Thread: Operator overloading issue - C++

Obviously you need a non-const version or else you would never be able to change values.
A const version is also needed so that the object can be passed to functions that promise not to change it.

Code:

#include <iostream>
#include <iomanip>
#include <algorithm>
 
class Matrix {
    int *m_vals;
    int m_rows, m_cols;
public:
    Matrix(int rows, int cols)
        : m_vals(new int[rows * cols]), m_rows(rows), m_cols(cols) {
        std::fill(&m_vals[0], &m_vals[rows*cols], 0);
    }
    ~Matrix() { delete[] m_vals; }
    int rows() const { return m_rows; }
    int cols() const { return m_cols; }
    int& operator()(int row, int col)
        { return m_vals[row * m_cols + col]; }
    int operator()(int row, int col) const
        { return m_vals[row * m_cols + col]; }
};
 
void print(const Matrix& m) {
    for (int row = 0; row < m.rows(); ++row) {
        for (int col = 0; col < m.cols(); ++col)
            std::cout << std::setw(3) << m(row, col);
        std::cout << '\n';
    }
}
 
int main() {
    Matrix m(5, 8);
    m(1, 2) = 42;
    print(m);
}

Originally Posted by HelpMeC

Suppose we have some method which is destined to do some modifications - so how can we define this kind of method a const one at all? It doesn't make sense.

That's why you define the method to be non-const.

But if you want the method to also be called in a const context, you have to define it as const.

So, you have to define it as non-const, but you also have to define it as const! A conundrum! What to do? Just overload to have one non-const version and one const version. Problem solved.

Originally Posted by HelpMeC

I am not sure I understand the point of your code in respect to our issue

It's an example. It could be educational to comment out the const version and try to compile the code so you can see the compile error, then to uncomment the const version and comment out the non-const version so you can see the compile error.

Originally Posted by HelpMeC

You have defined one of the operators as non-const and it returns a reference, and the const one is returning a copy, I don't know what the reason is yet,

Returning a reference allows the item to be modified by the caller; returning a copy does not.

Originally Posted by HelpMeC

I guess there is something wrong with this approach but not sure exactly what.

The first problem is that the behaviour is undefined when the Matrix object really is const, rather than merely non-const in a const context. The second problem is that the behaviour is unexpected to the reader: you declared the member function to be const, and yet you permit a change to the observable state of the object through that member function.

That is, you have chosen to lie to both the compiler and other programmers. Don't do that.

I am a C programmer who has spent some time trying to learn C++.

Tim S.

Code:

#include <iostream>
#include <iomanip>
#include <algorithm>

class Matrix {
private:
    int *m_vals;
    int m_rows, m_cols;
public:
    Matrix(int rows, int cols)
        : m_vals(new int[rows * cols]), m_rows(rows), m_cols(cols) {
        std::fill(&m_vals[0], &m_vals[rows*cols], 0);
    }
    ~Matrix() { delete[] m_vals; }
    int rows() const { return m_rows; }
    int cols() const { return m_cols; }
    const int& operator()(int row, int col) const
        { return m_vals[row * m_cols + col]; }
    int& operator()(int row, int col)
        { return m_vals[row * m_cols + col]; }
};

void print(const Matrix& m) {
    for (int row = 0; row < m.rows(); ++row) {
        for (int col = 0; col < m.cols(); ++col)
            std::cout << std::setw(3) << m(row, col);
        std::cout << '\n';
    }
}

int main() {
    Matrix m(5, 8);
    m(1, 2) = 42;
    print(m);
}

@stahta01 -
Yea, it seems that your version also holds the const-correctness as laserlight and john have mentioned, but your solution is better (?) as you don't return a copy but a const reference (more efficient).

Thanks,
Maybe you can answer my last question:
"BTW, how can I identify which method has to be defined in two version (const and non-const)?
There is some rule or something like that which can indicate that some method has to have 2 versions?..."

I know of no rules; but, I have yet to learn c++ after more than a decade of trying for a few weeks at a time and then giving up for a year or so.

But, my work pattern is to start out with no const and then add them to the parameters [that logically should be const] and fix the resulting errors by making const and non const methods.

Edit:
So, my first const would have been.

Code:

void print(const Matrix& m) {

I also make all my getters to const if they return POD types like int.
Edit2: POD means plain old data (non class types)

NOTE: You main issue was if you make a method const and the method returns a reference you almost always need to make that reference a const.

Tim S.

Originally Posted by HelpMeC

BTW, how can I identify which method has to be defined in two version (const and non-const)?
There is some rule or something like that which can indicate that some method has to have 2 versions?...

It's just what your class requires. You'll know when you start thinking about how you intend objects of your class to be used. It's a fairly common thing when overloading operator[] or providing an at() member function for a collections class, or in this case overloading operator() as a kind of two parameter operator[].

Originally Posted by HelpMeC

but your solution is better (?) as you don't return a copy but a const reference (more efficient).

It's possibly worse because ints are cheap to copy. If the objects are expensive to copy then it would make sense to return a const reference.

Originally Posted by HelpMeC

You know, I think your approach is wrong, doing that thing:

No, both m1 and m2 are non-const, so the non-const overload will always be called. When in doubt, add print statements to instrument the overloads so you can see which one is called.

Having said that, you should understand that what's happening here is copy assignment: the return value of m2(0, 0) will be copy assigned to the object referred to by the return value of m1(0, 0). So even if m2 is const, there's no issue.

Originally Posted by HelpMeC

It's an assignment between ints

Yes, although in real code, it is true that that Matrix class must have the copy constructor and copy assignment operator implemented or disabled.