Gfrktyl

I have a struct C which gets initialized with a variable number of instances of struct A and struct B. E.g.:

struct A

{};



struct B

{};



struct C

{

    C(A&& o1, B&& p1, A&& o2)

    {}

    C(A&& o1, B&& p1, A&& o2, B&& p2, A&& o3)

    {}

    C(A&& o1, B&& p1, A&& o2, B&& p2, A&& o3, B&& p3, A&& o4)

    {}

    C(A&& o1, B&& p1, A&& o2, B&& p2, A&& o3, B&& p3, A&& o4, B&&p4, A&& o5)

    {}

};

So, rather than providing multiple ctor's with different number of parameters I would like to find something generic.
However, the number of ctor parameters always grows about two parameters: B&& and A&&.
Could this be accomplished using parameter packs. Or would be another solution without implementing for each number of parameters an according ctor?

The goal should be that struct C can be constructed like the following examples:

C c1 = { A(), B(), A() };

C c2 = { A(), B(), A(), B(), A(), B(), A() };

etc.

You can use a variadic template and SFINAE to enable only the constructor where the type parameters satisfy your (or any arbitrary) condition.

#include <type_traits>

struct A {};

struct B {};

You need type_traits for std::false_type and std::true_type.

The alternates template is the key. The goal is to make alternates<X, Y, T1, T2, T3, ..., Tn> inherit from std::true_type if and only if the T1, ... Tn list is alternating X and Y. The default choice (just below) is no, but we specialize for matching cases.

template <typename X, typename Y, typename... Ts>

struct alternates : std::false_type {};

I choose to make this template more generic than your requirement here and allow alternates<X, Y> to inherit from true_type. The empty list satisfies the mathematical requirement that all elements of it alternate. This will be a good stopgap for the recursive definition below.

template <typename X, typename Y>

struct alternates<X, Y> : std::true_type {};

Any other list of alternates<X, Y, Ts...> alternates if and only if Ts... minus the first element alternate Y and X (Y first!).

template <typename X, typename Y, typename... Ts>

struct alternates<X, Y, X, Ts...>

: alternates<Y, X, Ts...> {};



struct C

{

We define the constructor as a template that first takes a parameter pack (the type will be deduced, no need to specify when calling) and it has a defaulted template parameter for SFINAE purposes. If the defaulted argument cannot be calculated based on the parameter pack, the constructor will not exist. I added the extra conditions about the number of pairs which I assumed from the example.

    template<typename... Ts,

        typename = typename std::enable_if<

            sizeof...(Ts) % 2 == 1 &&

            sizeof...(Ts) >= 3 && // did you imply this?

            alternates<A, B, Ts...>::value

        >::type>

    C(Ts&&...);

};

The way SFINAE works is that std::enable_if only defines the std::enable_if<condition, T>::type (the ::type part) if condition is true. That can be any arbitrary boolean expression computable at compile time. If it is false, saying ::type at the end will be a substitution failure and the overload where you tried to use it (e.g., C{A(), A(), A()}) will simply not be defined.

You can test that the examples below work as expected. The ones commented out are not expected to work.

int main() {

    C c1 { A(), B(), A() };

    C c2 { A(), B(), A(), B(), A(), B(), A() };

    // C c3 {};                     // I assumed you need at least 2

    // C c4 { A(), B(), A(), A() }; // A, A doesn't alternate

    // C c5 { B(), A(), B() };      // B, A, B not allowed

    // C c6 { A(), B(), A(), B() }; // A, B, A, B doesn't pair

}

Try the code here.

I suppose you can use a template delegating constructor

Something as follows

#include <utility>



struct A {};

struct B {};



struct C

 {

   C (A &&)

    { }



   template <typename ... Ts>

   C (A &&, B &&, Ts && ... ts) : C(std::forward<Ts>(ts)...)

    { }

 };



int main()

 {

   C(A{});

   C(A{}, B{}, A{});

   C(A{}, B{}, A{}, B{}, A{});

   C(A{}, B{}, A{}, B{}, A{}, B{}, A{});

 }

If you require at least three element (so no C(A{}) but at least C(A{}, B{}, A{})) the not-template constructor become

   C (A &&, B &&, A&&)

    { }

Maybe something like this would help...

#include <iostream>

#include <vector>

#include <utility>



// Simple classes A & B to represent your alternating pattern classes.

class A{ public: int a; };

class B{ public: int b; };



// helper class template to act as a single parameter kind of like std::pair...

template<typename T, typename U>

class Pack{

private:

    T t_;

    U u_;



public:

    Pack( T&& t, U&& u ) : 

      t_( std::move( t ) ),

      u_( std::move( u ) )

    {}



    T getT() const { return t_; }

    U getU() const { return u_; }        

};



// your class with varying amount of parameters for its ctors

template<class T, class U>

class  C{

private:

    std::vector<Pack<T,U>> packs_;



public:

    template<typename... Packs>

    C( Packs&&... packs  ) : packs_{ std::move( packs )... } { }



    std::vector<Pack<T,U>> getPacks() const {

        return packs_;

    }

};



// A few overloaded ostream operator<<()s for easy printing...

std::ostream& operator<<( std::ostream& os, const A& a ) {

    os << a.a;

    return os;

}



std::ostream& operator<<( std::ostream& os, const B& b ) {

    os << b.b;

    return os;

}



template<typename T, typename U>

std::ostream& operator<<( std::ostream& os, const Pack<T,U>& pack ) {

    os << pack.getT() << " " << pack.getU() << 'n';

    return os;

}



// Main program to demonstrate its use

int main() {    

    Pack<int,double> p1( 1, 2.3 ), p2( 4, 9.2 ), p3( 5, 3.5 );        

    C<int, double> c( p1, p2, p3 );    

    for (auto& p : c.getPacks() )

        std::cout << p;



    std::cout << 'n'; 



    Pack<float, char> p4( 3.14f, 'a' ), p5( 6.95f, 'b' ),

                      p6( 2.81f, 'c' ), p7( 8.22f, 'd' );

    C<float, char> c2( p4, p5, p6, p7 );

    for ( auto& p : c2.getPacks() )

        std::cout << p;    



    return 0;

}

Working Code

-Output-

1 2.3

4 9.2

5 3.5



3.14 a

6.95 b

2.81 c

8.22 d

-Note- I did not incorporate for any odd number of parameters. For a more detailed solution with odd cases you can refer to the other answers with SFINAE or Delegating Constructor.