C++ operator[] und operator+

[Tima22]

Hallo
Ich spiele da etwas mit c++ und stehe nun vor einem problem den ich nicht verstehe

Also hier stark verkürzte variante:

class Matrix
{
    public:
        Matrix(int zeile, int spalte);
        int& operator[](int element);
        int& element(int i, int j) const;
        Matrix operator+ (const Matrix& m1);
        int mat_zeilen_ausgabe() const;
        int mat_spalten_ausgabe() const;
        ~Matrix();
    private:
        int firstdim;
        int seconddim;
        int** matrize;
};

//ZuKlein und Zugross sind Fehlerklassen
//also es fängt bei 0 an und geht bis spalte*zeile -1
int& Matrix::operator[](int element)
{
    int zeile = 0;
    int spalte = 0;
    if (element < 0)
    {
        throw ZuKlein();    //element < 0 => fehler
    }
    if (element < (firstdim * seconddim))
    {
        zeile = element / seconddim;
        spalte = element % seconddim;
        return matrize[zeile][spalte];
    }
    else
    {
        throw ZuGross();    //element außer array => fehler
    }
}

//--------Problem!---------
Matrix Matrix::operator+ (const Matrix& m1)
{
    if ((m1.mat_zeilen_ausgabe() != this->firstdim) || (m1.mat_spalten_ausgabe() != this->seconddim))
    {
        throw NoPossible(); //addition nicht möglich
    }
//---------result matrix-------
    Matrix result(this->firstdim, this->seconddim);
#ifdef VAR_ONE
    for (int i = 0; i < this->firstdim -1; ++i)
    {
        for (int j = 0; j < this->seconddim -1; ++j)
        {
            result.element(i,j) = this->element(i,j) + m1.element(i,j);
        }
    }
#endif
#ifdef VAR_TWO
    for (int i = 0; i < ((this->firstdim * this->seconddim)-1); ++i)
    {
        result[i] = this->operator[](i) * m1[i];
    }
#endif
    std::cout << "addition" << std::endl;
    return result;
}

Ich möchte einfach schreiben können

int main()
Matrix m1(3,4); Matrix m2(3,4); Matrix m3(3,4);
m3 = m1 + m2;

In cygwin geht nicht, in gegensatz zu dev-c++, aber DAS Problem liegt in m1, wofür soll m1 nicht implementiert worden sein...in gegensatz zu rest

result[i] = this[i] * m1[i];

Habe dafür 2 varianten versucht, die 2te variante wäre mir lieber, aber es gibt fehler, dass operator nicht implementiert wäre. Wenn ich schreibe m1.operator[](i) gibt er fehler das m1.operator[](i&) nicht implementiert wäre.

Und bei 1er variante ist mein stack corupted - also irgendwo zugriffsfehler - aber wie gesagt - das sollte nur eine notlösung sein, ich möchte eigentlich mit operator[] machen.

Weis jemand wie es geht bzw wieso es so nicht geht?

Ja, und die 2 hilfsfunktionen

int mat_zeilen_ausgabe() const;
int mat_spalten_ausgabe() const;

hatte ich zuerst weder als const deklariert, noch definiert, aber der kompiler konnte diese nicht finden und schlug mit const vor - also hatte er diese als const gesehen - weiß einer wieso er die als const ansieht?