Return value of overloaded assignment operator

[kyrresc]

Hello,

when learning C++ I've been using a MyClass& return value when overloading the assignment operator for a class MyClass. But why are we doing this?

Consider the following class (note that I've replaced Dataset& with void here for the overloading of the assignment operator) :

class Dataset {
private:
    double *y;
    int N;
public:
    Dataset(int N);
    Dataset(const Dataset &other);
    ~Dataset();
    void operator=(const Dataset& rhs);
    double interpolate(double x);
    int getSize() const { return N; }
    double& operator[](int i) { return y[i]; }
};

and implementation:

Dataset::Dataset(int N) : N{N} {
    
    y = new double[N] {};
}

Dataset::Dataset(const Dataset& other) {
    this->N = other.N;
    this->y = new double[N];
    
    for (int i = 0; i < N; i++) {
        this->y[i] = other.y[i];
    }
    
}

Dataset::~Dataset() {
    delete [] y;
    
}

void Dataset::operator=(const Dataset& rhs) {
    this->N = rhs.N;
    delete [] this->y;
    this-> y = new double[N];
    for (int i = 0; i < N; i++) {
        y[i] = rhs.y[i];
    }
    //return *this;
}

From main:

Dataset data{10};
    Dataset d2{100};
    Dataset dr = data;
    
    d2 = dr;

and it runs without errors. So why are we usually returning &MyClass when overloading the assignment operator, and not just void it?

[coder777]

With this return type you may cascade the operator:

Dataset data{10};
    Dataset d1;
    Dataset d2{100};
    Dataset dr = data;
    
    d1 = d2 = dr;

Without the compiler would throw an error.

[kyrresc]

So it is basically for "chaining" operations, just like for overloading the << operator?

[keskiverto]

Indeed.


PS. You are not systematic:

Dataset::Dataset(int N) : N{N} {
    
    y = new double[N] {};
}

Dataset::Dataset(const Dataset& other) {
    this->N = other.N;
    this->y = new double[N];

Based on the first, one would expect:

Dataset::Dataset(const Dataset& other)
 : N{other.N}
{
    this->y = new double[N];

Or perhaps even:

Dataset::Dataset(const Dataset& other)
 : y{new double[other.N]}, N{other.N}
{

On the assignment, what if this->N >= rhs.N? Is deallocate+allocate absolutely necessary in that situation?