Question

I’d like to be able to construct an A or B without having to think about the number of constructor arguments.

The second constructor is not legal C++ but I wrote it like this as an attempt to express what I want.

Is there an enable_if trick to selectively enable one of the constructors?

(e.g. depending on the number of constructor arguments of A and B.)

I need this to test about 15 classes with 1, 2 or 3 constructor arguments.

struct A
{
    A(int x)
    {
    }
};

struct B
{
    B(int x, int y)
    {
    }
};

template<typename T>
struct Adaptor // second constructor is illegal C++.
{
    T t;

    Adaptor(int x, int y)
        : t(x)
    {
    }

    Adaptor(int x, int y) // error: cannot be overloaded
        : t(x, y)
    {
    }
};

int main()
{
    Adaptor<A> a(1,2);
    Adaptor<B> b(1,2);

    return 0;
}

Answer 1

A variant of @Aaron’s approach:

#include <type_traits>
#include <utility>

enum EArity { EZero = 0, EOne, ETwo, EThree, Error };

template <typename T, typename A1, typename A2, typename A3> struct getArity
{
    static const EArity arity =
       std::is_constructible<T>::value             ? EZero  :
       std::is_constructible<T, A1>::value         ? EOne   :
       std::is_constructible<T, A1, A2>::value     ? ETwo   :
       std::is_constructible<T, A1, A2, A3>::value ? EThree : Error;
};

template <typename T, EArity A> struct Construct;

template <typename T> struct Construct<T, EZero>
{
    T t;

    template <typename A1, typename A2, typename A3>
    Construct(A1 && a1, A2 && a2, A3 && a3) : t() { }
};

template <typename T> struct Construct<T, EOne>
{
    T t;

    template <typename A1, typename A2, typename A3>
    Construct(A1 && a1, A2 && a2, A3 && a3) : t(std::forward<A1>(a1)) { }
};

// ...

template <typename T>
struct AdapterIntIntInt : Construct<T, getArity<T, int, int, int>::arity>
{
    Adapter(int a, int b, int c)
    : Construct<T, getArity<T, int, int, int>::arity>(a, b, c) { }
};

template <typename T, typename A1, typename A2, typename A3>
struct Adapter : Construct<T, getArity<T, A1, A2, A3>::arity>
{
    Adapter(A1 && a1, A2 && a2, A3 && a3)
    : Construct<T, getArity<T, A1, A2, A3>::arity>
      (std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3))
    { }
};