Question

我正在根据策略模式实现矩阵。因为我有MyMatrix，它有一个指向Matrix的指针，还有两个从Matrix继承的子类 - SparseMatrix＆amp; RegMatrix。当添加两个矩阵时，因为我不知道我在哪个矩阵中添加哪个矩阵，我实现了一个使用每个继承类的内部方法的基函数，并且在添加时 - 我只是将新元素添加到左手矩阵中

这很好用。

我的问题是 - 我现在想要执行矩阵乘法。我想在基类中实现这个方法--Matrix。这就是我现在所拥有的：

Matrix& multiple(Matrix &other)
{
    double result = 0;
    int newMatrixRowSize = getRowSize();
    int newMatrixColSize = other.getColSize();
    double *resultArray = new double[newMatrixRowSize*newMatrixColSize];
    for (int i = 1; i <= getColSize(); i++)
    {
        for (int j = 1; j <= other.getColSize(); j++)
        {
            for (int k = 1; k <= other.getRowSize(); k++)
            {
                Pair firstPair(i,k);
                Pair secondPair(k,j);
                result += getValue(firstPair)*other.getValue(secondPair);
            }
            Pair resultIndex(i,j);
            resultArray[getNumIndex(resultIndex, newMatrixRowSize, newMatrixColSize)] = result;
            result = 0;
        }
    }
    delete [] resultArray;
}

唯一的问题是，现在我不能只将新元素添加到左手矩阵，我必须创建一个新的RegMatrix或SparseMatrix，并根据矩阵中的零数 - 交换到矩阵的合法表示

所以我的问题是 - 在基类中创建基类派生类的实例是“合法的”还是好的做法？我想避免使用工厂模式，更愿意在不知道手中的矩阵类型的情况下做多态的事情

Answer 1

如果要根据条件创建不同类型的对象，则必须使用工厂。如果您不希望Matrix知道其后代，您有几种选择。除了implementations using interfaces之外，在C ++ 11中，您可以使用std::function：

class Matrix {
     typedef std::function<Matrix*(const double*, int, int)> Factory;
     Factory factory;
public:
     Matrix(const Factory& f) : factory(f) {}
     Matrix* multiple(Matrix &other) {
         ....
         return factory(resultArray, newMatrixRowSize, newMatrixColSize);
     }
};

它为您提供的优势是您可以将任何类似函数的对象作为工厂传递：

Matrix* matrixFactoryFunc(const double* data, int rowSize, int colSize) {
    return nullptr;
}

class MatrixFactoryCallable {
public:
    Matrix* operator()(const double* data, int rowSize, int colSize) {
        return nullptr;
    }
};

class MatrixFactoryWithMemFun {
public:
    Matrix* createMatrix(const double* data, int rowSize, int colSize) {
    }
};

void testFactory() {
    std::function<Matrix*(const double*, int, int)> factory;

    factory = matrixFactoryFunc;

    factory = MatrixFactoryCallable();

    MatrixFactoryWithMemFun mi;
    factory = std::bind(&MatrixFactoryWithMemFun::createMatrix, &mi, _1, _2, _3);

    Matrix m(factory);
}

在基类对象中创建派生类对象

1 个答案: