C ++函子用法，避免代码重复

Question

ok so im not sure if its related to functors but from what i understood it is so the question is: lets assume i have the next class:

class Matrix{
public:
    Matrix(int, int);                       // constructor
    Matrix(const Matrix&);                  // copy constructor

    Matrix& operator+= (const Matrix&);
    Matrix& operator-= (const Matrix&);
    int* operator[] (int) const;

private:
    int rows;
    int cols;
    int** Mat_p;
};

and i want to overload the += and -= operators in Matrix class.
now, in order to sum or subtract 2 matrices we need to iterate over each value of both matrices and add or subtract so it will be some thing like:

Matrix& Matrix::operator+= (const Matrix& M){
    for (int indexR = 0; indexR < rows; ++indexR)
        for (int indexC = 0; indexC < cols; ++indexC)
            Mat_p[indexR][indexC] += M[indexR][indexC];
}

Matrix& Matrix::operator-= (const Matrix& M){
    for (int indexR = 0; indexR < rows; ++indexR)
        for (int indexC = 0; indexC < cols; ++indexC)
            Mat_p[indexR][indexC] -= M[indexR][indexC];
}

as you can see both operators "+=" and "-=" has the same structure give or take, so one of the basic so called "rules" is to avoid code duplication.
so the asked question is how do we avoid this duplication and keep the code effective ?

Answer 1

You could implement a single templated function and make two calls into it.

template<typename T>
Matrix& add_or_sub (const Matrix& M, const T &op){
    for (int indexR = 0; indexR < rows; ++indexR)
        for (int indexC = 0; indexC < cols; ++indexC)
            Mat_p[indexR][indexC] = op(Mat_p[indexR][indexC], M[indexR][indexC]);
    return *this;
}

Matrix& Matrix::operator+= (const Matrix& M){
    return add_or_sub(M, std::plus());
}

Matrix& Matrix::operator-= (const Matrix& M){
    return add_or_sub(M, std::minus());
}

Answer 2

I'm a bit late, but I guess the example is more complete. I would suggest writing a piecewise functor applicator which uses underlying scalar as operands, and returns the same type as well, and implement operators using this.

An example:

#include <iostream>
#include <functional>
using namespace std;

template <int Rows, int Cols, typename Scalar = int>
class Matrix {
    public:
    void piecewise_apply(const Matrix& other, std::function<Scalar(Scalar,Scalar)> f) {
        for (int indexR = 0; indexR < Rows; ++indexR)
            for (int indexC = 0; indexC < Cols; ++indexC)
                data[indexR][indexC] = f(data[indexR][indexC], other.data[indexR][indexC]);
    }

    Matrix<Rows,Cols,Scalar>& operator+=(const Matrix<Rows,Cols,Scalar>& rhs) {
        piecewise_apply(rhs, std::plus<Scalar>());
        return *this;
    }

    Matrix<Rows,Cols,Scalar>& operator-=(const Matrix<Rows,Cols,Scalar>& rhs) {
        piecewise_apply(rhs, std::minus<Scalar>());
        return *this;
    }
    private:
    Scalar data[Rows][Cols];
};

int main() {
    Matrix<5,5> a;
    Matrix<5,5> b;

    a.piecewise_apply(b, [](int a, int b){return a*b;});
    a -= b;
    return 0;
}

The example is not complete, as it lacks initialization. Also there is no protection when &rhs == this (a interesting place for optimizations), and probably some more, but it shows the idea. As for code efficiency.. well you should rely on the compiler on this one.

One advantage of this approach is that, even if it's a bit slower in the default version, you can try writing piecewise_apply which uses more elaborate optimization techniques, like blocking, or parallelization, etc. and get speedups in various places.

For a simple version, like in your example, the copy-paste version is shorter, and easier to understand, so probably a better choice.