ich soll als Projekt eine Klasse schreiben, die das Rechnen mit Matrizen ermöglicht.
Zuerst hab ich eine Klasse etwickelt, bei der die einzelnen Elemente jeweils aus aus einem 2dim. Feld der Länge 10 bestehen, plus die Attribute Zeilen, Spalten:

class Matrix
{
    private:
    int a[10][10];
    int Zeilen, Spalten;

    public:
    Matrix(int, int);
...
};

Matrix::Matrix(int m=10, int n=10)
{
    Zeilen=m;
    Spalten=n;
    for (int i=0; i<m; i++)
    {
        for (int j=0; j<n; j++)
        {
            a[i][j]=0;
        }
    }
}
...

Nun hab ich mir gedacht, wär ja auch schön, wenn ich eine allgemeine N X M Matrix hätte, die nicht durch 10 X 10 beschränkt ist:

class Matrix
{
    private:
    double** a;
    int Zeilen;
    int Spalten;

    public:
    Matrix (int, int);
    ~Matrix ();
...
};

Matrix :: Matrix (int M, int N)
{
    Zeilen=M;
    Spalten=N;
    double** a = new double* [M]; \\Feld von Zeigern der Dim. M
    for (int i=0; i<M; i++)
    {
        a[i] = new double [N]; \\Zeiger auf Feld vom Typ Double der Dim. N
        for (int j=0; j<N; j++)
            {
                a[i][j]=0;
            }
    }
    cout << "\n Konstruktor\n";
}

Matrix :: ~Matrix ()
{
    for (int i=0; i<Zeilen; i++)
    {
        delete [] a[i];
    }
    delete [] a;
    cout << "\n Destruktor\n";
}

...

Das Problem ist jetzt, sobald ich af die einzelnen Matrix-Elemente per Methode zugreife z.B a[i][j]=1; , stürtzt mein Programm ab. Im Konstruktor werden die Elemente aber ohne Probleme mit Nullen beschrieben.
Was zür Hölle hab ich hier falsch gemacht?

Ich hoffe mal ihr könnt mir helfen.

Matrix :: Matrix (int M, int N) 
:   Zeilen(M), Spalten(N)
{
/*  double** */ //wenn du wieder nen fehler haben willst, auskommentieren ;D
    a = new double* [M]; \\Feld von Zeigern der Dim. M 
    for (int i=0; i<M; i++) 
    { 
        a[i] = new double [N]; \\Zeiger auf Feld vom Typ Double der Dim. N 
        for (int j=0; j<N; j++) 
        { 
            a[i][j]=0; 
        } 
    } 
    cout << "\n Konstruktor\n"; 
}

was spricht eigtl ggn
a = new doube[M*N] ?

bb

Jedenfalls danke für die schnelle Hilfe.
Ich hab ech nicht bedacht, dass ich ja oben in der Klassendefiniton schon a vom Typ double ** definiert hatte.

Folgend eine schönere Implementierung. Der Ansatz greift auf die Container der STL zurück, um das Rad nicht neu zu erfinden. Somit ist die Matrix nichts anderes als ein Vektor von einem Vektor. Die Hilfsklasse MatrixVector wurde erstellt, damit der Benutzer der Klasse nicht den internen Zustand verändern kann, aber trotzdem die Index-Schreibweise verwenden kann.

class Matrix;

template<typename T>
class MatrixVector : private std::vector<T> 
{
	friend class Matrix;

public:
	explicit MatrixVector()
	 : std::vector<T>()
	{ }

	MatrixVector(unsigned int size, const T& rhs)
	 : std::vector<T>(size, rhs)
	{ }

	std::vector<T>::reference operator[](unsigned int rhs) 
	{
		return std::vector<T>::operator[](rhs);
	}

	std::vector<T>::const_reference operator[](unsigned int rhs) 
	{
		return std::vector<T>::operator[](rhs);
	}

};

template<typename T>
class Matrix 
{
public:
	/*
	 * Die Konstruktoren. 
	 */
	Matrix() 
	 : pRows(0), pColumns(0)
	{ }

	Matrix(const Matrix& other)
	 : pElements(other.pElements), pRows(other.pRows), pColumns(other.pColumns)
	{ }

	Matrix(unsigned int rows, unsigned int columns, const T& rhs=T()) 
	{
		resize(rows, columns, rhs);
	}

	// Ein Konstruktor, der die Matrix aus einem Teil einer anderen Matrix erzeugt. 
	Matrix(const Matrix& other, unsigned int rowBegin, unsigned int columnEnd, unsigned int rows, unsigned int columns)
	{
		resize(rows, columns);
		for(int r=0; r<rows; ++r)
			for(int c=0; c<columns; ++c)
				pElements[r][c] = other.pElements[r+rowBegin][c+columnBegin]
	}

	/*
	 * Zuweisungsoperator. 
	 */
	Matrix& operator=(const Matrix& other) 
	{
		if(this != &other)
		{
			pElements = other.pElements;
			pRows = other.rows;
			pColumns = other.columns;
		}
		return *this;
	}

	/*
	 * Indexoperatoren. 
	 */
	MatrixVector<T>& operator[](unsigned int rhs) 
	{
		return pElements[rhs];
	}

	const MatrixVector<T>& operator[](unsigned int rhs) const 
	{
		return pElements[rhs];
	}

	/*
	 * Die resize()-Methode: Anpassung der Größe der Matrix. 
	 */
	void resize(unsigned int rows, unsigned int columns, const T& rhs=T())
	{
		// Anpassung des Zeilenvektors. 
		pElements.resize(rows, MatrixVector<T>(columns, rhs));

		// Anpassung des Spaltenvektors. 
		for(int i=0; i<rows; ++i)
			pElements[i].resize(columns, rhs);

		pColumns = columns;
		pRows = rows;
	}

	unsigned int rows() const 
	{
		return pRows;
	}

	unsigned int columns() const 
	{
		return pColumns;
	}

	unsigned int size() const
	{
		return pSize;
	}

};

Wenn man das jetzt richtig fein machen wollte, könnte man natürlich auch noch Iteratoren (row_iterator, column_iterator und die entsprechende Gegenstücke mit dem const_ davor).

Niels