继承与专业化

Question

考虑以下两种使用场景（正如您所看到的，即最终用户只会对使用 Vector2_t 和 Vector3_t 感兴趣）：

[1]继承：

template<typename T, size_t N> struct VectorBase
{
};

template<typename T> struct Vector2 : VectorBase<T, 2>
{
};

template<typename T> struct Vector3 : VectorBase<T, 3>
{
};

typedef Vector2<float> Vector2_t;
typedef Vector3<float> Vector3_t;

[2]专业化：

template<typename T, size_t N> struct Vector
{
};

template<typename T> struct Vector<T, 2>
{
};

template<typename T> struct Vector<T, 3>
{
};

typedef Vector<float, 2> Vector2_t;
typedef Vector<float, 3> Vector3_t;

我无法决定哪个是更好的解决方案。 继承的明显优点是派生类中的代码重用； 一个可能的缺点是性能（更大的尺寸，用户可能按值传递等）。 专业化似乎可以避免这一切，但代价是我不得不多次重复自己。

我还错过了哪些其他优点/缺点？您认为我应该走哪条路？

Answer 1

我认为你最终想要的是拥有用户类型

Vector<T, N>

并且根据N，用户会得到稍微不同的东西。 第一个无法实现这一点，但第二个可以，但代价是代码重复。

您可以做的是反转继承：

template<typename T, size_t N> struct VectorBase 
{
};

template<typename T> struct VectorBase<T, 2>
{
};

template<typename T> struct VectorBase<T, 3>
{
};

template<typename T, size_t N> struct Vector : VectorBase<T, N>
{
};

并实现仅依赖于 N 是适当基类中的某个特定值的少数函数。 您可以在其中添加受保护的析构函数，以防止用户通过指向 VectorBase 的指针删除 Vector 的实例（通常他们甚至不应该能够命名 VectorBase code>：将这些基础放在某个实现命名空间中，例如 detail）。

另一个想法是将这个解决方案与另一个答案中提到的解决方案结合起来。 私有继承（而不是如上所述的公开继承）并将包装器函数添加到调用基类的实现的派生类中。

另一种想法是仅使用一个类，然后使用 enable_if（使用 boost::enable_if）针对特定的 N 值启用或禁用它们，或者使用像这样简单得多的 int 到类型转换器

struct anyi { };
template<size_t N> struct i2t : anyi { };

template<typename T, size_t N> struct Vector
{
    // forward to the "real" function
    void some_special_function() { some_special_function(i2t<N>()); }

private:
    // case for N == 2
    void some_special_function(i2t<2>) {
        ...
    }

    // case for N == 3
    void some_special_function(i2t<3>) {
        ...
    }

    // general case
    void some_special_function(anyi) {
        ...
    }
};

这样，它对 Vector 的用户是完全透明的。 它也不会为编译器进行空基类优化（很常见）增加任何空间开销。

Answer 2

使用继承和私有继承。 并且不要使用任何虚函数。 由于使用私有继承，您没有 is-a，因此没有人能够使用指向派生子类的 baseclas 指针，并且在按值传递时不会遇到切片问题。

这为您提供了两全其美的好处（事实上，这就是大多数库实现许多 STL 类的方式）。

来自 http://www.hackcraft.net/cpp/templateInheritance/ （讨论 std： :vector，而不是您的 Vector 类）：

vector 被声明为具有
vector 的私有基数。
所有放置新元素的函数
进入向量，例如push_back()，调用
这个私人基地上的等效功能，
所以在内部我们的向量正在使用
用于存储的向量。 所有功能
它从向量中返回一个元素，例如
front()，在
调用等效函数的结果
在私人基地上。 因为获得的唯一途径是
指向 vector 的指针（除了
故意危险的伎俩）是通过
vector 提供的接口是安全的
将 void* 静态转换回 T*
（或将 void*& 返回到 T*&，依此类推）。

一般来说，如果 STL 这样做，它似乎是一个不错的模拟模型。

Answer 3

继承只能用于建模“is-a”。 专业化将是更清洁的选择。 如果您出于某种原因需要或想要使用继承，至少将其设为私有或受保护的继承，这样您就不会从具有公共非虚拟析构函数的类公开继承。

是的，模板元编程人员总是这样做，

 struct something : something_else {};

但那些东西是元函数，并不意味着用作类型。

Answer 4

您需要根据您的实际用例以及真正的公共接口应该是什么来确定以下问题的“正确”答案：

1. “Vector”是您的主要接口吗？公共接口还是实现细节？ 例如，人们是否应该使用这些对象，例如 std::vector 或者它只是隐藏“vector_2”真实 API 的常见实现逻辑的一种方法，等等.?

   


2. 所有“Vector”是否具有相同的逻辑行为？ 大多数人会告诉您在进行此类决策时遵循 STL，但 STL 本身却因 std::vector 而臭名昭著地搞砸了这一点。 他们被迫支持由此造成的混乱局面 30 年。

需要记住的一件事是，您可以将继承和模板特化结合起来； 它们并不相互排斥。 模板专业化应该对用户透明，这意味着它们应该具有与通用模板相同的公共接口和行为。

例如：

template <typename T, size_t N>
class VectorBase {
public:
    // The public interface all 'vector-like' classes must honor
    virtual T& at(size_t index) = 0;

    // More APIs... 
};

// The generic Vector<T,N> 
// Let's forbid inheritance from vectors, for now. 
template <typename T, size_t N> 
class Vector final : public VectorBase<T, N>
{
public: 
   // Have to implement the public interface 
   virtual T& at(size_t index) override;

   // Vector-only APIs
   virtual T* data();
};

// We've got some optimized way of storing, let's say doubles, that doesn't fit the general case
template <size_t N>
class Vector<double, N> final : public VectorBase<double, N>
{
public:
   // Same APIs as baseline Vector<T,N>
   virtual double& at(size_t index) override; 
};

// We DISABLE a specialization, e.g. Vector<bool, N> 
template <size_t N>
class Vector<bool, N> final : public VectorBase<bool, N>
{
};  // Nobody can ever create one of these. We never implemented the pure virtual APIs and we disabled inheritance.

// A different object that has a lot of interface overlap with Vector<T, N>
template <size_t N> 
class Bitset : public Vector<bool, N> 
{
public: 
   // From VectorBase 
   virtual bool& at(size_t index) override; 

   // Unique to me 
   virtual void  bitwise_not(); 
   virtual void  bitwise_or(const Bitset<N>& other); 
   //...
};

在通用“Vector”之间共享代码 及其专业，您有多种选择。 最直接的方法是将其放入基类的受保护函数中。

Answer 5

如果您过多地使用模板专业化，您可能需要重新考虑您的设计。 考虑到您将其隐藏在 typedef 后面，我怀疑您是否需要它。