c++ how to correctly overload + operator

Question

I need to implement a matrix class for my study, and now I'm stuck with operator + overloading. Here's my matrix.cpp code:

template<class type>
matrix<type> matrix<type>::operator+ (const matrix<type>& matObj){
matrix<type> newMat(this->WIDTH, this->HEIGHT, 0);
    for (int i = 0; i < this->HEIGHT; i++)
        for (int j = 0; j < this->WIDTH; j++)
            newMat.array[WIDTH * i + j] = matObj.array[WIDTH * i + j] + this->array[WIDTH * i + j];

    return newMat;
}

And here's main.cpp code:

int main() {

    vector< vector<int>> v = {
        {1, 2, 3},
        {4, 5, 6},
        {1, 2, 9}
    };
    math::matrix<int> mat1(v), mat2;
    mat2 = mat1+mat1;

    for (int i = 0; i < mat2.cols();  i++) {
        for (int j = 0; j < mat2.rows(); j++) {
            cout << mat2[i][j] << ", ";
        }
        cout << endl;
    }

    cin.get();
    return 0;
}

Assume that all constructors and other codes are written correctly. So the problem is when I try to run the program, it fails on line:

mat2 = mat1+mat1;

And when I try to print newMat in matrix.cpp before the return statement, it prints it correctly. And of course, I have implemented = operator which works fine. Any suggestions?

Answer 1

The easy way to implement + is as follows.

struct example {
  int state = 0;

  example& operator+=( example const& rhs )& {
    // increment state here; change in real code
    state += rhs.state;
    return *this;
  }
  friend example operator+( example lhs, example const& rhs ) {
    lhs += rhs;
    return std::move(lhs);
  }
  example( example&& ) = default; // ensure this is efficient
  example& operator=( example&& ) = default; // ensure this is efficient
  example& operator=( example const& ) = default; // this can be expensive
  example( example const& ) = default; // this can be expensive
};

more concretely

template<class T>
struct matrix {
  std::vector< std::vector<T> > state;

  matrix & operator+=( matrix const& rhs )& {
    // increment state here; change in real code
    for (std::size_t i = 0; i < (std::min)(state.size(), rhs.state.size(); ++i) {
      for (std::size_t j = 0; j < (std::min)(state[i].size(), rhs.state[i].size(); ++j) {
         state[i][j] += rhs.state[i][j];
      }
    }
    return *this;
  }
  friend matrix operator+( matrix lhs, matrix const& rhs ) {
    lhs += rhs;
    return std::move(lhs);
  }
  matrix( matrix&& ) = default; // ensure this is efficient
  matrix& operator=( matrix&& ) = default; // ensure this is efficient
  matrix& operator=( matrix const& ) = default; // this can be expensive
  matrix( matrix const& ) = default; // this can be expensive
}

=default works on matrix(matrix&&) etc because I followed the rule of 0 -- I left data storage to a specialized class (std::vector<?>), and it has efficient move semantics, so I get it automatically.

If you swap state for a std::vector< T > that has width*height elements, you just have to adapt how you access it. (That is more efficient, but I was trying to keep it simple).