Operators overloading for a class which contains 2d array - c++

Question

After returning object from the method matrix matrix::operator+(const matrix& right), the whole array seems to be erased! Let's describe this strange problem on the following simplified example:
main.cpp:
#include "matrix.h"
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
matrix a("a.mt");
matrix b("b.mt");
matrix d(a.getRows(),a.getColumns());
d = a+b;
std::cout<<"hooray!";
return 0;
}
matrix.h:
#ifndef H_MATRIX
#define H_MATRIX
#include <string>
struct field
{
int row;
int column;
double value;
};
class matrix
{
private:
int c; //columns
int r; //rows
field** b; //2d array
void allocmem();
public:
matrix(int rows,int columns);
matrix(std::string filename);
~matrix();
void read(std::string fname);
matrix operator+(const matrix& right);
matrix& operator=(const matrix& right); //deep copy
int getColumns() const;
int getRows() const;
};
#endif
matrix.cpp
#include "matrix.h"
#include <string>
#include <fstream>
#include <iostream>
void matrix::allocmem()
{
b = new field*[r];
for(int i=0; i < r; i++)
b[i] = new field[c];
}
matrix::matrix(int rows,int columns)
{
c = columns;
r = rows;
allocmem();
}
matrix::matrix(std::string fName)
{
read(fName);
}
matrix::~matrix()
{
for(int i=0; i<r;i++)
delete [] b[i];
delete b;
}
void matrix::read(std::string fname) //load matrix from file
{
std::ifstream is;
is.open(fname);
is>>r>>c; //get matrix dimensions
allocmem();
//go to the first row
char dull = is.peek();
while(dull != '\n'){dull = is.get();}
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
is>>b[i][j].value;
b[i][j].row=i+1;
b[i][j].column=j+1;
}
while(dull != '\n'){dull = is.get();}
}
is.close();
}
matrix matrix::operator+(const matrix& right)
{
matrix rMatrix(right.getRows(),right.getColumns());
if((r != right.r) || (c != right.c))
{
return NULL;
}
rMatrix.r = r;
rMatrix.c = c;
//matrix addition algorithm
for(int i=0;i<r;i++)
for(int j=0;j<c;j++)
{
rMatrix.b[i][j].value = b[i][j].value+right.b[i][j].value;
rMatrix.b[i][j].row = i+1;
rMatrix.b[i][j].column = j+1;
}
return rMatrix;
}
matrix& matrix::operator=(const matrix& right)
{
if(this == &right)
return *this;
for(int i=0; i<r;i++)
delete [] b[i];
delete b;
r = right.getRows();
c = right.getColumns();
allocmem();
for(int i=0;i<r;i++)
for(int j=0;j<c;j++)
{
b[i][j].value = right.b[i][j].value; //RUN-TIME ERROR!
b[i][j].column = j+1;
b[i][j].row = i+1;
}
return *this;
}
int matrix::getColumns() const
{
return c;
}
int matrix::getRows() const
{
return r;
}
a.mt:
4 4
10.5 20.7 30.5 40.1
0 0 15.4 9.8
4 2 -8.3 4.2
9.3 2.7 1.2 8.9
b.mt:
4 4
-2.5 0.7 30.5 -54.1
0 1 0 9.8
4 7 8.3 4.2
7.3 2.7 -1.2 3.9
This program should load two matrices from file, and then calculate their sum. In practice, it crashes inside the deep copy method(operator =) throwing such error:.
I'd like to ask you where the bug is and how to fix it.

Answer 1

Try adding a copy constructor as well.
When you return the matrix from the operator+ it uses the copy constructor to initialize the result. The default will copy member by member the calls (including the pointers to the data).
Then you release the memory because the rMatrix is destroyed when you leave operator+ but you try to access it for the operator = in the context above.

Answer 2

Well, it appears you do not know how to handle dynamic memory in C++.
Nothing strange here, it is a tough problem, so you have 2 solutions:
Do not manipulate raw memory
Learn how to manipulate raw memory
Obviously, in the long term, learning how to manipulate raw memory is better... but the short term solution is:
std::vector<std::vector<field>> b;
Now, let us look at the long term.
Preface: do not reinvent the wheel, except for learning purposes
Obey the Single Responsibility Principle: either a class manages resources OR it has a business functionality, but not both
A resources-handling class must obey the Rule of Three (carefully write all of copy constructor, copy assignment operator and destructor) and must take special care of handling exceptions arising during those methods
So... let's go! The general architecture will be:
a resources class, handling memory (and that's all)
a business class, handling operations and relying on the resources class under the covers
A little nibbling first:
// No reason to have line and column there, is it ?
struct Field {
Field(): value() {} // initialize value on construction, please!
double value;
};
Start with the resources class:
// An array of N*M "Field" elements
// It is minimalist, but minimalist is good!
class FieldsArray {
public:
FieldsArray(size_t rows, size_t columns);
FieldsArray(FieldsArray const& other);
FieldsArray& operator=(FieldsArray const& other);
~FieldsArray();
void swap(FieldsArray& other);
Field& at(size_t i, size_t j);
Field const& at(size_t i, size_t j) const;
private:
void allocate(); // rows & columns must be set
void release(); // rows & columns must be set
size_t rows;
size_t columns;
Field** fields;
}; // class FieldsArray
inline void swap(FieldsArray& left, FieldsArray& right) {
left.swap(right);
} // swap
On to the definitions, where we realize that using a table of tables is inconvenient (would have been easier to just use ONE big N*M table).
FieldsArray::FieldsArray(size_t rows, size_t columns):
rows(rows), columns(columns)
{
this->allocate();
} // FieldsArray::FieldsArray
FieldsArray::FieldsArray(FieldsArray const& other):
rows(other.rows), columns(other.columns)
{
// Perform deep copy
this->allocate();
try {
for (size_t i = 0; i < rows; ++i) {
for (size_t j = 0; j < columns; ++j) {
fields[i][j] = other.fields[i][j];
}
}
} catch(...) {
this->release();
throw; // rethrow
}
} // FieldsArray::FieldsArray
FieldsArray& FieldsArray::operator=(FieldsArray const& other) {
FieldsArray tmp(other);
this->swap(tmp);
return *tmp;
} // FieldsArray::operator=
FieldsArray::~FieldsArray() {
this->release();
} // FieldsArray::~FieldsArray
void FieldsArray::swap(FieldsArray& other) {
using std::swap;
swap(this->rows, other.rows);
swap(this->columns, other.columns);
swap(this->fields, other.fields);
} // FieldsArray::swap
Field& FieldsArray::at(size_t i, size_t j) {
assert(i < rows && "Wrong index!");
assert(j < columns && "Wrong index!");
return _fields[i][j];
} // FieldsArray::at
Field const& FieldsArray::at(size_t i, size_t j) const {
assert(i < rows && "Wrong index!");
assert(j < columns && "Wrong index!");
return _fields[i][j];
} // FieldsArray::at
void FieldsArray::allocate(size_t rows, size_t columns) {
fields = new Field*[rows];
try {
for (size_t i = 0; i < rows; ++i) { fields[i] = new Fields[columns]; }
} catch(...) {
this->release();
throw; // rethrow
}
} // FieldsArray::allocate
void FieldsArray::release() {
for (size_t i = 0; i < rows; ++i) { delete[] fields[i]; }
delete[] fields;
} // FieldsArray::release
Yeah, all of that just to get the equivalent of std::vector<Field> (of size N*M). I just hope I did not mess it up (Note: in C++11, std::unique_ptr<Field[]> would help greatly...)
And now, finally, we get to work on the core business:
class Matrix {
public:
Matrix(size_t rows, size_t columns): _data(rows, columns) {}
Field& at(size_t i, size_t j) { return _data.at(i, j); }
Field const& at(size_t i, size_t j) const { return _data.at(i, j); }
Matrix& operator+=(Matrix const& other);
private:
FieldsArray _data;
}; // class Matrix
inline Matrix operator+(Matrix const& left, Matrix const& right) {
Matrix result(left);
result += right;
return result;
} // operator+
And the definition of operator+=:
Matrix& Matrix::operator+=(Matrix const& other) {
assert(this->rows == other.rows && "Rows differ!");
assert(this->columns == other.columns && "Columns differ!");
for (size_t i = 0; i < rows; ++i) {
for (size_t j = 0; j < columns; ++j) {
this->at(i, j) += other.at(i, j);
}
}
return *this;
} // Matrix::operator+=
I'll leave the implementation of other methods as an exercise for the reader ;)