c++ - 混合部分模板特化和默认模板参数

Question

我想创建一个通用 vector 类并为一些情况创建特化。像这样的东西(它不编译，但希望传达我的意图):

template<int dim, typename T = float>
class Vector
{
public:
    typedef Vector<dim, T> VecType;

    Vector() { /**/ }
    Vector(const VecType& other) { /**/ )
    Vector& operator=(const VecType& other) { /**/ }

    VecType operator+(const VecType& other) { /**/ }    
    VecType operator-(const VecType& other) { /**/ }    
    T operator*(const VecType& other) { /**/ }

private:
    std::array<T, dim> elements;
};

template<int dim, typename T>
class Vector<2>
{
public:
    T x() const { return elements[0]; }
    T y() const { return elements[1]; }
};

template<int dim, typename T>
class Vector<3>
{
public:
    T x() const { return elements[0]; }
    T y() const { return elements[1]; }
    T z() const { return elements[2]; }
};

换句话说，我希望元素的默认类型为 float 并且我希望有 x() 和 y() dim = 2 情况下的访问器方法，以及 x()、y() 和 z()对于 dim = 3 情况。我对错误消息有点困惑:

vector.h:56:10: error: declaration of ‘int dim’

vector.h:6:10: error: shadows template parm ‘int dim’

(与 T 相同)。

我怎样才能正确地做到这一点？ (如果可能的话)

Answer 1

1.

当部分特化模板时，只提供实际上是参数的模板参数。因为你已经修复了 dim为2或3，无需再次指定。

template<typename T>
class Vector<2, T>
{
   ....

2.

特化一个类实际上意味着改变整个声明。因此，泛型 Vector<dim, T> 的成员 s将不会在专门的 Vector<2, T> 中提供.你可以制作通用的 Vector<dim, T>作为一个内部基类，并创建一个专门用于特化的子类:

template<int dim, typename T>
class VectorImpl;

...

template<int dim, typename T = float>
class Vector : public VectorImpl<dim, T> {};

template<typename T>
class Vector<2, T> : public VectorImpl<2, T>
{
public:
   T x() const { ... }
};

3.

您不需要定义 VecType !在模板中，您可以只使用 Vector .它将自动推断为引用具有正确参数的类。

编译的最终结果:

#include <array>

template<int dim, typename T>
class VectorImpl
{
public:
    //typedef Vector<dim, T> VecType;

    VectorImpl() {  }
    VectorImpl(const VectorImpl& other) {  }
    VectorImpl& operator=(const VectorImpl& other) { return *this; }

    VectorImpl operator+(const VectorImpl& other) { return *this; }
    VectorImpl operator-(const VectorImpl& other) { return *this; }
    T operator*(const VectorImpl& other) { return 0; }

protected:
    std::array<T, dim> elements;
};

template <int dim, typename T = float>
class Vector : public VectorImpl<dim, T> {};

template<typename T>
class Vector<2, T> : public VectorImpl<2, T>
{
public:
    T x() const { return this->elements[0]; }
    T y() const { return this->elements[1]; }
};

template<typename T>
class Vector<3, T> : public VectorImpl<2, T>
{
public:
    T x() const { return this->elements[0]; }
    T y() const { return this->elements[1]; }
    T z() const { return this->elements[2]; }
};

int main()
{
    Vector<2> v;
    Vector<3> vv;
    v + v;
    vv.z();
}