继承与类模板专业化。设计老兄

Question

我有一个实现设计问题。我希望你能帮助我。假设我有以下课程

class A
{
public:
    vector<int> v() const { return m_v; }
    bool isValid() const { return m_v.size() > m_components; }
    int operator [] (const int index) const { return m_v[index]; }
    ...
private:
    vector<int> m_v;
    int m_components;
}

现在我希望m_v 向量可以是不同的类型，所以我可以模板类：

template<typename T>
class A
{
public:
    vector<T> v() const { return m_v; }
    T operator [] (const int index) const { return m_v[index]; }
    ...
private:
    vector<T> m_v;
    int m_components;
}

但是，我意识到当 T 类型为 double 时，我需要扩展类 A 并添加更多属性，例如另一个 vector<bool> m_foo; 并更改应使用这些新属性的几个方法。

这是我有疑问的地方。我想我有几个选择：

选项1：我可以创建一个非模板基类A，实现所有常用方法，并为每种不同类型派生多个类（具有自己的特定类属性和方法实现），即：Aint, Adouble, Afloat。此选项要求 vector<...> m_v; 存储在每个派生类中，因此我必须多次复制所有相同的代码才能访问每个派生类中的 m_v; 属性。例子中只有v()、operator []和isValid()这样的方法，但在实际问题中还有更多。

选项 2： 模板专业化。我可以为每种类型专门化类模板，因此只提供根据T 类型更改的特定方法的实现。但是，这会强制在模板类中存储大量内容，这些内容仅在 T 为特定类型时使用，即仅在 T 类型为 double 时使用的 m_foo 向量（在建议的例子）。因此，我在浪费内存。此外，实现模板类并为几乎大多数模板类型提供模板类专业化并存储仅用于特定类型的特定属性似乎不是很优雅甚至连贯。

我不知道我是否能很好地解释我的问题。希望如此。

提前谢谢你。 哈维尔。

Answer 1

我会尝试用一个与我的实际问题非常接近的例子来阐述这个问题，尽管它会变得更长。

选项1：考虑以下基于模板和模板特化的类实现。

template<typename T>
class A
{
public:
   A() {}
   vector<T> v() const { return m_v; }
   bool isValid() const  { return m_v.size() >= m_components; }
   T  operator [] (const int i) const { return m_v[i]; }
   T& operator [] (const int i)       { return m_v[i]; }
   int components() const { return m_components; }
   double value() const { return m_value; }
   void method1();
private:
   vector<T> m_v;
   int m_components;
   double m_value;
   vector<bool> m_indices;    // this is only used when T is int
   map<int, char> m_map;      // this is only used when T is double
   queue<int> m_queue;        // this is only used when T is bool
};

template<>
void A<int>::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   // stuff only for int case
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_indices[i] = true : m_indices[i] = false; }
}
template<>
void A<double>::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   // stuff only for double case
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_map[i] = 'e' : m_map[i] = 'o'; }
}
template<>
void A<bool>::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   // stuff only for bool case
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_queue.push(1) : m_queue.push(0); }
}

如您所见，无论T 类型如何，都有几种常用方法，并且涉及使用m_v 向量（方法：v()、isValid()、operator[]）。但是，还有其他方法（method1()）根据T类型有特定的实现，也需要根据这种类型使用特定的数据结构（queues，maps，vectors） .我在课堂上看到队列、地图、向量等的定义非常非常丑陋，尽管它们是否仅用于具体情况，具体取决于 T 类型。

选项 2： 另一种选择：

class A
{
public:
   A() {}
   int components() const { return m_components; }
   double value() const { return m_value; }
   virtual void method1() == 0;
protected:
   int m_components;
   double m_value;
};

/***** Derived A for int case ****/
class Aint : public A
{
public:
   Aint() {}
   vector<int> v() const { return m_v; }
   bool isValid() const  { return m_v.size() >= m_components; }
   int  operator [] (const int i) const { return m_v[i]; }
   int& operator [] (const int i)       { return m_v[i]; }

   void method1();
private:
   vector<int> m_v;
   vector<bool> m_indices;
};
void Aint::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_indices[i] = true : m_indices[i] = false; }
}

/***** Derived A for double case ****/
class Adouble : public A
{
public:
   Adouble() {}
   vector<double> v() const { return m_v; }
   bool isValid() const  { return m_v.size() >= m_components; }
   double  operator [] (const int i) const { return m_v[i]; }
   double& operator [] (const int i)       { return m_v[i]; }

   void method1();
private:
   vector<double> m_v;
   map<int, char> m_map;
};
void Adouble::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_map[i] = 'e' : m_map[i] = 'o'; }
}

/***** Derived A for bool case ****/
class Abool : public A
{
public:
   Abool() {}
   vector<bool> v() const { return m_v; }
   bool isValid() const  { return m_v.size() >= m_components; }
   bool  operator [] (const int i) const { return m_v[i]; }
   bool& operator [] (const int i)       { return m_v[i]; }

   void method1();
private:
   vector<bool> m_v;
   queue<int> m_map;
};
void Abool::method1()
{
   for (int i = 0; i < m_components; ++i) m_v.push_back(i);
   for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_queue.push(1) : m_queue.push(0); }
}

如您所见，在这种情况下，类型特定的数据结构（queues、maps 等）仅针对其需要的情况定义（不在 选项 1 的通用类模板中）强>）。但是，由于其特定类型，现在应该在每个派生类中定义 m_v 向量。因此，访问和操作向量的东西应该总是在所有派生类中复制，尽管它们总是相同的（方法v()、isValid()、operator[] 等）。它也似乎设计得不好。

为此目的最好的设计是什么？ 谢谢

Answer 2

使用子操作部分专门化您的类中的特定操作（而不专门化整个类）。

#include <vector>

namespace detail
{
  // general concept of indexing into something
  template<class T> struct index_operation;

  // indexing into most vectors
  template <class T> struct index_operation<std::vector<T>>
  {
    T& operator()(std::vector<T>& v, std::size_t i) const
    {
      return v[i];
    }
    T const& operator()(std::vector<T> const& v, std::size_t i) const
    {
      return v[i];
    }
  };

  // indexing into a vector<bool>
  template <> struct index_operation<std::vector<bool>>
  {
    std::vector<bool>::reference operator()(std::vector<bool>& v, std::size_t i) const
    {
      return v[i];
    }
    std::vector<bool>::const_reference operator()(std::vector<bool> const& v, std::size_t i) const
    {
      return v[i];
    }
  };


}

template<typename T>
class A
{
    using vector_type = std::vector<T>;

public:
    std::vector<T> v() const { return m_v; }
    decltype(auto) operator [] (const int index) const
    {
      auto op = detail::index_operation<vector_type>();
      return op(m_v, index);
    }
private:
    std::vector<T> m_v;
};

Answer 3

这种取决于。

一般的经验法则是问自己是否“ADouble is-a A”。当它们具有 is-a 关系时，您应该使用继承。

但是你也有类型依赖，它不是真正的“is-a”关系。

您还可以同时使用这两种选择：拥有一个具有通用功能的基类，它接受一个模板参数，并拥有一个带有他们需要的附加功能的子类。所以你不需要重新实现所有的类型依赖函数

所以：

template<typename T>
class A
{
public:
    vector<T> v() const { return m_v; }
    T operator [] (const int index) const { return m_v[index]; }
    ...
private:
    vector<T> m_v;
    ...
};

class ADouble : public A<double>
{
    ...
};

顺便说一句：为什么您认为模板会占用更多内存？