具有不同数组实现的子类

时间:2011-02-10 05:40:54

标签: c++ arrays templates inheritance multidimensional-array

假设我有一个基类模板MyBase:

template <class T>
class MyBase{
private:
    T data;
public:
    MyBase(T _data);
};

我想将其子类化两次(至少目前为止):

  1. 数据应该是动态二维数组:T **data
  2. 数据应该是固定的二维数组:T data[rows][cols]
  3. 我仍然是C ++的新手,我无法弄清楚如何做到这一点。 具体来说,我想制作一种矩阵库(主要是作为学习项目)。我过去做过一些事情,我的动态矩阵存储更有意义,反之亦然。因此,似乎一个好的解决方案是实现一个提供所有常用功能的基类(insert(T item, int i, int j),例如,在任何一种情况下应该使用data[i][j] = item;),然后继承DynamicMatrix和FixedMatrix 。 DynamicMatrix将有一个构造函数

    data = new T*[rows];
    for (int i = 0; i < rows; i++)
    {
        data[i] = new T[cols];
    }
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
             data[i][j] = 0;
        }
    }
    

    和FixedMatrix一样:

    for (i=0; i < rows; i++)
    {
        for (j=0; j < cols; j++)
        {
             data[i][j] = 0;    
        }
    }
    

    在基类中创建成员变量T data;非常简单。但是在子类中,如何将其转换为双指针?也许我不能,我没关系。但那我该怎么做呢?

1 个答案:

答案 0 :(得分:3)

在这里,您尝试使用继承进行代码重用,在我看来,这不是一种好的设计方法;继承是为了实现自由,而组合是为了代码重用。

在这种情况下,如果确实需要支持这些不同的情况,我会将2d数组正式化:

template<typename T> class Array2D {
    public:
       virtual const T* operator[](int row_index) const = 0;
       virtual T* operator[](int row_index) = 0;
       virtual size_t rows() const = 0;
       virtual size_t cols() const = 0;
};

然后我将提供您指定的Array2D的实现:

template<typename T, int R, int C> class FixedArray2D : public Array2D {
     public:
       virtual const T* operator[](int row_index) const {
           return &data_[row_index][0];
       }
       virtual T* operator[](int row_index) {
            return &data_[row_index][0];
       }
       virtual size_t rows() const { return R; }
       virtual size_t cols() const { return C; }
     private:
        T data_[R][C];
};

template<typename T> class DynamicArray2D : public Array2D {
     public:
        DynamicAray2D(int rows, int cols) {
           // ...
        }
        // ...
};

此时,您可以使用任一格式实例化Array2D。现在,无论您使用何种代码,只需在需要处理此类对象的地方使用const Array2D&Array2D&

那就是说,我认为这可能是不必要的复杂性,因为动态大小的数组将适用于任何一种情况,因此除非有令人信服的理由支持这两种类型,否则我会继续使用它。