模板类的专门构造函数

Question

Suppose that there are 3 classses:

template <typename T>
class X;


template <typename T>
class Y;


template <typename T>
class Z;

I wish to define a constructor for X which takes an object reference of type Z<T> and returns an object of type X<Y<T>> . Is this possible with a single template definition?

template <typename T>
X<Y<T>>::X(Z<T>) {
  // logic to map Z<T> to Y<T> and pass it on for object creation.
}

I guess there will be significant side-effects if I use two template definitions for defining the constructor.

Answer 1

Something like this?

template <class T>
class Z;

template <class T>
class Y;

template <class T>
class X
{
    X(Z&);
};

template<class T>
X<Y<T>> MakeX(Z<T>& z)
{
    return X<Y<T>>(z);
};

Answer 2

I am not sure whether you can accomplish what you want to using a single template class. However, you can use template specialization to accomplish what you are looking for.

Here's a minimal definition of such a class.

template <typename T> class X
{
};

template <typename T> class Y
{
};

template <typename T> class Z
{
};

template <typename T> class X<Y<T> >
{
   public:
      X(Z<T> z) {}
};


int main()
{
   Z<int> z;
   X<Y<int> > x(z);
}

Answer 3

Direct way to achieve this:

template <typename T>
class Y{};

template <typename T>
class Z{};

template <typename T>
class X
{
    template <typename U>
    X(U){}
};

template <typename T>
template <>
X<Y<T>>::X(Z<T>){}

Unfortunately, this code is not standard-compliant.

If you really don't want to use a helper function ( @Neil Kirk 's variant ) or specialize a whole class ( @R Sahu 's variant ) you may try the following variant using std::enable_if :

#include <type_traits>

template <typename T>
struct template_traits;

template
    <
        template <typename>
        class C,
        typename A
    >
struct template_traits<C<A>>
{
    using argument_type = A;
};

template
    <
        typename T,
        template <typename>
        class C
    >
struct is_instantiation_of : std::false_type{};

template
    <
        typename A,
        template <typename>
        class C
    >
struct is_instantiation_of<C<A>, C> : std::true_type{};


template <typename T>
class Y{};

template <typename T>
class Z{};

template <typename T>
class X
{
public:

    X(){}

    template
        <
            typename U = T,
            typename = typename std::enable_if<is_instantiation_of<U, Y>::value>::type
        >
    X(Z<typename template_traits<U>::argument_type>& z){}

};

Example of using:

Y<int> y_i;
Y<char> y_c;
Z<int> z_i;
Z<char> z_c;

X<int> x; // compiles
X<Y<int>> x1(z_i); // compiles
X<Y<int>> x2(z_c); // doesn't compile
X<Z<int>> x3(y_i); // doesn't compile
X<Z<int>> x4(y_c); // doesn't compile