3. Problem mit dem Ausgabeoperator

Problem mit dem Ausgabeoperator

  • ?

    Hallo lieber SeppJ,

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

    0
  • ?

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

    0
  • ?
     

    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?

    0
  • ?

    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

    0
  • ?

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

    Mach dich mal über Einrückungsstil schlau.

    0
  • ?

    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.

    0
  • ?
     

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

    0 

  • #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';
}
    0
  • ?

    Hallo lieber Swordfish,

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

    0
Anmelden zum Antworten