Matrizen



  • Moin!

    ich habe folgende Aufgabe:

    In dieser Aufgabe sollen Sie eigenständig aus einer gegeben Problemstellung eine
    Klasse Matrix implementieren. Die Klasse Matrix soll eine zweidimensionale Matrix
    enthalten und folgenden Operationen ermöglichen:
    • Addition zweier Matrizen
    • Skalarmultiplikation
    • Matrizenmultiplikation
    • Berechnung der Transponierten einer Matrix

    Die Matrix enthält nur Elemente vom Typ long.
    Um diese Aufgabe zu lösen gehen Sie wie folgt vor:
    1. Rufen Sie sich die mathematischen Hintergrund in Erinnerung
    2. Überlegen Sie sich welche Attribute und Funktionen benötigt werden
    3. Zeichnen Sie ein Diagramm Ihrer Klasse
    4. Implementieren Sie Ihre Klasse
    5. Schreiben Sie ein geeignetes Hauptprogramm, welches die Funktionen
    Ihrer Klasse demonstriert.

    ich habe jetzt angefangen und mir das so gedacht.

    Hier meine Dateien:
    matrix.h

    #ifndef MATRIX
    #define MATRIX
    
    class Matrix{
    private:
    	int spalte, zeile;
    	long number;
    	long matrix[][];	
    
    public:
    
    	Matrix(const int, const int);
    	//~Matrix();
    	void print();
    	//void add();
    };
    
    #endif
    

    matrix.cpp

    #include <iostream>
    #include "matrix.h"
    
    using namespace std;
    
    Matrix::Matrix(const int zeile, const int spalte):this->zeile(zeile),this->spalte(spalte)
    {
    	for(int i=0; i<zeile; i++)
    		for(int k=0;k<spalte;k++)
    			matrix[i][k]=0L;
    
    }
    
    void Matrix::print()
    {
    	for(int i=0; i<zeile; i++)
    		for(int k=0;k<spalte;k++)
    			cout << matrix[i][k];
    
    }
    

    main.cpp

    #include <iostream>
    #include "matrix.h"
    
    using namespace std;
    
    int main(void)
    {
    	int x1, y1, x2,y2;
    
    	cout << "1. Matrix: Wieviele Zeilen: ";
    	cin >> x1;
    	cout << "1. Matrix: Wieviele Spalten: ";
    	cin >> y1;
    
    	cout << "2. Matrix: Wieviele Zeilen: ";
    	cin >> x2;
    	cout << "2. Matrix: Wieviele Spalten: ";
    	cin >> y2;
    
    	Matrix ma1(x1,y2);
    	Matrix ma2(x2,y2);
    
    	ma1.print();
    	ma2.print();
    	return 0;
    
    }
    

    jetzt bringt er mir ständig den Fehler, dass die Feldindizes des Arrays in der Klasse fehlen.

    Kann mir jemand sagen, wie ich richtig mache?



  • schau mal in die FAQ nach dynamischen mehrdimensionalen Arrays. Oder nimm gleich std::vector.

    der fehler liegt in dieser zeile:

    long matrix[][]; // hier muss die größe angegeben werden, oder du machst es dynamisch mit **. außerdem: ist long der richtige datentyp?



  • ich denke schon, dass long der richtige datentyp ist.

    Mit dynamischen Arrays habe ich es vorher auch schon probiert, kam da aber nicht weiter.
    Ich zeig dir einfach mal meinen ersten Versuch:

    header.h

    #ifndef MATRIX
    #define MATRIX
    
    class Matrix{
    
    private:
    	long number;
    
    public:
    	Matrix(const long = 0,const long = 0);
    	~Matrix();
    
    	void print(const Matrix* matrix) const;
    	void init_matrix(const int, const int);
    	void matAdd(const Matrix*, const Matrix*);
    	void matSkalar(const int);
    	void matMul(const Matrix*);
    
    };
    
    #endif
    

    matrix.h

    #include <iostream>
    #include "mat_rech.h"
    
    using namespace std;
    
    Matrix::Matrix(const long = 0, const long = 0)
    {
    	long **matrix;
    
    	matrix = new long* [spalte];		// |1|2|3|4|5|6|7|8|9|10|
    
    	cout << "Konstruktor: Spalten erstellt!" <<endl;
    
    	for(int i=0; i < zeile; i++){		// spalten runter = zeilen
    		matrix[i]= new long [zeile];	
    
    	}
    
    	cout << "Konstruktor: Zeilen erstellt!" <<endl;
    
    	for(int i=0;i< spalte; i++;)
    		for(int k=0;i<zeile; i++)
    			matrix[i][k]= 0;
    }
    
    Matrix::~Matrix()
    {
    	for(int i=0; i < spalte; i++)
    		delete matrix[i];
    
    	cout << "Zeilen geloescht!" <<endl;
    
    	delete [] matrix;
    
    	cout << "Spalten geloescht!"<<endl;
    }
    
    void Matrix::init_matrix(const int x, const int y)
    {
    	for(int i =0; i<x; i++)
    	{
    		for(int k=0;k<y;i++)
    		{
    			cout << i<<".Zahl: "<<endl;
    			cin >> number;
    			matrix[i][k]= number;		
    		}
    	}
    
    }
    
    void Matrix::matAdd(const Matrix *mat1, const Matrix *mat2)
    {
    	for(int i=0;)
    
    }
    
    void Matrix::print(Matrix matrix)
    {
    
    }
    

    main.cpp

    #include <iostream>
    #include "mat_rech.h"
    
    using namespace std;
    
    int main (void)
    {
    	long x1, y1, x2,y2;
    	int wahl=0;wahl2=0;skalar=0;
    
    	cout << "1. Matrix: Wieviele Spalten: ";
    	cin >> x1;
    	cout << "1. Matrix: Wieviele Zeilen: ";
    	cin >> y1;
    
    	cout << "2. Matrix: Wieviele Spalten: ";
    	cin >> x2;
    	cout << "2. Matrix: Wieviele Zeilen: ";
    	cin >> y2;
    
    	Matrix *m1(x1L,y1L);
    	Matrix *m2(x2L,y2L);
    
    	cout << "1. Matrix initialisieren (Spaltenweise): "<<endl;
    
    	m1.init_matrix(x1,y1);
    
    	cout << "2. Matrix initialisieren (Spaltenweise): "<<endl;
    
    	m2.init_matrix(x2,y2);
    
    	cout <<"1. Addition zweier Matrizen\n"
    		<<"2. Skalarmultiplikation\n"
    		<<"3. Matrizenmultiplikation\n" 
    		<<"4. Berechnung der Transponierten einer Matrix\n"
    		<<"Funktion auswaehlen: "
    
    	cin >> wahl;
    
    	switch(wahl)
    	{
    	case 1:
    		matAdd(m1, m2);
    		break;
    	case 2:
    		cout << "Skalar: "
    		cin >> skalar;
    		cout <<"Welche Matrix (1 oder 2): ";
    		cin >> wahl2;
    		if(wahl2==1)
    
    	}
    
    	return 0;
    }
    

    habe hier dann abgebrochen 😞

    bei diesem versuch wusste ich aber nicht wie ich mit den rückgabeparamatern arbeiten sollte.

    Irgendwie war der Versuch komisch...



  • Matrix::Matrix(const long = 0, const long = 0)
    {
        long **matrix; // Muss schon ne Klassenvariable sein, sonnst weißt du ja nichtmehr wie du später drauf zugreifen kannst  ^^
    
        matrix = new long* [spalte];
    
        cout << "Konstruktor: Spalten erstellt!" <<endl;
    
        for (int i=0; i < zeile; i++){        // du willst aber die spalten durchgehen und denen jeweils die Zeilen zuordnen ... d.h. i < spalten
            matrix[i]= new long [zeile];   
    
        }
    
        cout << "Konstruktor: Zeilen erstellt!" <<endl;
    
        /*for(int i=0;i< spalte; i++;)
            for(int k=0;i<zeile; i++)
                matrix[i][k]= 0;*/ // weglassen ...
    }
    

    Hmm also mal aufräumen:

    #if !defined(MATRIX_H__INCLUDED)
    #define MATRIX_H__INCLUDED
    
    #if (_MSC_VER >= 1300)
    #pragma once
    #endif // (_MSC_VER >= 1300)
    
    class matrix
    {
    	long**			m_data;
    	std::size_t		m_row;
    	std::size_t		m_col;
    
    public:
    	matrix(std::size_t row, std::size_t col);
        ~matrix();
    
    public:
    	matrix& operator+(matrix const&); // statt matAdd
    	matrix& operator*(matrix const&); // statt matMul
    	friend std::ostream& operator << (std::ostream& out, matrix const& data)
    	{
    		// statt deiner print-Funktion 
    	}
    
    	friend std::istream& operator >> (std::istream& in, matrix& data)
    	{
    		// statt deiner init_matrix-Funktion
    	}
    };
    
    #endif // MATRIX_H__INCLUDED
    

    ... warum nicht die Operatoren überladen? Dann kann man mit der Klasse noch VIEL einfacher Arbeiten ...
    Und jetzt hab ich dir es auch mal kurz aufgeschrieben, wie die Initialisierung deines Arrays aussehen muss:

    matrix::matrix(std::size_t row, std::size_t col) 
    	: m_row(row), m_col(col), m_data(new long*[row])
    {
    	for (std::size_t i(0); i < row; ++i) 
    		m_data[i] = new long[col];   
    }
    
    matrix::~matrix()
    {
    	for (std::size_t i(0); i < m_row; ++i)
            delete [] m_data[i];
    	delete [] m_data;
    }
    

    ... So ist es kurz und knackig 😛



  • Achja, bevor du das vergeigst:

    friend std::istream& operator >> (std::istream& in, matrix& data)
    {	
    	for (std::size_t i(0); i < data.m_row; ++i)
    		for (std::size_t j(0); j < data.m_col; ++j)
    		{
    			std::cout << "(" << i << ", " << j << ") = " << std::flush;
    			if (!(in >> data.m_data[i][j])) { in.setstate(std::failbit); break; }
            }
    	return in;
    }
    

    ... wenn das lesen dann fehlschlägt, wird das failbit gesetzt und das einlesen abgebrochen ...

    friend std::ostream& operator << (std::ostream& out, matrix const& data)
    {
    	for (std::size_t i(0); i < data.m_row; ++i)
    	{
    		out << "( ";
    		for (std::size_t j(0); j < (data.m_col - 1); ++j)
    			out << "{" << data.m_data[i][j] << "}, ";
    		out << "{" << data.m_data[i][data.m_col - 1] << "} )\n";
    	}
    }
    

    ...

    ( {1}, {0}, {0} )
    ( {0}, {1}, {0} )
    ( {0}, {0}, {1} )
    

    Wäre die Ausgabe, wenn du eine 3 * 3-Matrix hast und diese mit den vertikalen Daten füllst.



  • also meien dateien sehen jetzt so aus.

    Habe das gemerkt, dass **matrix in die klasse muss!

    header.h

    #ifndef MATRIX
    #define MATRIX
    
    class Matrix{
    
    private:
    	int zeile, spalte;
    	long number;
    	long **matrix;
    
    public:
    	Matrix(const int = 0,const int = 0);
    	~Matrix();
    
    	void init();
    	void skalar();
    	void multi(const Matrix);
    	void add(const Matrix);
    
    	void print() const;
    
    };
    
    #endif
    

    matrix.cpp

    #include <iostream>
    #include "mat_rech.h"
    
    using namespace std;
    
    /////////////////////////////////////////////
    // Konstruktor
    /////////////////////////////////////////////
    Matrix::Matrix(const int z= 0, const int s= 0):zeile(z),spalte(s)
    {
    	matrix = new long* [spalte];		// |1|2|3|4|5|6|7|8|9|10|
    
    	cout << "Konstruktor: Spalten erstellt!" <<endl;
    
    	for(int i=0; i < zeile; i++){		// spalten runter = zeilen
    		matrix[i]= new long [zeile];	
    
    	}
    
    	cout << "Konstruktor: Zeilen erstellt!" <<endl;
    
    	for(int i=0;i< spalte; i++)
    		for(int k=0;i<zeile; i++)
    			matrix[i][k]= 0;
    
    }
    
    /////////////////////////////////////////////
    // Destruktor
    /////////////////////////////////////////////
    Matrix::~Matrix()
    {
    	for(int i=0; i < spalte; i++)
    		delete matrix[i];
    
    	cout << "Destruktor: Zeilen geloescht!" <<endl;
    
    	delete [] matrix;
    
    	cout << "Destruktor: Spalten geloescht!"<<endl;
    }
    
    /////////////////////////////////////////////
    // Matrix mit Werten fuellen
    /////////////////////////////////////////////
    void Matrix::init()
    {
    	for(int i =0; i<spalte; i++)
    	{
    		for(int k=0;k<zeile;i++)
    		{
    			cout <<"Zahl: "<<endl;
    			cin >> number;
    			matrix[i][k]= number;		
    		}
    	}
    }
    
    /////////////////////////////////////////////
    // Skalarmultiplikation
    /////////////////////////////////////////////
    void Matrix::skalar()
    {
    	int skalar;
    	cout << "Skalar eingeben: ";
    	cin >> skalar;
    
    	for(int i=0;i<spalte;i++)
    		for(int k=0;k<zeile;k++)
    			matrix[i][k]=skalar*matrix[i][k];
    
    }
    
    /////////////////////////////////////////////
    // matrizenmultiplikation
    /////////////////////////////////////////////
    
    //Das Produkt zweier Matrizen ist nur dann definiert, 
    //wenn die Anzahl der Spalten der ersten Matrix gleich der Anzahl der Zeilen der zweiten Matrix ist. A*B != B*A
    void Matrix::multi(const Matrix matrix2)
    {
    	if(spalten == matrix2.zeile){
    
    		for(int i=0;i<spalte;i++)
    			for(int k=0;k<zeile;k++)
    				matrix[i][k]=matrix[i][k]; // nicht fertig
    
    	}
    	else
    		cout<< "Berechnung leider nicht möglich!"<<endl;
    
    }
    
    /////////////////////////////////////////////
    // Addition zweier Matrizen
    /////////////////////////////////////////////
    
    void Matrix::add(const Matrix matrix2)
    {
    	if(spalte == matrix2.spalte && zeile == matrix2.zeile)
    	{
    		for(int i=0;i<spalte;i++)
    			for(int k=0;k<zeile;k++)					// FALSCHE RECHNUNG
    				matrix[i][k]+=matrix2[i][k]; 
    	}
    	else
    		cout<< "Berechnung leider nicht möglich!"<<endl;
    
    }
    
    void Matrix::print() const
    {
    
    	for(int i=0;i<spalte;i++)
    	{
    		for(int k=0;k<zeile;k++)
    		{
    			cout << " "<<matrix[i][k]; 
    		}
    		cout <<endl;
    	}
    
    }
    

    main.cpp

    #include <iostream>
    #include "mat_rech.h"
    
    using namespace std;
    
    void skalar(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "Welche Matrix soll mit einem Skalar multipliziert werden?"<<endl;
    	cout << "1. Matrix 1"<<endl;
    	cout << "2. Matrix 2" <<endl;
    	cin >> choice;
    	if(choice==1)
    		m1.skalar();
    	else if(choice == 2)
    		m2.skalar();
    }
    
    void multi(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "1. A*B"<<endl;
    	cout << "2. B*A" <<endl;
    	cin >> choice;
    
    	if(choice==1)
    		m1.multi(m2);
    	else if(choice == 2)
    		m2.multi(m1);
    }
    
    int main (void)
    {
    	int x1, y1, x2,y2;
    	int wahl=0,skalar=0;
    
    	cout << "1. Matrix: Wieviele Spalten: ";
    	cin >> x1;
    	cout << "1. Matrix: Wieviele Zeilen: ";
    	cin >> y1;
    
    	cout << "2. Matrix: Wieviele Spalten: ";
    	cin >> x2;
    	cout << "2. Matrix: Wieviele Zeilen: ";
    	cin >> y2;
    
    	Matrix m1(x1,y1);
    	Matrix m2(x2,y2);
    
    	cout <<"1. Addition zweier Matrizen\n"
    		<<"2. Skalarmultiplikation\n"
    		<<"3. Matrizenmultiplikation\n" 
    		<<"4. Berechnung der Transponierten einer Matrix\n"
    		<<"Funktion auswaehlen: ";
    
    	cin >> wahl;
    
    	switch(wahl)
    	{
    	case 1:
    		m1.add(m2);
    		break;
    	case 2:
    		skalar(m1, m2);
    		break;
    	case 3:
    		multi(m1, m2);
    		break;	
    
    	}
    
    	return 0;
    }
    

    Kommt das so hin?!



  • nein ... guck mal genau was ich geschrieben habe ... und verbesser das ALLES so, wie ich es dir geschrieben habe ... das hatte schon seinen Grund! Wenn der für dich nicht ersichtlich ist, frag danach.


  • Mod

    @(D)Evil: Hat es einen bestimmten Grund, hier die ***-Methode anzubringen? Die ist einfach nur böse.



  • Was für ne Methode? 😮



  • ich fange mal langsam an! bin noch neu in C++. Habe noch nicht so viele Erfahrungen mit operatoren überladen.

    Ich beginne mal mit meiner main.cpp.

    #include <iostream>
    #include "mat_rech.h"
    
    using namespace std;
    
    void skalar(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "Welche Matrix soll mit einem Skalar multipliziert werden?"<<endl;
    	cout << "1. Matrix 1"<<endl;
    	cout << "2. Matrix 2" <<endl;
    	cin >> choice;
    	if(choice==1)
    		m1.skalar();
    	else if(choice == 2)
    		m2.skalar();
    }
    
    void multi(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "1. A*B"<<endl;
    	cout << "2. B*A" <<endl;
    	cin >> choice;
    
    	if(choice==1)
    		m1.multi(m2);
    	else if(choice == 2)
    		m2.multi(m1);
    }
    
    int main (void)
    {
    	int x1, y1, x2,y2;
    	int wahl=0,skalar=0;
    
    	cout << "1. Matrix: Wieviele Spalten: ";
    	cin >> x1;
    	cout << "1. Matrix: Wieviele Zeilen: ";
    	cin >> y1;
    
    	cout << "2. Matrix: Wieviele Spalten: ";
    	cin >> x2;
    	cout << "2. Matrix: Wieviele Zeilen: ";
    	cin >> y2;
    
    	Matrix m1(x1,y1);
    	Matrix m2(x2,y2);
    
    	cout <<"1. Addition zweier Matrizen\n"
    		<<"2. Skalarmultiplikation\n"
    		<<"3. Matrizenmultiplikation\n" 
    		<<"4. Berechnung der Transponierten einer Matrix\n"
    		<<"Funktion auswaehlen: ";
    
    	cin >> wahl;
    
    	switch(wahl)
    	{
    	case 1:
    		m1.add(m2);
    		break;
    	case 2:
    		skalar(m1, m2);   // FEHLER beim compilieren
    		break;
    	case 3:
    		multi(m1, m2);
    		break;	
    
    	}
    
    	return 0;
    }
    

    Fehlermeldung: "Ausdruck ergibt keine Funktion, die 2 Argumente übernimmt"

    Nun wollte ich mal die "neuen" Referenzen nutzen und es gibt Probleme. Kannste mir sagen, was ich da falsch gemacht habe? 😕



  • sheddy, du hast auch eine lokale Variable mit Namen 'skalar' deklariert, d.h. diese überdeckt dann die Funktion.
    Also lösche die Variable oder benenne sie um.



  • okay danke!
    Jetzt mal eine andere Frage. Nämlich zu "const"

    int bla(const Mensch &m1, const Mensch &m2)
    

    Ist das ein konstantes Objekt oder eine konstante Referenz.
    Es ist doch ein konstantes Objekt,oder?!

    void bla(matrix const&)
    

    Das ist doch das gegenteil,oder?!

    Hierbei handelt sich doch um eine konstante Referenz oder?!



  • Es gibt keine konstante Referenz. (Was sollte das auch ausdrücken?)

    const A und A const ist das gleiche.



  • rüdiger schrieb:

    Es gibt keine konstante Referenz. (Was sollte das auch ausdrücken?)

    😕
    Referenzen sind IMMER konstant.



  • okay danke



  • so, jetzt noch einmal mein ganzes Programm:

    Wir haben Vektoren noch nicht gehabt, deshalb habe ich die Aufgabe mit Arrays gelöst.

    Ich denke, ich bin soweit fertig und will eigentlich nur noch mal einen testlauf machen, jedoch bricht das programm bei der Initialisierung der zweiten Matrix immer ab.

    Zu erst der Quellcode dann ein Bild des Fehlers:

    matrix.h

    #ifndef MATRIX
    #define MATRIX
    
    class Matrix{
    public:
    	Matrix(const int = 0,const int = 0);
    	~Matrix();
    	Matrix(const Matrix &);
    
    private:
    	int line, col;
    	long number;
    	long **matrix;
    
    public:	
    	Matrix& operator=(const Matrix &);
    	void init();
    	void skalar();
    	//Matrix& operator+(const Matrix &);
    	//Matrix& operator*(const Matrix &);
    	void matAdd(const Matrix &);
    	void matMul(const Matrix &);
    	void transponiert();
    	void print() const;
    };
    
    #endif
    

    matrix.cpp

    #include <iostream>
    #include "matrix.h"
    
    using namespace std;
    
    Matrix::Matrix(const int spalte, const int zeile):col(spalte),line(zeile)
    {
    
    	matrix = new long* [col];		// |1|2|3|4|5|6|7|8|9|10|
    
    	cout << "\tKonstruktor:"<< col << " Spalten erstellt!" <<endl;
    
    	for(int i=0; i < col; i++){		// spalten runter = zeilen
    		matrix[i]= new long [line];	
    
    	}
    
    	cout << "\tKonstruktor: " << line << " Zeilen erstellt!" <<endl;
    }
    
    Matrix::Matrix(const Matrix &matrix2)
    {
    
    	if(this != &matrix2)
    	{
    		for(int i=0; i < col; i++)
    			delete matrix[i];
    
    		delete [] matrix;	
    
    		matrix = new long* [matrix2.col];		// |1|2|3|4|5|6|7|8|9|10|
    
    		for(int i=0; i < matrix2.col; i++)		// spalten runter = zeilen
    			matrix[i]= new long [matrix2.line];			
    	}
    }
    
    Matrix::~Matrix()
    {
    	for(int i=0; i < col; i++)
    		delete matrix[i];
    
    	cout << "\tDestruktor: Zeilen geloescht!" <<endl;
    
    	delete [] matrix;
    
    	cout << "\tDestruktor: Spalten geloescht!"<<endl;
    }
    
    Matrix& Matrix::operator =(const Matrix &matrix2)
    {
    	if(this != &matrix2)
    	{
    		for(int i=0; i < col; i++)
    			delete matrix[i];
    
    		delete [] matrix;	
    
    		matrix = new long* [matrix2.col];		// |1|2|3|4|5|6|7|8|9|10|
    
    		for(int i=0; i < matrix2.col; i++){		// spalten runter = zeilen
    			matrix[i]= new long [matrix2.line];	
    
    		}
    	}
    
    	return *this;
    }
    
    void Matrix::init()
    {
    	cout << "Spaltenweise Initialisierung:"<<endl;
    	for(int i =0; i<line; i++)
    	{
    		cout <<endl;
    		for(int k=0;k<col;k++)
    		{
    			cout <<"Position ["<< i <<"][" << k << "]: ";
    			cin >> number;
    			matrix[i][k]= number;			
    		}		
    	}
    }
    
    void Matrix::skalar()
    {
    	int faktor;
    	cout << "Skalar eingeben: ";
    	cin >> faktor;
    
    	for(int i=0;i<col;i++)
    		for(int k=0;k<line;k++)
    			matrix[i][k]=faktor*matrix[i][k];
    
    }
    
    void Matrix::matAdd(const Matrix &matrix2) 
    {
    	if(col == matrix2.col && line == matrix2.line)
    	{
    		for(int i=0;i<line;i++)
    			for(int k=0;k<col;k++)					
    				matrix[i][k]+=matrix2.matrix[i][k];		
    	}
    	else
    		cout<< "Berechnung leider nicht möglich!"<<endl;
    }
    
    //Das Produkt zweier Matrizen ist nur dann definiert, 
    //wenn die Anzahl der Spalten der ersten Matrix gleich der Anzahl der linen der zweiten Matrix ist. A*B != B*A
    void Matrix::matMul(const Matrix &matrix2)
    {
    	long temp;
    	int col_new, line_new;
    	int line,col;
    	int x,y;
    
    	if(this->col == matrix2.line)
    	{
    		line=col=x=y=0;
    		col_new=line_new= (this->line*matrix2.col)/2;
    		Matrix matrix_new(col_new,line_new);
    
    		for(int i=0;i<this->line;i++)
    		{
    			temp=0;
    			col=0;
    			line++;
    			y=0;
    			for(int k=0;k<this->col;k++)
    			{				
    				temp+=matrix[i][k]*(matrix2.matrix[x][y]);
    
    				if(k==matrix2.line-1)
    				{
    					matrix_new.matrix[line][col]=temp;				//if(col != col_new-1)
    					col++;
    					if(y != matrix2.col-1)							
    					{							
    						k=temp=x=0;
    						y++;
    					}
    				}
    				x++;				
    			}
    
    		}
    
    		*this=matrix_new;
    	}
    	else
    		cout<< "Berechnung leider nicht möglich!"<<endl;
    
    }
    
    void Matrix::transponiert()
    {
    	Matrix matrix_new(line,col);
    
    	for(int i=0;i<line; i++)
    		for(int k=0; k <col; k++)
    		{
    			matrix_new.matrix[k][i]=matrix[i][k];
    		}
    
    	*this=matrix_new;	
    }
    
    void Matrix::print() const
    {
    	for(int i=0;i<line;i++)
    	{
    		for(int k=0;k<col;k++)
    		{
    			cout << " "<<matrix[i][k]; 
    		}
    		cout <<endl;
    	}
    }
    

    main.cpp

    #include <iostream>
    #include "matrix.h"
    
    using namespace std;
    
    void trans(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "Matrix auswaehlen"<<endl;
    	cout << "1. Matrix 1"<<endl;
    	cout << "2. Matrix 2" <<endl;
    	cin >> choice;
    	if(choice==1)
    		m1.transponiert();
    	else if(choice == 2)
    		m2.transponiert();
    }
    
    void matrixskalar(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "Matrix auswaehlen"<<endl;
    	cout << "1. Matrix 1"<<endl;
    	cout << "2. Matrix 2" <<endl;
    	cin >> choice;
    	if(choice==1)
    		m1.skalar();
    	else if(choice==2)
    		m2.skalar();
    }
    
    void multi(Matrix &m1, Matrix &m2)
    {
    	int choice;
    	cout << "1. A*B"<<endl;
    	cout << "2. B*A" <<endl;
    	cin >> choice;
    
    	if(choice==1)
    		m1.matMul(m2);
    	else if(choice == 2)
    		m2.matMul(m1);
    }
    
    int main (void)
    {
    	int x, y;
    	int choice=0;
    
    	cout << "1. Matrix Spalten: ";
    	cin >> x;
    	cout << "1. Matrix Zeilen: ";
    	cin >> y;
    
    	Matrix m1(x,y);
    	m1.init();
    
    	cout << "2. Matrix Spalten: ";
    	cin >> x;
    	cout << "2. Matrix Zeilen: ";
    	cin >> y;
    
    	Matrix m2(x,y);	
    	m2.init();
    
    	cout <<"1. Addition zweier Matrizen\n"
    		<<"2. Skalarmultiplikation\n"
    		<<"3. Matrizenmultiplikation\n" 
    		<<"4. Berechnung der Transponierten einer Matrix\n"
    		<<"Funktion auswaehlen: ";
    
    	cin >> choice;
    
    	switch(choice)
    	{
    	case 1:
    		m1.matAdd(m2);
    		break;
    	case 2:
    		matrixskalar(m1, m2);
    		break;
    	case 3:
    		multi(m1, m2);
    		break;	
    	case 4:
    		trans(m1,m2);
    		break;	
    	}
    
    	m1.print();
    	m2.print();
    
    	return 0;
    }
    

    Fehler

    Finde den Fehler nicht. 😕



  • einer der Fehler:

    matrix_new.matrix[k][i]=matrix[i][k];
    

    ...



  • nee, das habe ich bewusst so gemacht, weil die transponierte matrix eben transponiert ist!

    also 1. zeile in die 1. spalte.

    aber bis dahin komme ich ja nicht einmal.

    es muss ja schon irgendwo am anfang bei der initialisierung liegen!


  • Mod

    Sieht nicht so aus, als ob Kopierkonstruktor oder Zuweisungsoperator irgendwas kopieren.



  • hast recht, ändert trotzdem nix an meinem problem 😞


Log in to reply