hier mal unser quelltext
header datei

#include <iostream>
#include <vector>

using namespace std;

struct newline{};
class P_matrix {

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

public:
	P_matrix(void);
	P_matrix(int n, int m);
    //~matrix(void);
	int set_determinante();
    void Zeilenumformung();
    void Rueckaufloesung();
    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);
	friend 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<double>());
   index=0;
}

////Überladener Konstruktor um die Größe der Matrix am Anfang zu definieren ////
/*
P_matrix::P_matrix(int n, int m)
{
   for (int index=0; index<n; index++){
        mv.push_back(vector<int>());
        cout<<" Zeile "<< i+1 << ": "; 
        for (int j=0; j<m; j++)
           cinmv[][]

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

}

////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<double>());                   //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]<<"\t";              //schreiben in die ostream Variable
            }
            os<<endl;                             //Zeilenvorschub der Ausgabe
          }	
          return os;
}

P_matrix operator * (const P_matrix &MATRIX_A, const P_matrix &MATRIX_B)
{        
         int i,j,k;
         double 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;
                hilf=0;
          }
          if ((k+1)<MATRIX_A.mv.size()) m_tmp >> nz;
}

          return m_tmp;
}
///// Gauss Zeilenumformung ////////////////////////////////////////////////////

void P_matrix::Zeilenumformung()
{
     int k=0;
     int n = mv.size();
     double c;              //Faktor durch den geteilt wird. 
     int i;

     for (k=0; k<n-1; k++){   //c_ik= a_ik / a_kk // k: 1...n-1; Elinationsstufe

      for (i=1; (i+k)<n; i++)    //i: 1...n-1; Zeile
      {   

          c=mv[i+k][k]/mv[k][k];
          for (int j=0; j<mv[i].size(); j++)   //j: 1...n(spalten); Spalte
          {
              mv[i+k][j]=mv[i+k][j]-(mv[k][j]*c);  //0 erzeugen durch Subtraktion der aktuellen Zeile mal den Faktor c
          }

      }
      }
}
void P_matrix::Rueckaufloesung(){

     int n= mv.size();

     }

der >> operator ist schon überladen,so dass man ins programm MAtrixname>>element>>...schreiben kann und das in ne neue matrix gespeichert wird
sowas würde ich gerne für die konsolenanwendung haben

hab mir das so gedacht:
der user gibt die zahlen einer spalte mit leerzeichen getrennt ein,wenn er fertig ist drückt er enter um in die nächste zeile zu gelangen
umd die eingabe zu beenden muss der user entweder ein word wie fertig oder ende oder so eingeben ooder ne bestimmte taste(tastenkombi) drücken

hat einer ne idee wie ich das mit dem oben überladenen >> operator umsetzen kann?
bin über jede hilfe dankbar

MFG

Braineater schrieb:

der user gibt die zahlen einer spalte mit leerzeichen getrennt ein

nimm doch einfach std::string( oder char*, den du dann an string übergibst ):

while( ... )    // Abbruchbedingung
{
    cin >> Matrixname;  // einen String übergeben, trennung der Werte z.B. mit '|'           
}

Überlade den >> operator nocheinmal:

P_matrix& P_matrix::operator >> (const char* WERT_ch)
{  
    std::string WERT;
    int len = 0;
    while( *WERT_ch++ ) len++;  // größe ermitteln
    for( int i=0; i<=len; i++ )
        WERT += WERT_ch[i];     // übertragen

    if( WERT == "ende" ) // Abbruch...
    // die einzelnen Werte auslesen( stringstream && isdigit ) und an die Matrix übergeben...
    // nach der Bearbeitung dann eine neue Zeile erstellen
    mv.push_back(vector<double>());                   //erzeugt einen neuen Zeilenvektor in der Matrix
        index++;
    //...
}

wir sollen nämlich anschliessend noch mit den eingegebenen matrizen rechnen

mit std::string sollte es auch gehen...

Braineater schrieb:

so wie die fkt jetzt geschrieben ist ist sie aber zum rechnen nicht mehr zu gebrauchen da alles als char übergeben wird,oder hab ich mich da verguckt?

so wie die funktion im moment geschrieben ist, trifft das zu, ja, aber wenn man den string mit stringstreams ausliest, erhält man wieder integer-Werte:

P_matrix& P_matrix::operator >> (const std::string str)
{  
	if( WERT == "ende" ) break;

	std::string buffer;
	std::stringstream cst;
	int i=0;
	int k=0;
	int mwert=0;

    // die einzelnen Werte auslesen( stringstream && isdigit ) und an die Matrix übergeben...
    // nach der Bearbeitung dann eine neue Zeile erstellen

	while( i <= str.length() )
	{
		if( std::isdigit( str[i] ) )
		{
			buffer += str[i];
		}

		else if( str[i] == '|' ) // ein leerzeichen als trennzeichen ist nicht möglich, da std::cin keine lesen kann
 		{
			cst.clear();

			cst << buffer;
			cst >> mwert;

			// Integerwerte an die Matrix übergeben
			mv[index].push_back(mwert);

			buffer = "";
			mwert = 0;
		}

                else
                {
                    std::cout << "Syntax Error" << std::endl;
                    break;
                }
		++i;
	}	

	// neue zeile anhängen... -> kann auch am anfang stehen
	mv.push_back(vector<double>());                   //erzeugt einen neuen Zeilenvektor in der Matrix
	index++;
    //...
}

Jetzt sollten die Werte in die Matrix eingetragen sein und man
kann weiter mit ihnen rechnen

\\EDIT: nicht vergessen die Header einzubinden

#include <string>
#include <sstream>