首先要注意，矩阵的A*A + A*B != (A+B)*A，甚至不接近，它是A*(A+B)，这和矩阵乘法不交换不一样，也就是说，你所要求的，作为一个概念上的东西，是可行的。
这不是一个完整的答案，只是一个提示。正如@JerryJeremiah正确地写的那样，你可以使用表达式模板。首先对于你的矩阵类，你返回一个未求值的上下文，而不是实现表达式求值的运算符：（这里我展示值scemantics，当然，你可以使用引用/指针来实现它）

template<typename LHS, typename RHS, char op>
struct OperatorContext {
    static constexpr char operator = op;
    const LHS lhs;
    const RHS rhs;
};

// inside Matrix {
    template<typename LHS, typename RHS, char op>
    friend auto operator+(const Matrix& lhs, OperatorContext<LHS, RHS, op>& rhs) {
        return OperatorContext<Matrix, OperatorContext<LHS, RHS, op>, '+'>{lhs, rhs};
    }

    template<typename LHS, typename RHS, char op>
    friend auto operator+(OperatorContext<LHS, RHS, op>& lhs, const Matrix& rhs) {
        return OperatorContext<Matrix, OperatorContext<LHS, RHS, op>, '+'>{lhs, rhs};
    }

    friend auto operator+(const Matrix& lhs, const Matrix& rhs) {
        return OperatorContext<Matrix, Matrix, '+'>{lhs, rhs};
    }

    // similarly for other operators
// }

// furthermore, you need similar operators for 2 OperatorContext arguments

然后，您可以从不同的OperatorContext<>版本中实现Matrix的赋值运算符。在这里，您可以进行优化，因为您有完整的类型信息。请注意，只有在您为变量赋值之前，此操作才有效。例如：

// inside Matrix {
    Matrix& operator=(OperatorContext<OperatorContext<Matrix, Matrix, '*'>, OperatorContext<Matrix, Matrix, '*', '+'> other) {
        if (other.lhs.lhs == other.rhs.lhs) { // preferably compare-by-address
          *this = other.lhs.lhs * (other.lhs.rhs + other.rhs.rhs)
        } else {
          *this = other.lhs.lhs * other.lhs.rhs + other.rhs.lhs * other.rhs.rhs;
        }
        return *this;
    }
// }