Class operators

Question

I'm having a problem to make the code:

void main(){
     Matrix c(rows,cols);//rows & cols are int numbers
     c[0][0]=2//the line that I'm having a problem to do the operator
}

//My class defined like this: 
class Matrix{
public:
     Matrix(int rows,int cols): rows(rows), cols(cols){
         mat= new double*[cols];
         for( int i=0; i<rows;i++){
             *mat=new double[i];
         }
     }
private:
     int rows,cols;
     double **mat;
};

How can I make an operator that will help me to do the line that I'm having a problem with?

You should note that `void main` is not valid C++. Only `int main`, so it's better to use that because a) it's what the C++ rules dictate and b) it's shorter to write anyway — Tas, Dec 28 '18 at 00:17
@MooingDuck It's in the constructor body. The phrase "method" has no particular meaning in C++ but I think in the colloquial sense we can consider special member functions such as constructors to be "methods". — Lightness Races in Orbit, Dec 28 '18 at 00:42
You could make a `double& Matrix::operator()(int r, int c);` way of accessing elements in the matrix. — Eljay, Dec 28 '18 at 02:29

Jarod42 · Answer 1 · 2018-12-28T00:40:18.167

2

There are no operator [][], but operator[]. So that one should return something for which you can use [] too (pointer or proxy class).

In your case, you might simply do:

double* operator[](int i) { return mat[i]; }
const double* operator[](int i) const { return mat[i]; }

For more complicated cases, you have to return a proxy class.

edited Dec 28 '18 at 00:40

answered Dec 28 '18 at 00:16

Jarod42

203,559
14
181
302

Lightness Races in Orbit · Answer 2 · 2018-12-28T00:48:21.823

Don't dynamically allocate in two dimensions like that. It's poison for your cache, and completely pointless. I see it all the time and I wish I didn't! Make yourself a nice std::vector<double> of size rows*cols instead.

Anyway, the trick to permit [width][height] is a proxy class. Have your operator[] return an instance of a class that has its own operator[] to do the second-level lookup.

Something like this:

#include <iostream>
#include <vector>

struct Matrix
{
    Matrix(const size_t columns, const size_t rows)
       : columns(columns)
       , rows(rows)
       , data(columns*rows, 0)
    {}

    size_t index(const size_t x, const size_t y) const
    {
        return x + y*columns;
    }

    double& at(const size_t x, const size_t y)
    {
        return data[index(x, y)];
    }

    double at(const size_t x, const size_t y) const
    {
        return data[index(x, y)];
    }

    template <bool Const>
    struct LookupHelper
    {
        using ParentType = std::conditional_t<Const, const Matrix, Matrix>;
        using ReturnType = std::conditional_t<Const, double, double&>;

        LookupHelper(ParentType& parent, const size_t x) : parent(parent), x(x) {}

        ReturnType operator[](const size_t y)
        {
            return parent.data[parent.index(x, y)];
        }

        const ReturnType operator[](const size_t y) const
        {
            return parent.data[parent.index(x, y)];
        }

    private:
        ParentType& parent;
        const size_t x;
    };

    LookupHelper<false> operator[](const size_t x)
    {
        return {*this, x};
    }

    LookupHelper<true> operator[](const size_t x) const
    {
        return {*this, x};
    }

private:
    const size_t columns, rows;
    std::vector<double> data;
};

int main()
{
    Matrix m(42, 3);
    m[15][3] = 1;
    std::cout << m[15][3] << '\n';
}

(In reality, you'd want to make it moveable and it could doubtlessly be tidied up a bit.)

Certainly, switching to operator() or a .at(width, height) member function is a lot easier…

https://stackoverflow.com/questions/49822848/const-double-indexing-with-in-matrix-class has example of that proxy class. — Jarod42, Dec 28 '18 at 00:30
@Jarod42 I had a really good one somewhere but couldn't find it :( Recreated a pauper's version instead — Lightness Races in Orbit, Dec 28 '18 at 00:42
Pretty sure there are dup also, but cannot find it, `[]` might be interpreted as empty tag in search :-/ — Jarod42, Dec 28 '18 at 00:46
@Jarod42 Didn't even bother trying to use symbol search ^_^ I've just used so many variations on the theme of "matrix" "2d vector" "two-dimensional vectors" "facade" "indexes" "indices" "proxy class" "helper type" blah blah over the years that I can't find my gem :( — Lightness Races in Orbit, Dec 28 '18 at 00:47
@Jarod42 Ah, [it was on a deleted question](https://stackoverflow.com/questions/52278399/error-no-match-operator-when-overloading-operator-in-matrix-structure-c#comment91505570_52278399) #sadface Anyway it looks pretty much the same as this one :D — Lightness Races in Orbit, Dec 28 '18 at 00:49
@LightnessRacesinOrbit things get deleted too easily around here. — Mark Ransom, Dec 28 '18 at 01:03

Class operators

2 Answers2

Linked