具有专门构造函数的模板类

Question

考虑以下人为设计的模板化数组定义示例：

template <typename t, unsigned int n> class TBase
{
protected:
    t m_Data[n];

    //...
};

template <typename t, unsigned int n> class TDerived : public TBase<t, n>
{
    TDerived()
    {
    }
};

我可以专门为这个类型提供一个长度为 2 的数组的非默认构造函数，如下所示：

template <typename t> class TDerived<t, 2> : public TBase<t, 2>
{
public:
    TDerived(const t& x0, const t& x1)
    {
        m_Data[0] = x0;
        m_Data[1] = x1;
    }
};

int main()
{
    TDerived<float, 2> Array2D_A(2.0f, 3.0f); //uses specialised constructor
    TDerived<float, 3> Array3D_A;             //uses default constructor

    return 0;
}

是否有其他方法可以创建一个类，该类具有不同的构造函数选项，在编译时受模板参数约束，而无需为每个变体提供完整的类专业化？

换句话说，有没有什么方法可以在TBase 类中使用专门的构造函数，而无需创建TDerived 的中间步骤，同时保留TBase 的功能？

Answer 1

我认为从基类派生您的类与这里的问题无关，这仅仅是实现细节。您真正想要的是是否有一种方法可以部分专门化成员函数，例如构造函数。你想要这样的东西吗？

template <typename T, int N> class Foo
{
    Foo(); // general
    template <typename U> Foo<U, 2>(); // specialized, NOT REAL CODE
};

这不起作用。你总是必须专攻整个班级。原因很简单：您必须首先了解类的完整类型，然后才能知道存在哪些成员函数。考虑以下简单情况：

template <typename  T> class Bar
{
  void somefunction(const T&);
};

template <> class Bar<int>
{
  double baz(char, int);
};

现在Bar<T>::somefunction() 依赖于T，但该函数仅在T 不是int 时存在，因为Bar<int> 是一个完全不同的类。

或者考虑另一个特化template <> class Bar<double> : public Zip {};——甚至一个类的多态性质在特化中也可能完全不同！

因此，您可以提供 specializations 成员的新声明（包括构造函数）的唯一方法是专门化整个类。 （您可以专门化现有函数的定义，请参阅@Alf 的回答。）

Answer 2

我看到的基本上有两种选择：

• 使用可变参数函数进行构造（即“...”表示法），您可以使用该函数中的值 n 从堆栈中获取参数。但是，编译器不会在编译时检查用户是否提供了正确数量的参数。

• 使用一些严肃的模板魔法来允许调用 chaning 初始化，看起来像这样：vector(2.0f)(3.0f)。您实际上可以构建至少确保用户不会在此处提供太多参数的东西。不过这个机制有点复杂，如果你愿意，我可以组装一个例子。

Answer 3

你总是可以专门化一个成员，例如

#include <stdio.h>

template< class Type >
struct Foo
{
    void bar() const
    { printf( "Single's bar.\n" ); }
};

template<>
void Foo< double >::bar() const
{ printf( "double's bar.\n" ); }

int main()
{
    Foo<int>().bar();
    Foo<double>().bar();
}

但是你想要有效地不同的签名，所以这不是专门化成员的直接情况。

然后一种方法是声明一个带有单个参数的构造函数，其类型取决于模板参数。

然后，您可以根据需要进行专业化。

干杯，

Answer 4

由于构造函数是一个函数，您需要完全专门化包含类来解决您的特定问题。没有出路。

但是，函数不能部分特化（在所有编译器中）。所以假设如果你知道你需要n = 2 而t = int or double 那么下面是一种选择。

template<>
TDerived<int,2>::TDerived()
{
  //...
}
template<>
TDerived<double,2>::TDerived()
{
  //...
}

等等。

[注：如果你使用MSVC，那么我认为它支持偏特化；在这种情况下，您可以尝试：

template<typename t>
TDerived<t,2>::TDerived()
{
  //...
}

不过，我对此不太确定。]

Answer 5

您可以在非专业类中给出最常见的定义，并在数组长度上给出static_assert（非 C++0x 的 BOOST_STATIC_ASSERT）。这可能被认为是一种 hack，但它是解决您的问题的简单方法且安全。

template<typename T, unsigned int n>
struct Foo {
  Foo(const T& x) { static_assert(n == 1, "Mooh!"); }
  Foo(const T& x1, const T& x2) { static_assert(n == 2, "Mooh!"); }
};

“邪恶”的方式是可变参数。

template<typename T, unsigned int n>
struct Foo {
  Foo(...) { 
    va_list ap;
    va_start(ap, n);
    for(int j=0; j < n; ++j)
      bork[j] = va_arg(ap, T);
    va_end(ap);
  }
};

还有 C++0x 和古老的 make_something 技巧，这比人们想象的要难。

template<typename... T, unsigned int n>
Foo<T, n> make_foo(T&&...) {
  // figure out the common_type of the argument list
  // to our Foo object with setters or as a friend straight to the internals
  Foo< std::common_type< T... >::type, sizeof(T) > foo;
  // recursive magic to pick the list apart and assign 
  // ...
  return foo;
}