Is is possible to create a composite constructor without tuples? - c++

Question

I know that I can expand a parameter pack of tuples onto a variadic template of base classes
like this:
#include <tuple>
struct ComponentA {
int foo;
int bar;
ComponentA(std::tuple<int, int> && pack):
foo(std::get<0>(pack)),
bar(std::get<1>(pack))
{}
};
struct ComponentB {
ComponentB(std::tuple<> && pack)
{}
};
template<typename ... Bases>
struct CompositeClass: public Bases... {
template<typename ... Arguments>
CompositeClass(Arguments &&... arguments):
Bases(std::forward<Arguments>(arguments))...
{}
};
int main() {
CompositeClass<ComponentA, ComponentB> composite{
std::make_tuple(100, 100),
std::make_tuple()
};
}
However, I find that syntax cumbersome. Is there a way to avoid the tuples altogether?
Edit:
Something more like this:
struct ComponentA {
int foo;
int bar;
ComponentA(int a, int b):
foo(a),
bar(b)
{}
};
struct ComponentB {
ComponentB()
{}
};
template<typename ... Bases>
struct CompositeClass: public Bases... {
template<typename ... ... Arguments>
CompositeClass(Arguments &&... ... arguments):
Bases(std::forward<Arguments>(arguments)...)...
{}
};
int main() {
CompositeClass<ComponentA, ComponentB> composite{100, 100};
}
Both parameters are passed to ComponentA, none to ComponentB.
Edit 2
So I have got something like this:
template <int ...>
struct SequenceContainer {};
template <int, typename>
struct AppendIntToSequence;
template <int Value, int ... Sequence>
struct AppendIntToSequence<Value, SequenceContainer<Sequence...>> {
typedef SequenceContainer<Sequence..., Value> type;
};
template<int End>
struct MakeSequence:
AppendIntToSequence<End - 1, typename MakeSequence<End - 1>::type> {};
template<>
struct MakeSequence<0> {
typedef SequenceContainer<> type;
};
struct ComponentA {
static const int parameters = 2;
ComponentA(int && a, int && b) {
std::cout << a << b << std::endl;
}
};
struct ComponentB {
static const int parameters = 1;
ComponentB(const char * string) {
std::cout << string << std::endl;
}
};
template <typename Base>
struct TupleConstructor: Base {
template <typename ... Arguments, int ... Sequence>
TupleConstructor(std::tuple<Arguments...> &&, SequenceContainer<Sequence...> const &);
};
template <typename Base>
template <typename ... Arguments, int... Sequence>
TupleConstructor<Base>::TupleConstructor(std::tuple<Arguments...> && arguments, SequenceContainer<Sequence...> const &):
Base(std::forward<Arguments>(std::get<Sequence>(arguments))...)
{}
template <typename ... Components>
struct CompositeClass: public TupleConstructor<Components>... {
template <typename ... Arguments>
CompositeClass(Arguments &&... arguments):
TupleConstructor<Components>(
std::forward<Arguments>(arguments),
typename MakeSequence<std::tuple_size<Arguments>::value>::type{}
)...
{}
};
int main()
{
CompositeClass<ComponentA, ComponentB> composite{
std::tuple<int &&, int &&>(100,100),
std::tuple<const char *>("Hello World!")
};
However, I haven't been able to figure out how to remove the two tuples from the CompositeClass constructor. How can this be done?

Answer 1

It seems, if you cut down a bit on sprinkling periods all over the place you should be OK! Parameter packs aren't anything particular special: they are just expanded into a comma separate list. That is, if you change your code to become that below you should be OK:
template <typename... Bases>
struct CompositeClass: public Bases... {
template <typename... Arguments>
CompositeClass(Arguments&&... arguments):
Bases(std::forward<Arguments>(arguments))...
{}
};
Except for adding a colon in front of the initializer list I have only removed some excess "...". This works OK as long as all your template arguments are actually class types and as long as they happen to be different. Obviously, types which aren't classes can't be used as bases. If You need the same type multiple times as base you need to inherit them indirectly why an auxiliary type which gives them a number. Generating the numbers is a bit tricky the first few times you do it but nothing really magically either.
Expanding on the edited question: You mean, you want to pass lists of arguments to each individual base class constructor? If it is OK to pass in std:tuple<...> as arguments to your CompositeClass this is doable, too. Essentially, you need to transform each std::tuple<...> into a list of arguments. This also requires the generation of said indices. I would at least start off with an auxiliary base which takes a std::tuple<...> as argument and forwards the members as arguments to the base. This would use something similar to the code above for the CompositeClass and the main trick would be in an auxiliary class:
template <int... Numbers> struct Sequence {};
template <int N> struct MakeSequence;
template <typename Base>
struct AuxiliaryBase: Base {
template <typename Tuple, int... Numbers>
AuxiliaryBase(Tuple&&, Sequence<Numbers...> const&);
};
template <typename... Bases>
struct CompositeClass: public AuxiliaryBase<Bases>... {
template <typename... Args>
CompositeClass(Args&&... arguments):
AuxiliaryBase<Bases>(std::forward<Args>(arguments),
typename MakeSequence<std::tuple_size<Args>::size>())...
{}
};
Implementing the constructor of AuxiliaryBase essentially requires that there is a facility creating a sequence of integers from 0 to std::tuple_size<Tuple>::value. This take a bit tweaking but is definitely doable. To make them available an auxiliary parameter is passed in (I'm not sure if this can be avoided; well, probably it can be packaged as a type with the std::tuple<...> if this should be avoided). With this, the base class constructor is fairly straight forward:
template <typename Base>
template <typename Tuple, int... Numbers>
AuxiliaryBase<Base>::AuxiliaryBase(Tuple&& tuple, Sequence<Numbers...> const&):
Base(std::get<Numbers>(tuple)...)
{}
I haven't tested it but something along these lines should actually work. What this version doesn't do is perfect forwarding of the members in the std::tuple<...>: for this you would need a variation of std::forward<>() which takes three arguments which uses the reference qualifications of the outer type to determine which kind of reference needs to be forward for the member. I haven't tried this but it is probably an interesting exercise as well.
I haven't tried to compile this particular example but I have definitely done something like this in the past: if you look the slides for the presentation I gave at the ACCU conference in 2010 you will find all the details on how to do this (including how to create a sequence of integers; a very short of this, actually).