und zwar habe ich ein Problem mit der Übergabe von Instanzen oder ein Problem mit dem Heap, bin mir da nicht ganz sicher.

Erstmal zum Verständnis: Ich möchte ein Klasse zur Berechnung mit Matrizen programmieren.
Habe mir dazu ne Klasse Matrix erschaffen, welche in einer Headerdatei steht.

//Matrix.h

#ifndef Matrix_H
    #define Matrix_H

#include <iostream>
#include <ostream>
#include <iomanip>

enum Matrix_Error{NO_ERROR = 0, DIMENSION_ERROR = 1, MATRIX_NOT_FILLED = 2, DIMENSION_TO_HIGH = 3};

class Matrix
{
private:
    int rows;
    int cols;
    double* pArray = NULL;
    Matrix_Error err = NO_ERROR;

public:
    Matrix()
        :rows(0), cols(0)
    {
        pArray = new double[rows * cols];
    }

    Matrix(int _rows, int _columns)
        :rows(_rows), cols(_columns)
    {
        pArray = new double[rows * cols];

        for(int i = 0; i < rows * cols; i++)
        {
            pArray[i]  = 0;
        }
    }

    double* operator[](int row)
    {
        return &pArray[row * cols];
    }

    ~Matrix()
    {
        delete [] pArray;
        pArray = NULL;
    }

    //Memberfunctions
    void Get();
    Matrix operator +(Matrix &m2);
};

#endif // Matrix_H

Die Klasse funktioniert so, dass ich mir mit

Matrix mat(3,3);

Eine 3 x 3 Matrix erschaffe.
Diese kann ich dann einfach verwalten wie ein 2-dimensionales Array, dazu habe ich den Operator [] überladen.
Als Memberfunktionen habe ich jetzt als Beispiel mal den '+' Operator und die Funktion Get().
Get gibt mir einfach die Matrix in das Konsolenfenster.

Definiert habe ich die Funktionen in einer Matrix.cpp

//Matrix.cpp
#include "Matrix.h"
#include <cmath>
#include <iostream>

void Matrix::Get()
{
    Matrix m(*this);

    for(int i = 0; i < rows; i++)
    {
        std::cout << "(";

        for(int j = 0; j < cols; j++)
        {
            std::cout << std::setw(5) << m[i][j] << " ";
        }

        std::cout << ")" << std::endl;
    }
}

Matrix Matrix::operator +(Matrix &m2)
{
    Matrix m1(*this), tmp(rows, cols);

    if(m1.rows != m2.rows || m1.cols != m2.cols)
    {
        SetError(DIMENSION_ERROR);
        return tmp;
    } else
    {
        for(int i = 0; i < rows; i++)
        {
            for(int j = 0; j < cols; j++)
            {
                tmp[i][j] = m1[i][j] + m2[i][j];
            }
        }

        return tmp;
    }
}

Jetzt zu meinen Problem:

Wenn ich mir in main() 2 2x2-Matrizen erschaffe und diese addieren möchte, werden diese irgendwie nicht korrekt an meinen +-operator übergeben.

Stattdessen hat meine erste übergeben Matrix m1(*this) als werte (0 0 0 0)
und meine Matrix m2 (1.39575e-307 0 0 0).

Irgendwie verstehe ich nicht warum, da mein Programm gestern noch einwandfrei funktionierte?

Meine main() Funktion zum testen sieht so aus:

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

using namespace std;

void FillMatrix(Matrix &mat)
{
    int r, c;
    time_t t;

    time(&t);
    srand((unsigned int)t);

    mat.GetDimensions(r, c);

    for(int i = 0; i < r; i++)
    {
        for(int j = 0; j < c; j++)
        {
            mat[i][j] = (double)(rand() % 99 + 1);
        }
    }
}

int main()
{
    Matrix mat1(3, 3), mat2(3, 3), mat3;

    FillMatrix(mat1);
    FillMatrix(mat2);

    mat1.Get();
    cout << "+" << endl;
    mat2.Get();
    cout << "=" << endl;
    mat3 = mat1 + mat2;
    mat3.Get();

    return 0;
}

Vielen Dank schonmal für eure Hilfe.

Gruß

Wenn die Probleme nach Behebung dieser Fehler weiter bestehen, dann melde dich noch einmal. Den Rest des Codes habe ich mir nämlich nicht weiter angesehen, nachdem ich dieses Problem erkannt hatte.

Werde denke in den sauren Apfel beißen müssen und mir die Klasse mit std::vectoren neu schreiben müssen.

Die Kopie von this habe ich mir erstellt, da ich mit einer neuen Matrix handlicher arbeiten kann.

Danke für eure Hilfe

Gruß

Alex

Die Kopie von this habe ich mir erstellt, da ich mit einer neuen Matrix handlicher arbeiten kann.

Ja dann ...
Bei Matrizenrechnung kommt es ja auf Performance nicht an ...

Und dein erster Konstuktor, der rows=0, cols=0 setzt, der macht dann ein new double[0] , gibt dir also einen Pointer, den du nicht sinnvoll nutzen kannst.

Also ersetze pArray doch einfach durch einen vector<double> daten . Dein 2. Konstruktor wird auch einfacher:

Matrix(int _rows, int _columns)
    : rows(_rows)
    , cols(_columns)
    , daten(_rows * _cols)
{}

Dein Destruktor fällt komplett weg und dein operator[] kann praktisch gleich bleiben, wo ist also der saure Apfel, in den du beißen musst?

(Es gibt natürlich schon haufenweise Bibliotheken für Matrix-Multiplikation, ich nehme also an, du machst das zum Lernen?)

danke für eure Antworten. Hab das Array jetzt durch einen std::vector ersetzt.
Funktioniert soweit erstmal.

Ein Problem habe ich aber noch, da es anscheinend sehr verpönt ist eine Kopie von *this zu erzeugen.

Wenn ich die Kopie nicht mache, wie kann ich denn dann auf die einzelnen Elemente meiner Instanz zugreifen?

wenn ich versuche über this[i][j] die daten zu bekommen, ist meine Ausgabe auf die Konsole total falsch.
Benutze ich jedoch die Kopie von this stimmt meine Ausgabe mit Get().

Was kann ich also machen um per Get() die richtigen Ausgaben zu bekommen?

Meine Motivation hinter dem ganzen ist mehr C++ zu lernen.
Finde es irgendwie cool was eigenes zu erschaffen, auch wenn es effizienter wäre auf eine fertige Bibliothek zuzugreifen.

Danke und Gruß

Ein Problem habe ich aber noch, da es anscheinend sehr verpönt ist eine Kopie von *this zu erzeugen.

Nicht verpönt, hier aber total unnötig - es gibt einfach keinen Grund dazu.

AlexR schrieb:

Wenn ich die Kopie nicht mache, wie kann ich denn dann auf die einzelnen Elemente meiner Instanz zugreifen?

wenn ich versuche über this[i][j] die daten zu bekommen, ist meine Ausgabe auf die Konsole total falsch.

Entweder operierst du direkt auf dem entsprechenden Member (in deinem Code pArray ) oder greifst mit (*this)[i][j] darauf zu. Mit (*this) dereferenzierst du den Zeiger auf das eigene Objekt und erhältst eine Referenz.

wenn ich versuche über this[i][j] die daten zu bekommen,

(*this)[i][j]
const Matrix& m1 = *this
Matrix operator +(const Matrix &m2, const Matrix &m2)

Ein Problem habe ich aber noch, da es anscheinend sehr verpönt ist eine Kopie von *this zu erzeugen.

Ich mach mal einen Autovergleich (etwas weit hergeholt, aber vielleicht gar nicht so schlecht):

Angenommen, du möchtest ein Auto probefahren (= Matrix ausgeben). Dann suchst du dir einen Mechaniker, der das Auto komplett nachbaut (=kopiert), dann machst du eine Probefahrt in dem nachgebauten Auto (=ausgeben der Matrix) und schließlich verschrottest du das nachgebaute Auto wieder (=Destruktor der Kopie). Klingt das für dich nicht auch sehr aufwendig?

Wäre es nicht einfacher, direkt das Auto probezufahren (=Ausgeben der Matrix ohne Kopie)?

Also merke: keine unnützen Kopien!

Das kopieren ist natürlich unsinnig, ich sehe es ein.

Danke für eure Hilfe.