ich schreibe gerade an einer Funktion die durch Rückauflösung das Ergebniss (Gauss) einer Dreiecksmatrix löst.

mein Code:

matrix.h

#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);

matrix.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<double>());
   index=0;
}

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();
     vector<double> erg_vec;
     double hilf_var=0.0;

     for(int a=0; a<n; a++)
             erg_vec.push_back(0.0);

     for(int i=n; i>0; i--)
     {
             for (int j=0; j<mv[j].size();j++)
                 {
                      if(i!=j)
                      hilf_var+=mv[i][j]*erg_vec[0][j];                       
                 }
            erg_vec[0][i]=(mv[i][mv[i].size()]-hilf_var)/mv[i][i];

     } 
}
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();
     vector<double> erg_vec;
     double hilf_var=0.0;

     for(int a=0; a<n; a++)
             erg_vec.push_back(0.0);

     for(int i=n; i>0; i--)
     {
             for (int j=0; j<mv[j].size();j++)
                 {
                      if(i!=j)
                      hilf_var+=mv[i][j]*erg_vec[0][j];   //HIER                    
                 }
            erg_vec[0][i]=(mv[i][mv[i].size()]-hilf_var)/mv[i][i]; //HIER

     } 
}

Dabei bekomme ich jetzt aber immer folgende Fehlermeldung:

invalid types `double[int]' for array subscript

Die stellen sind im Quelltext mit 'HIER' markiert.

mfg

ist ein eindimensales Array:)

du greifst aber auf 2 Dimensioen zu

erg_vec[0][i]

mach es so wie du es auch überall emach hast;)

vector<vector<double> > erg_vec

Vielen Dank für den Hinweis, jetzt funktionierts.