anlässlich einer mir nicht verständlichen Lösung wende ich mich an euch.

Problem sieht wie folgt aus:
Es ist eine Templateklasse "Matrix" gegeben, die praktisch einen zweidimensionalen Vektor darstellt. Die erste Dimension besteht aus einem normalen Vektor, der Elemente mit dem Typ "MathVektor" hat. Ok, davon wird also ein Feld erzeugt. Nun soll für die Matrizenklasse ein *=-Operator geschrieben werden, der als Parameter eine zweite Matrix übergeben bekommt und dann damit multipliziert.

Als Lösung wird das hier vorgeschlagen:

template<class T>
Matrix<T>& Matrix<T>::operator*=(const Matrix<T>& b) {
        if(spalten() != b.zeilen())
                throw "Falsche Dimension in Matrix*=!";
        Matrix<T> erg(zeilen(), b.spalten());
	for(size_t i=0; i<zeilen(); ++i) {
		for(size_t j=0; j<b.spalten(); ++j) {
			erg[i][j] = T(0);
			for(size_t k=0; k<spalten(); ++k)
				erg[i][j] += super::operator[](i)[k] * b[k][j];
		}
	}
	*this = erg;
	return *this;
}

Und das war meine Meinung dazu:

template<class T>
Matrix<T>& Matrix<T>::operator*=(const Matrix<T>& x) {
        if(!(zeilen()==x.zeilen() && spalten()==x.spalten())) {
                throw "Matrizen sind nicht gleich groß.";
        }

        for(int i=0; i<zeilen(); ++i) {
                for(int j=0; j<spalten(); ++j) {
                        super::operator[](i)[j] *= x.super::operator[](i)[j];
                }
        }
        return *this;
}

Kann mir jemand vllt. den Gedankengang hinter der Musterlösung erklären. Ich zweifel nämlich langsam dran, dass ich unter Matrizenmultiplikation das Richtige versteh. Meiner Meinung nach wird jedes einzelne Feld mit dem Entsprechenden der anderen Matrix multipliziert. Dann begreif ich aber nicht, was der Sinn dieser k-Schleife ist. Hab's mal versucht, mir aufzuzeichnen, bin aber damit leider auch nicht weitergekommen.

Danke für die Antworten

~moagnus

Alles klar, habs verstanden

wäre schön für den weltfrieden, wenn die in quadratischer laufzeit (d.h. lediglich 2 Schleifen) funktionieren würde