Problem mit dem Ausgabeoperator

[MariaSchm87]

Hallo liebe Forumsmitglieder,

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;
}

[SeppJ]

Was klappt denn nicht? Beschreibe deine Fehler!

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.

[MarianSch87]

Hallo lieber SeppJ,

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

[elise]

kurz geschaut... baust du eine endlosschleife, zähle in der inneren schleife das j hoch, nicht das i, und es ist A.d[i][j].
freigaben fehlen.

[MariaSchm87]

Hallo liebe Elise,

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?

[SeppJ]

MariaSchm87 schrieb:

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.

[MariaSchm87]

Hallo lieber SeppJ,

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

[DirkB]

Suche in deinem Text mal alle i++ und schaue, ob die da sinnvoll sind.

[MelanieSchm87]

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

return os;
}

Ups, ihr meintet diese Stelle?

[MariaSchm87]

Jetzt bekomme ich sogar eine Ausgabe, wenn ich

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

[DirkB]

Dir fehlt die Ausgabe von einem '\n' an der richtigen Stelle

Mach dich mal über Einrückungsstil schlau.

[MariaSchm87]

Danke, jetzt klappt alles perfekt. Ich bekomme nun die n*n-Matrix mit dem richtigen Zeilenumbruch. Aber findet ihr mein Programm nicht so gut? Insbesondere du SeppJ meintest doch, dass man das lieber mit Vetroren machen sollte.

[MariaSchm87]

template <typename T>class MatrixT {
	private:
	T **d;
	int dim;
	public:
	//d) Konstruktor fuer Template-Klasse
		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 0.0initialisieren
		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]<<" ";
		 }
		 os<<endl;
		}
		os<< endl;
			return os;
			}

	};

int main(){

MatrixT<int> A(5);

cout << "Matrix A: \n" << A << endl;   

	return 0;
	}

[MariaSchm87]

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=(a.d[i][j]+b.d[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]<<" ";
		 }
		 os<<endl;
		}
		os<< endl;
			return os;
			}

	};

int main(){

MatrixT<double> A(8);
MatrixT<double> B(8);
MatrixT<double> ma;

cout << "Matrix A: \n" << A << endl;   // Wieso klappt die Ausgabe nicht?!?!
cout << "Matrix B: \n" << B << endl; 
ma.operator +(ma);
cout << "Matrix C: \n" << ma << endl; 

	return 0;
	}

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

[Swordfish]

#include <iostream>

template < typename T >
class MatrixT {

	private:
		T **d;
		int dim;

	public:

		MatrixT(int di) 
		:	dim( di )
		{
			di = 3; // weil?

			d = new T*[ dim ];

			for( int i = 0; i < dim; i++ ) {

				d[ i ] = new T[ dim ];
			}

			for( int i = 0; i < dim; i++ ) {

				for( int j = 0; j < dim; j++ ) {

					d[ i ][ j ] = 1.0; // Matrixelemente mit 0.0initialisieren <-- ja ne, ... possible loss ...
				}
			}
		}

	MatrixT< T > operator+( const MatrixT< T > & rhs )
	{
		_ASSERT( dim == rhs.dim );

		MatrixT< T > temp( dim );

		for( int i = 0; i < dim; i++ ) {

			for( int j = 0; j < dim; j++ ) {

				temp.d[ i ][ j ] = d[ i ][ j ] + rhs.d[ i ][ j ];
			}
		}
		return temp;
	}

	friend std::ostream& operator<<( std::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]<<" ";
			}

			os << std::endl; // weil?
		}

		os << std::endl; // weil?
		return os;
	}
};

int main()
{
	MatrixT< double > A( 8 );
	MatrixT< double > B( 8 );

	std::cout << "Matrix A:\n" << A;
	std::cout << "\n\nMatrix B:\n" << B;

	std::cout << "\n\nMatrix C:\n" << ( A + B ) << "\n\n";
}

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';
}

[MariaSCHm87]

Hallo lieber Swordfish,

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