模板类的专用构造函数

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's variant）或专门化整个类（@R Sahu's variant），您可以尝试以下变体使用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