ich habe ein kleines Programm geschrieben. Doch leider funktioniert die Ausgabe nicht ganz. Kann mir vielleicht jemand veraten, was genau ich falsch gemacht habe?

template <typename T>class MatrixT {
private:
T **d;
int dim;
public:

MatrixT(int di) : dim(di){ //Bekommt dim uebergeben 2-58
//di=3;
d = new T*[dim];
for (int i=0; i<dim; i++){ //Speicher fuer Arry d anfordern
d[i] = new T[dim];
}

for (int i=0; i<dim; i++) //Matrixelemente mit 1.0 initialisieren
for (int j=0; j<dim; j++)
d[i][j] = 1.0;

}

friend MatrixT operator+ (const MatrixT& a, const MatrixT& b){
MatrixT ma;
for(int i=0; i<b.dim; i++)
for(int j=0; j<b.dim; j++)
ma[i][j]=(a[i][j]+b[i][j]);

return ma;
}

friend ostream& operator <<(ostream& os, const MatrixT& A){
for (int i=0; i<A.dim; i++)
for (int j=0; j<A.dim; i++)
os<< A[i][j] <<" ";

return os;
}

};

int main(){

MatrixT<int> A(2);

cout << "Matrix A: " << A << endl; Wieso klappt die Ausgabe nicht?!?!

return 0;
}

Wenn du in C++ new für Arrays benutzt, dann meinst du eigentlich std::vector. Dein ganzes Programm steht derzeit auf sehr wackeligen Beinen, weil deine manuelle Speicherverwaltung nicht vollständig richtig ist. Mit std::vector entfallen diese Probleme.

Und wenn du ein Array von Pointern auf immer gleich große Arrays hast, dann ist das keine echte zweidimensionale Datenstruktur sondern bloß eine sehr umständliche Art und Weise etwas umzusetzen, was man mit einer 1D-Strukutr viel einfacher haben könnte.

danke für deine schnelle Antwort. Also, ich wollte eine zweidimensionelle Matrix aufbauen. Anzahl der Zeilen und Spalten ist dim. Wie haben diese Vorgehensweise damals in der Uni so gelernt, also nicht über Vectoren die Matrix aufzubauen. Ich habe in meinen alten Unterlagen nachgesehen und im Skript ist das Programm so aufgebaut. Das war aber damals in C. Jetzt soll das Ganze mit einer Klasse implementiert werden. Das Problem ist nur, dass er mir Nichts ausgibt. Meines Erachtens liegt es daran, dass die Werte des ostreams nicht weitergereicht werden. Oder lkiege ich da falsch?

friend ostream& operator <<(ostream& os, const MatrixT& A){
for (int i=0; i<A.dim; i++)
for (int j=0; j<A.dim; i++)
os<< A[i][j] <<" ";

return os;
}

cout << "Matrix A: " << A << endl

kannst du mir zeigen, wie ich die Freigabe implementieren soll?
Es wird doch in der inneren Schleife das j hochgezählt? Oder sehe ich das falsch?

kannst du mir zeigen, wie ich die Freigabe implementieren soll?

Indem du std::vector benutzt. Du programmierst ihn gerade nach. Und zwar nicht so gut wie er im Original ist. Falls du ihn unbedingt nachprogrammieren musst, dann googel mal nach der "Regel der großen Drei" und "RAII" für ein paar Grundlagen.

Es wird doch in der inneren Schleife das j hochgezählt? Oder sehe ich das falsch?

Nein, guck noch einmal genau hin. Benutz zur Not eine Schriftart, mit der du i und j besser unterscheiden kannst.

kannst du mir die Stelle zeigen? Ich sehe es einfach nicht.

Ups, ihr meintet diese Stelle?

template <typename T>class MatrixT {
private:
T **d;
int dim;
public:

MatrixT(int di) : dim(di){ //Bekommt dim uebergeben 2-58
//di=3;
d = new T*[dim];
for (int i=0; i<dim; i++){ //Speicher fuer Arry d anfordern
d[i] = new T[dim];
}

for (int i=0; i<dim; i++) //Matrixelemente mit 1.0 initialisieren
for (int j=0; j<dim; j++)
d[i][j] = 1.0;

}

friend MatrixT operator+ (const MatrixT& a, const MatrixT& b){
MatrixT ma;
for(int i=0; i<b.dim; i++)
for(int j=0; j<b.dim; j++)
ma[i][j]=(a[i][j]+b[i][j]);

return ma;
}

friend ostream& operator <<(ostream& os, const MatrixT& A){
for (int i=0; i<A.dim; i++)
for (int j=0; j<A.dim; j++)
os<< A.d[i][j] <<" ";

return os;
}

};

int main(){

MatrixT<int> A(2);

cout << "Matrix A: " << A << endl; Wieso klappt die Ausgabe nicht?!?!

return 0;
}

das so schreine. Die Ausgabe lautet Matrix A: 1 1 1 1

Mach dich mal über Einrückungsstil schlau.

Jetzt mekert der aber beim operator+ rum. Den ruft man doch so auf im main

Warum keinen std::vector ? Wo ist der dtor?

Warum nicht std::array ?

#include <cstddef>
#include <array>
#include <iostream>

template < typename T, std::size_t X, std::size_t Y = X >
class array_2d_t {

	private:
		std::array< T, X * Y > data;

	public:

		array_2d_t< T, X, Y >() : data() {}

		array_2d_t< T, X, Y > operator+( array_2d_t< T, X, Y > const &rhs )
		{
			array_2d_t< T, X, Y > tmp;

			for( std::size_t i = 0; i < ( X * Y ); ++i ) {

				tmp.data[ i ] = data[ i ] + rhs.data[ i ];
			}

			return tmp;
		}

	friend std::ostream& operator<<( std::ostream & os, array_2d_t< T, X, Y > const & array_2d )
	{
		for( std::size_t i = 0; i < ( X * Y ); ++i ) {

			os << array_2d.data[ i ] << ' ';

			if( ( i + 1 ) % X == 0 ) os.put( '\n' );
		}

		return os;
	}
};

int main()
{
	array_2d_t< int, 3 > a;
	array_2d_t< int, 3 > b;

	std::cout << ( a + b ) << '\n';
}

danke, du hast dir wirklich sehr viel Mühe gemacht.