了解运算符重载的效用

Question

I've been working on the code of a class "DenseMatrix" that aims to create regular matrices.

Going through the code, there are 2 or 3 things I can't quite understand.
So first here's the code of this class :

#include<iostream>
#include<complex>
#include<vector>
#include <cassert>

using namespace std ;

class DenseMatrix{
    typedef complex<double> Cplx;

private:
    int nr, nc;
    vector<Cplx> data;

public :
    DenseMatrix(const int& nr0, const int& nc0){
    nr = nr0; nc = nc0; data.resize(nr*nc,0);}

    DenseMatrix(const DenseMatrix& M){
    nr = M.nr; nc = M.nc; data.resize((M.data).size());
    for (int j=0; j<data.size(); j++) {data[j]=M.data[j];} }

    void operator=(const DenseMatrix& M){
    nr = M.nr ; nc = M.nc ; data.resize((M.data).size());
    for (int j=0; j<data.size() ; j++){data[j]=M.data[j];} }

    Cplx& operator () (const int& j ,const int& k) {
    assert(0<=j && j<nr && 0<=k && k<nc) ; return data[k+j*nc];}

    const Cplx& operator () (const int& j ,const int& k) const {
    assert(0<=j && j<nr && 0<=k && k<nc) ; return data[k+j*nc];}

    friend ostream& operator<<(ostream& o , const DenseMatrix& M){
    for ( int j =0; j<nr ; j++){ for ( int k=0; k<nc; k++){o << M(j,k) << "\ t " ;} o << endl ;}
    //return o ;}
};

First thing is what's the utility of defining the "=" operator if we can actually use the copy constructor and obtain the same result ?

Second thing, if my understanding is right, Cplx& operator () will return a reference and this reference will actually allow us to modify a private attribute (an element of the matix). But what does the second definition of operator, const Cplx& operator () (const int& j ,const int& k) const , does ? What's its utility ?

Thanks !

Answer 1

First thing is what's the utility of defining the "=" operator if we can actually use the copy constructor and obtain the same result ?

Because you can't use the copy constructor to obtain the same result. The copy constructor is a constructor; it gets used when you construct a matrix. The assignment operator lets you assign to an already constructed matrix.

Second thing, if my understanding is right, Cplx& operator () will return a reference and this reference will actually allow us to modify [an element of the matrix].

But what does the second definition of operator, const Cplx& operator () (const int& j ,const int& k) const , do?

That version is for when you have a const DenseMatrix . Imagine that you used the normal operator() - you'd get a Cplx& which you could use to change the matrix elements. But you aren't allowed to change the matrix elements if it's a const matrix. The compiler won't allow the first version to be used on a const matrix.

The last const (before the { ) is saying that this function is okay to call on a const DenseMatrix .

Answer 2

First thing is what's the utility of defining the "=" operator if we can actually use the copy constructor and obtain the same result ?

They are two different beasts. The copy constructor allows you to create a new object as a copy of an existing one; the assignment operator allows you to copy an object over an existing one. So:

DenseMatrix foo;
...
DenseMatrix bar(foo); // copy constructor
...
foo = bar; // assignment operator

The difference is subtle but important: the copy constructor starts with a pristine object, while the assignment operator generally has also to get rid of the existing data.

Still, given that the assignment operator generally is very similar to a destructor + copy constructor (with most code being duplicated), often the copy & swap idiom is used to minimize code duplication (while achieving other useful properties - such as strong exception guarantees in the process).

---

But what does the second definition of operator, const Cplx& operator () (const int& j ,const int& k) const , does ? What's its utility ?

The const overload is the one that gets invoked over const instances of the class (or to "regular" instances accessed through a const pointer or reference); in this case, they will return the same data as the non- const version, but as a const reference instead of a plain reference, thus not allowing the caller to modify the data of the matrix, as per the constness of the object over which is it invoked.

Answer 3

References don't allow access to private attributes. It's no different than working with the bare object itself.

The idiom of having two versions of a function, one const and one not, is quite common. Since the function is returning a reference, it returns a const reference from the const function.