c++ - 继承的部分特化。我可以避免继承吗？

Question

我正在编写一个 vector 类，我希望它具有以下特征:

1. 尽可能在堆栈上使用静态分配(以避免调用 new 以提高效率)。
2. 如果用户更愿意提供先前分配的数组，则能够从指针实例化。
3. 该类需要轻松转换为简单的指针。这允许使用以前用 C 编写的例程。

在下面找到这个简单的测试问题以及我提出的解决方案。我使用继承，因此 Vector 继承自 Vector_base，它为所有 vector 提供了一个公共(public)接口(interface)(纯虚拟)。然后我定义了一个空类 Vector，它允许我使用部分特化来拥有不同的存储方案；静态或动态。

这背后的想法是，我只希望 vector 成为老式静态数组的 C++ 包装器。

我喜欢下面的实现。我想保留我在 main 中想出的界面。

我不喜欢的是 sizeof(Vector3) = 32，而在 C 中，三个 double 值的 vector 是 24 字节。原因是虚拟表多了8个字节。

我的问题:我能否想出另一种设计来为我提供相同的界面，但 vector 只有 24 个字节？

总结:

1. 我想要一个 24 字节的 Vector3，就像在 C 中一样。
2. 不过我仍然想要任意大的 vector (使用 <double,n> )
3. 我想保留 main() 中使用的接口(interface)。

我可以为此使用特征或策略之类的编程习惯用法吗？我对这些人很陌生，我不知道他们是否可以提供解决方案。

在下面找到我的小测试代码:

#include <iostream>
using namespace std;

#define TRACE0(a) cout << #a << endl; a;
#define TRACE1(a) cout << #a "=[" << a << "]" << endl;

enum alloc_type {Static,Dynamic};

template <class T>
class Vector_base{
public:
  Vector_base(){}
  virtual operator T*() = 0;
  virtual T operator[](int i)const = 0;
  virtual T& operator[](int i) = 0;
  virtual int size() const = 0;
  friend ostream& operator<<(ostream &os,const Vector_base& v){
    for (int i=0; i<v.size(); i++)
      cout << v[i] << endl;
    return os;
  }
};

// base template must be defined first
template <class T, int n,alloc_type flg=Static>
class Vector{};

//Specialization for static memory allocation.
template <class T, int n>
class Vector<T,n,Static>: public Vector_base<T>{
public:
  T a[n];
public:
  Vector() { 
    for (int i=0; i<n; i++) a[i] = 0; 
  }
  int size()const{return n;}
  operator T*(){return a;}
  T operator[](int i)const {return a[i];}
  T& operator[](int i){return a[i];}
};

//Specialization for dynamic memory allocation
template <class T,int n>
class Vector<T,n,Dynamic>: public Vector_base<T>{   //change for enum. flg=0 for static. flg=1 for dynamic. Static by default
public:
  T* a;
public:  
  Vector():a(NULL){
  }  
  Vector(T* data){ //uses data as its storage
    a = data;
  }
  int size()const{return n;}
  operator T*(){return a;}
  T operator[](int i)const {return a[i];}
  T& operator[](int i){return a[i];}
};

//C++11 typedefs to create more specialized three-dimensional vectors.
#if (__cplusplus>=201103L)
template <typename Scalar,alloc_type flg=Static>
using Vector3 = Vector<Scalar,3,flg>;
#else
#error A compiler with the C++2011 standard is required!
#endif

int main(){

  cout << "Testing Vector3: " << endl;

  //Vector<double,3> v3;
  Vector3<double> v3;
  TRACE0(cout << v3 << endl;);
  TRACE1(sizeof(v3));

  //Vector<double,3,Dynamic> v0(v3);
  Vector3<double,Dynamic> v0(v3); //calls Vector<double,3,Dynamic>::Vector(double*) and uses the conversion operator on v3.
  TRACE1(sizeof(v0));
  TRACE1(sizeof(double*));

  TRACE0(v3[1] = 2.1;);
  TRACE0(cout << v0 << endl;);

  return 0;
}

Answer 1

您需要的所有功能都作为标准提供，或者可以插入现有的标准扩展点。

Use static allocation on the stack whenever possible (to avoid calling new for efficiency).

见面 std::array<T, N> .它是 C 数组上的 C++ 包装器，具有所有相同的特征。

Be able to be instantiated from a pointer if the user prefers to provide a previously allocated array.

认识分配器。您可以编写满足返回已分配内存要求的分配器，然后只需使用 std::vector .这样的分配器正在考虑用于 future 的标准以及其他分配器增强功能，如多态分配器。

The class needs to be easily converted to a simple pointer. This allows to use previously written routines in C.

两者都是 std::vector 和 std::array 将此作为微不足道的事情提供。

如果您想在运行时提供此选择，请考虑 boost::variant .滚动你自己的受歧视的 union - 不建议。