Verkettung von überladenen arithmetischen Operatoren

User01815

Hallo,

habe mir folgende Matrix-Klasser erstellt.

template<typename T>
class matrix{
public:
    matrix(T zeilen_, T spalten_):zeilen(zeilen_),spalten(spalten_){matrix_=new T[zeilen*spalten];}
    ~matrix(){delete[] matrix_;}

    T size_zeilen(){return(zeilen);}
    T size_spalten(){return(spalten);}
    T& operator()(T i, T j){return(matrix_[((i*spalten)+j)]);}
    T* operator[](T i){return(matrix_+i*spalten);}

    matrix<T>& operator=(matrix<T> rhs){
        if (this == &rhs)
            return *this;

        swap(matrix_,rhs.matrix_);
        return *this;
    }

private:
    T zeilen, spalten;
    T *matrix_;
};

Mit dem Additionsoperator

template<typename T>
matrix<T> operator+( matrix<T> lhs, matrix<T> rhs){

    matrix<T> neu(lhs.size_zeilen(),lhs.size_spalten());
    for(int i=0;i<lhs.size_zeilen();i++)
    {
        for(int j=0;j<lhs.size_spalten();j++)
        {
            neu(i,j) = lhs(i,j)+rhs(i,j);
        }
    }
    return(neu);
}

int main()
{
    matrix<int> B(20,20);
    matrix<int> A(20,20);

    for(int i =0;i<20;i++){
        for(int j =0;j<20;j++){
            B(i,j)=1;
            A(i,j) = 2;
        }
    }

    matrix<int> Z(20,20);
    Z = A + B + B;

    for(int i = 0;i<19;i++)
    {
        for(int j = 0;j<20;j++)
        {
            cout<<Z(i,j);
        }
        cout<<endl;
    }

    return 0;
}

Bekomme folgende Fehlermeldung:

error: no match for 'operator+' (operand types are 'matrix<float>' and 'matrix<float>')
Z = A + B + B;

Kann mir bitte einer erklären wieso, weshalb, warum und wie dies beheben kann

Danke!

Finnegan

ich sehe da zwar eine ganze Reihe (logischer) Fehler, aber keinen, der vom Compiler angemeckert werden sollte. Auch habe ich mir mal die Mühe gemacht, und versucht den Code selbst zu kompilieren. GCC sowie auch MSVC machen das bei mir hier anstandslos. Gibt es da vielleicht noch irgendwelche Namespaces oder anderen Code, der den genannten Fehler verursachen könnte?

Finnegan

camper

Ich vermisse eine Copykonstruktor (das Ganze fliegt dir also in jedem Fall bei Ablauf um die Ohren; double delete etc.). Möglicherweise gibt es den aber mit unpassender Signatur, so das der op+ nicht aufgerufen werden kann? Dann wäre allerdings der gezeigt Code nicht mit Original dem identisch...

Nebenbei

matrix<T>& operator=(matrix<T> rhs){
        if (this == &rhs) // das ist unmöglich bei dieser Signatur
            return *this;

Moment mal... double post?