模板類的專門構造函數

Question

假設有3個類別：

template <typename T>
class X;


template <typename T>
class Y;


template <typename T>
class Z;

我希望為X定義一個構造函數，該構造函數采用Z<T>類型的對象引用並返回X<Y<T>>類型的對象。 單個模板定義可以做到嗎？

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

我想如果我使用兩個模板定義來定義構造函數，將會產生明顯的副作用。

Answer 1

像這樣嗎

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

我不確定您是否可以使用單個模板類來完成所需的工作。 但是，您可以使用模板專業化來完成所需的工作。

這是此類的基本定義。

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

實現此目的的直接方法：

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>){}

不幸的是，該代碼不符合標准。

如果您真的不想使用輔助函數（ @Neil Kirk的變體 ）或專門研究整個類（ @R Sahu的變體 ），則可以使用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){}

};

使用示例：

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