c++ how to correctly overload + operator - c++

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).