模板变量

Question

我目前有以下非模板代码：

class Vector{ 
  public:
    double data[3];
 };
static Vector *myVariable;
void func() {
  myVariable->data[0] = 0.;
}
int main() {
  myVariable = new Vector();
  func();
}

然后我想模板化维度：

template<int DIM> class Vector{ 
  public:
    double data[DIM];
 };
static Vector<3>* myVariable;
void func() {
  myVariable->data[0] = 0.;
}
int main() {
  myVariable = new Vector<3>();
  func();
}

但我最后也想用维度模板化我的变量：

template<int DIM> class Vector{ 
  public:
    double data[DIM];
 };
template<int DIM> static Vector<DIM> *myVariable;

void func() {
  myVariable->data[0] = 0.;
  // or perform any other operation on myVariable
}
int main() {
  int dim = 3; 

  if (dim==3)
    myVariable = new Vector<3>();
  else
    myVariable = new Vector<4>();

  func();
}

但是，最后一个版本的代码产生了一个错误：这个静态变量不能被模板化（“C2998: Vector *myVariable cannot be a template definition”）。

如果没有完全重新设计，我怎么可能纠正这个错误（比如从非模板类继承模板化 Vector 类，这将需要对虚拟方法进行更昂贵的调用，或者手动创建多个不同维度的 myVariables）？也许我只是累了，没有看到明显的答案：s

编辑：请注意，此代码是显示错误的最小工作代码，但我的实际实现模板化了完整计算几何类的维度，因此我不能只用数组替换 Vector。我发现我的问题似乎没有解决方案。

谢谢！

Answer 1

已经有一段时间了，但我以前在模板声明中使用过常量。我最终朝着另一个方向发展，所以我也不知道它最终是否会成为你的解决方案。我认为这里的问题是任何模板化变量都必须在编译时知道它的模板参数。

在您的示例中，Vector<3> 和 Vector<4> 是不同的类型，不能分配给同一个变量。这就是为什么template<int DIM> static Vector<DIM> *myVariable 没有任何意义；它没有可辨别的类型。

Answer 2

template<int DIM> static Vector<DIM> *myVariable;

语言规范不允许这样做。故事结束。

而且由于我不了解您的代码的目的或您想要实现的目标，因此我无法提出比简单地建议您尝试使用更好的替代方案std::vector<T>。这也是因为我不知道我可以在多大程度上重新设计您的代码，以及您使用它的方式，以使您的代码正常工作。

Answer 3

您可以使用std::array 模板化维度，但您不能将一个维度的指针转换为另一个维度的指针。

Answer 4

我想我找到了！

template<int DIM> class Vector{ 
  public:
    double data[DIM];
 };
static void *myVariable;

template<int DIM>
void func() {
((Vector<DIM>*)myVariable)->data[0] = 0.;
  // or perform any other operation on myVariable
}
int main() {
  int dim = 3; 

  if (dim==3)
  {
    myVariable = (void*) new Vector<3>();
    func<3>();
  }
  else
  {
    myVariable = (void*) new Vector<4>();
    func<4>();
   }


}

Answer 5

Vector<3> 和Vector<4> 是完全不同的类型，并且彼此之间没有正式关系。从您的角度来看，它们表面上相似这一事实并不重要。

如果您希望它们与某种类型等效，我们有一个名称：interfaces

template <typename Scalar = float>
class BasicVector {
public:
    typedef Scalar * iterator;
    virtual ~ BasicVector () {}

    virtual size_t   size  () const = 0;
    virtual iterator begin ()       = 0;
    virtual iterator end   ()       = 0;
};

template <unsigned N, typename Scalar = float>
class Vector : public BasicVector <Scalar> {
    Scalar m_elements [N];
public:
    using Scalar :: iterator;
    size_t   size  () const {return N;}
    iterator begin ()       {return m_elements;}
    iterator end   ()       {return m_elements + N;}
};

int main () {
    BasicVector * a;
    a = new Vector <3>;
    a = new Vector <4>;
}