c++ copy assignment operator classes - c++

Question

I have a problem with the operator = in my class. This is the semplified code:
class:
#include <iostream>
using namespace std;
class Mat{
private:
int *m1;
int *m2;
unsigned rows;
unsigned cols;
void write(unsigned r_max, unsigned c_max){
m1 = new int [r_max*c_max];
for(unsigned i = 0; i < r_max*c_max; i++){
m1[i] = i;
}
}
public:
Mat():
rows(1), cols(1){
m1 = new int [1];
m1[0] = 0;
m2 = new int [1];
m2[0] = 0;
}
Mat(unsigned r, unsigned c):
rows(r), cols(c){
write(rows, cols);
m2 = new int [rows*cols];
for(unsigned i = 0; i < rows*cols; i++)
m2[i] = 0;
}
Mat &operator=(const Mat &w){
int *new_ptr1 = NULL;
new_ptr1 = new int [w.rows*w.cols];
int *new_ptr2 = NULL;
new_ptr2 = new int [w.rows*w.cols];
for(unsigned i = 0; i < w.rows*w.cols; i++){
new_ptr1[i] = w.say_m1(i);
new_ptr2[i] = w.say_m2(i);
}
delete[] w.m1;
delete[] w.m2;
m1 = new_ptr1;
m2 = new_ptr2;
rows = w.rows;
cols = w.cols;
return *this;
}
int say_m1(unsigned i) const{ return m1[i]; }
int say_m2(unsigned i) const{ return m2[i]; }
~Mat(){
delete[] m1;
delete[] m2;
}
};
Here is what I need to do in the main:
#include "Mat.cpp"
#include <iostream>
#include <cstdlib>
using namespace std;
int main(int argc, char **argv){
Mat a;
Mat b(20, 20);
a = b;
return 0;
}
I think the problem is in the class where I overload the operator =
I don't know how to copy the right object data into the left object data, I'm not sure also if I delete correctly...

Answer 1

I think the problem is in the class where I overload the operator = I don't know how to copy the right object data into the left object data, I'm not sure also if I delete correctly...
You do not (delete correctly).
Operator = should alter the values of *this. Instead, you delete w.m1 and w.m2 (where w is your parameter).
Corrected code:
Mat &operator=(const Mat &w){
int *new_ptr1 = NULL;
new_ptr1 = new int [w.rows*w.cols];
int *new_ptr2 = NULL;
new_ptr2 = new int [w.rows*w.cols];
for(unsigned i = 0; i < w.rows*w.cols; i++){
new_ptr1[i] = w.say_m1(i);
new_ptr2[i] = w.say_m2(i);
}
delete[] m1; // <<< HERE
delete[] m2; // <<< HERE
m1 = new_ptr1;
m2 = new_ptr2;
rows = w.rows;
cols = w.cols;
return *this;
}
That said, there's a host of other problems with your code:
Assuming you wrote this code to learn how to manipulate dynamic arrays within a class:
you're using a class that manages two different allocated resources directly. You should consider using a smart pointer on m1 and m2 (for exception safety).
Implement the rule of three: constructor (you already have this), copy constructor (you don't have this) and assignment operator (you already have this).
Add a destructor to your class.
** Assuming this is code you will use and did not write for learning arrays:**
[] use std::vectors for m1 and m2 instead. This will save you from having to implement the rule of three and destructor.
You use using namespace std; globally. Don't do that as it creates many many problems.
Edit:
Better code:
#include <iostream>
#include <vector>
class Mat{
std::vector<int> life;
std::vector<int> neighborhood;
public:
// this is unnecessary
// void write(unsigned r_max, unsigned c_max); {
Mat() : life(1), meighborhood(1) // fill each with 1 int with default value (0)
{
}
Mat(unsigned r, unsigned c)
: life(r), meighborhood(c) // fill each with r(and c) ints with default value (0)
{
}
// ~Mat() became unnecessary: destructors of std::vector will deallocate fine
Mat &operator=(const Mat &w) {
// create replacements before doing changing any value
// this way, if you get an exception while creating the data
// the value in the obhect does not change
std::vector<int> new_life(w.life);
std::vector<int> new_neighborhood(w.neighborhood);
life.swap(new_life);
neighborhood.swap(new_neighborhood);
return *this;
}
// use std::vector<int>::at which throws an exception if the index is invalid
// if you are not interested in the validation of the index
// return life[i] and neighborhood[i]
int say_m1(unsigned i) const{ return life.at(i); }
int say_m2(unsigned i) const{ return neighborhood.at(i); }
};