Matrizenmultiplikation über Operatorenüberladung,brauche hilfe

[Braineater]

ICh habe ein Problem
ich muss über Operatorenüberladung Matrizenmultiplikation hinbekommen
nur leider bekomme ich immer wieder fehler mit denen ich nix anzufangen weiß

Hier meine header datei

#include <iostream>
#include <vector>

using namespace std;

struct newline{};
class P_matrix {

private:
	vector<vector<int> > mv;
	int index;
	int Determinante;

public:
	P_matrix(void);
	//~matrix(void);
	int set_determinante();
    P_matrix& operator >> (const int WERT);
	P_matrix& operator >> (const struct newline N);
	P_matrix& operator += (const P_matrix &MATRIX);
	P_matrix& operator *= (const P_matrix &MATRIX);

	friend ostream & operator << (ostream & os, const P_matrix &m);

};

P_matrix operator + (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B);
P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B);

Hier meine cpp

#include <iostream>
#include <vector>
#include "Matrix.h"

using namespace std;
//// Standard-Konstruktor der Klasse P_matrix //////////////////////////////////

P_matrix::P_matrix(void){
    mv.push_back(vector<int>());
   index=0;
}

////Global Überladen zur Addition zweier Matrizen über den Operator '+' ////////

P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B) 
{
         int i,j,k;
         int hilf=0;            //Index-Variablen um durch die Matrix zu laufen
         P_matrix m_tmp; 
         newline nz;      

for (k=0; k<MATRIX_A.mv.size();k++)
{
         for (i=0; i<MATRIX_B.mv.size();i++)              //Zeilenvorschub
          {   

                for (j=0; j<MATRIX_B.mv[i].size();j++)    //Spaltenvorschub
                {

                  hilf+=MATRIX_A.mv[k][j]*MATRIX_B.mv[j][i];

                }
          m_tmp >> hilf;
          }
   m_tmp >> nz;
}
          return m_tmp;

}

////Einlesen der einzelnen Werte in die Matrix über den Operator '>>' //////////

P_matrix& P_matrix::operator >> (const int WERT)
{  
	mv[index].push_back(WERT);                     //neuer Wert wird am Zeilenvektor hinten angehängt
    return *this;
}

//// Zeilenvorschub erzeugen innerhalb der Matrix über den Operator '>>' ///////

P_matrix& P_matrix::operator >> (const struct newline N)  //Es wird ein Wert vom leeren struct newline erwartet
{
	mv.push_back(vector<int>());                   //erzeugt einen neuen Zeilenvektor in der Matrix
		index++;                                   //Index-Variable zum schreiben in die neue Zeile wird inkrementiert
		return *this;
}

//Multiplikation zweier Matritzen mit dem Operator '*='
P_matrix& P_matrix::operator *= (const P_matrix &MATRIX)
{        
         int i,j,k;
         int hilf=0;                                       //Index-Variablen um durch die Matrix zu laufen
         P_matrix m_tmp; 
         newline nz;      

for (k=0; k<mv.size();k++)
{
         for (i=0; i<MATRIX.mv.size();i++)              //Zeilenvorschub
          {   

                for (j=0; j<MATRIX.mv[i].size();j++)    //Spaltenvorschub
                {

                  hilf+=mv[k][j]*MATRIX.mv[j][i];

                }
          m_tmp >> hilf;
          }
   m_tmp >> nz;
}

          return *this;
}

es läuft weder der *= Operator noch der * operator
Beim *= ist der Fehler denke ich das das *this die anfänglich übergeben matrix zurückgeben will,ich mein ergebniss aber in einer Hilfsmatrix gespeichert habe,wegen der berechnung.nur weiß ich nicht wie ich die fkt dazu bringe was anderes zurück zu geben

Beim * Operator weiß ich nich wo der Fehler liegt,mein compiler zeigt mir nur bei den for schleifen within the context fehler und bringt nen Fehler auf den vektor typ ind der private classe

ich hoffe ihr könnt mir helfen

mfg

[Tachyon]

Ohne jetzt alles im Detail gelesen zu haben:

P_matrix& P_matrix::operator *= (const P_matrix &MATRIX)
{        
    int i,j,k;
    int hilf=0;                                       //Index-Variablen um durch die Matrix zu laufen
    newline nz;      

    for (k=0; k<mv.size();k++)
    {
        for (i=0; i<MATRIX.mv.size();i++)              //Zeilenvorschub
        {  

            for (j=0; j<MATRIX.mv[i].size();j++)    //Spaltenvorschub
            {

                hilf+=mv[k][j]*MATRIX.mv[j][i];

            }
            *this >> hilf;
        }
        *this >> nz;
    }

    return *this;
}

P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B)
{
    P_matrix tmpMat(MATRIX_A); //setzt einen Copy-Ctor voraus! 
    tmpMat *= MATRIX_B;
    return tmpMat;
}

[Braineater]

hi,
danke für den tipp aber ich glaube deine fkt geht so nicht...bei matrizenmultiplikation werden die elemnte doch immer spalten*zeilen-weiße multipliziert

mfg

[Tachyon]

Braineater schrieb:

hi,
danke für den tipp aber ich glaube deine fkt geht so nicht...bei matrizenmultiplikation werden die elemnte doch immer spalten*zeilen-weiße multipliziert

mfg

Ich habe doch an Deiner Funktion nichts geändert, außer das jetzt direkt *this manipuliert wird und nicht m_tmp.
Die zweite Funktion macht sich nur *= zunutze. Das muss man nicht alles doppelt implementieren.

[Braineater]

achso
sry...ich versteh auf dem gebiet noch nicht so viel

Wie lege ich eine Copy-Ctor an?

mfg

[Tachyon]

Braineater schrieb:

achso
sry...ich versteh auf dem gebiet noch nicht so viel

Wie lege ich eine Copy-Ctor an?

mfg

Da gibts viele Beispiele zu im Netz. Mal selbst etwas aktiv werden. Dann lernt man auch mehr.

[Braineater]

kann ichs auch so machen und mir so den copy ctor sparren ?

P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B)
{
    P_matrix m_tmp= MATRIX_A; //setzt einen Copy-Ctor voraus!
    m_tmp *= MATRIX_B;
    return m_tmp;
}

??

mfg

[camper]

Die Klasse hat bereits einen geeigneten copy-ctor, selbst Hand anzulegen ist in diesem Falle unnötig.

[camper]

Braineater schrieb:

kann ichs auch so machen und mir so den copy ctor sparren ?

Nein, denn beide Schreibweisen sind in diesem Falle gleichwertig.

[Braineater]

dann dürfte das prog ja eigentlich laufen...tut es aber leider nicht bekomme immer nen linker error

[Linker error] undefined reference to `P_matrix::operator*(P_matrix const&)'

[Nexus]

Ein solcher Fehler kommt meistens, wenn man eine Memberfunktion nur deklariert, aber nicht definiert hat und von ihr Gebrauch macht...
Hast du deinen Code noch geändert?

[Braineater]

so die ausführung geht jetzt nur leider kommt kein ergebniss
hier nochmal der komplette quelltext

Header datei

#include <iostream>
#include <vector>

using namespace std;

struct newline{};
class P_matrix {

private:
	vector<vector<int> > mv;
	int index;
	int Determinante;

public:
	P_matrix(void);
	//~matrix(void);
	int set_determinante();
    P_matrix& operator >> (const int WERT);
	P_matrix& operator >> (const struct newline N);
	P_matrix& operator += (const P_matrix &MATRIX);
	P_matrix& operator *= (const P_matrix &MATRIX);

	friend ostream & operator << (ostream & os, const P_matrix &m);

};

P_matrix operator + (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B);
P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B);

cpp datei

#include <iostream>
#include <vector>
#include "Matrix.h"

using namespace std;
//// Standard-Konstruktor der Klasse P_matrix //////////////////////////////////

P_matrix::P_matrix(void){
    mv.push_back(vector<int>());
   index=0;
}

//// Determinantenberechnung ///////////////////////////////////////////////////

int P_matrix::set_determinante(){
 if ((mv.size()==1)&& (mv[0].size()==1))
    Determinante = mv[0][0];
    return mv[0][0];
}

//Addition zweier Matrizen mit dem Operator '+=' ///////////////////////////////

P_matrix& P_matrix::operator += (const P_matrix &MATRIX)
{        
         int i,j;                                   //Index-Variablen um durch die Matrix zu laufen

         for (i=0; i<MATRIX.mv.size();i++)              //Zeilenvorschub
          {   
                for (j=0; j<MATRIX.mv[i].size();j++)    //Spaltenvorschub
                mv[i][j]+=MATRIX.mv[i][j];
          }
          return *this;
}

////Global Überladen zur Addition zweier Matrizen über den Operator '+' ////////

P_matrix operator + (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B) 
{
          P_matrix m_tmp = MATRIX_A;
          return m_tmp += MATRIX_B;

}

////Global Überladen zur Addition zweier Matrizen über den Operator '+' ////////

P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B)
{
    P_matrix m_tmp= MATRIX_A; //setzt einen Copy-Ctor voraus!
    m_tmp *= MATRIX_B;
    return m_tmp;
}

////Einlesen der einzelnen Werte in die Matrix über den Operator '>>' //////////

P_matrix& P_matrix::operator >> (const int WERT)
{  
	mv[index].push_back(WERT);                     //neuer Wert wird am Zeilenvektor hinten angehängt
    return *this;
}

//// Zeilenvorschub erzeugen innerhalb der Matrix über den Operator '>>' ///////

P_matrix& P_matrix::operator >> (const struct newline N)  //Es wird ein Wert vom leeren struct newline erwartet
{
	mv.push_back(vector<int>());                   //erzeugt einen neuen Zeilenvektor in der Matrix
		index++;                                   //Index-Variable zum schreiben in die neue Zeile wird inkrementiert
		return *this;
}

//// Ausgabe der Matrix über den Operator << ///////////////////////////////////

ostream & operator<<(ostream & os, const P_matrix &m)
{
        int i, j;                                 //Index-Variablen um durch die Matrix zu laufen

        for (i=0; i<m.mv.size();i++)              //Zeilenvorschub
          {   
                for (j=0; j<m.mv[i].size();j++)   //Spaltenvorschub
            {
                os<<m.mv[i][j]<<" ";              //schreiben in die ostream Variable
            }
            os<<endl;                             //Zeilenvorschub der Ausgabe
          }	
          return os;
}

//Multiplikation zweier Matritzen mit dem Operator '*='
P_matrix& P_matrix::operator *= (const P_matrix &MATRIX)
{        
         int i,j,k;
         int hilf=0;                                       //Index-Variablen um durch die Matrix zu laufen

         newline nz;      

for (k=0; k<mv.size();k++)
{
         for (i=0; i<MATRIX.mv.size();i++)              //Zeilenvorschub
          {   

                for (j=0; j<MATRIX.mv[i].size();j++)    //Spaltenvorschub
                {

                  hilf+=mv[k][j]*MATRIX.mv[j][i];

                }
          *this >> hilf;
          }
   *this >> nz;
}

          return *this;
}

und die main

#include <iostream>
#include "Matrix.h"

using namespace std;

int main(int argc, char *argv[])
{
    int punkt=0;

    P_matrix m1,m2,m3;
    newline nz;

	m1>>2;m1>>4;m1>>3;m1>>8;m1>>3;m1>>9;m1>>nz;
    m1>>2;m1>>4;m1>>3;m1>>8;m1>>3;m1>>9;m1>>nz;
    m1>>2;m1>>4;m1>>3;m1>>8;m1>>3;m1>>9;
	cout<<m1;
    cout<<endl;

    m2>>2;m2>>3;m2>>nz;
    m2>>4;m2>>5;m2>>nz;
    m2>>2;m2>>3;m2>>nz;
    m2>>7;m2>>8;m2>>nz;
    m2>>2;m2>>3;m2>>nz;
    m2>>1;m2>>9;m2>>nz;

    cout<<m2;

/*/	cout<<endl<<"m3=m2+m1"<<endl;
	m3=m1+m2;
	cout<<m3<<endl;
    cout<<endl<<"m2+=m1"<<endl;
    m2+=m1;
    cout<<m2;
	cout<<endl<<"m3=m2+m1"<<endl;
 */   

	m3=m1*m2;
	cout<<m3<<endl;

  //  cout<<endl<<"m2*=m1"<<endl;
    m2*=m1;
    cout<<m2;
//	cout<<endl<<"m3=m2*m1"<<endl;     

    system("PAUSE");
    return EXIT_SUCCESS;
}

könnte es an der überladung von *= liegen...also an der dierekten zuweisung auf *this...weil eigentlich müsste ich ja einen neuen vektor anlegen mit neuen dimensionen,aber *this bezieht sich doch auf das element vor *=
oder?

mfg

[Braineater]

weiß keiner rat?

kann ich das auch über friend funktionen machen?