3. Matrizenmultiplikation über Operatorenüberladung,brauche hilfe

Matrizenmultiplikation über Operatorenüberladung,brauche hilfe

  • T

    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.

    0
  • B

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

    Wie lege ich eine Copy-Ctor an?

    mfg

    0
  • T

    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.

    0
  • B

    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

    0
  • C
    Mod

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

    0
  • C
    Mod

    Braineater schrieb:

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

    Nein, denn beide Schreibweisen sind in diesem Falle gleichwertig.

    0
  • B

    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&)'

    0
  • N

    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?

    0
  • B

    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

    0
  • B

    weiß keiner rat?

    kann ich das auch über friend funktionen machen?

    0
Anmelden zum Antworten