Operator+ overloading, 2D Vector

[Michael S. (michaelsmith)]

Hallo,

ich habe ein Problem mit dem operator overloading.
ich habe 2 Matrizen die ich in der main() addieren möchte,

Matrix x;
Matrix y;
Matrix result;

// eingabe wird über cin>> gehandelt...
x.a[2][2] = {{2, 2}, {2, 2}}
y.a[2][2] = {{1, 2}, {3, 4}}

result=x+y;  // result soll {{3,4},{5,6}} ausgeben

class Matrix{    
    public:
        std::vector<std::vector<int>>  a;
        Matrix operator+(const Matrix& f_object)
        {
            Matrix result;
            int i = 0;

            for(int y = 0; y<a.size(); y++)
            {
                for(int z = 0; z<a[y].size(); z++)
                {
                    cout<<"a[y][z]: "<<a[y][z]<<endl;//dieser Kommentar wird noch angezeigt
                    result.a[y][z]=(a[y][z] + f_object.a[y][z]); // hier kommt der Absturz
                    cout << "f_object.a["<<y<<"]"<<"["<<i<<"]: "<< f_object.a[y][i] << endl; // dieser Kommentar nicht mehr
                }
            }
            return result;
        }
};

habe ich was übersehen,

[Andreas M. (amesser)]

Wie stellst Du sicher, dass a und f_object.a die selbe Dimension haben? 
Du nimmst die Größe der ersten Dimension von f_object.a und die Größe 
der zweiten Dimension von a als Iterationsgrenzen für beide Arrays. Was 
passiert, wenn die erste Dimension von a aber kleiner ist als von 
f_object.a...

[Michael S. (michaelsmith)]

Andreas M. schrieb:
> Wie stellst Du sicher, dass a und f_object.a die selbe Dimension
> haben?
> Du nimmst die Größe der ersten Dimension von f_object.a und die Größe
> der zweiten Dimension von a als Iterationsgrenzen für beide Arrays. Was
> passiert, wenn die erste Dimension von a aber kleiner ist als von
> f_object.a...

hast natürlich recht, habe jetzt überall a als Referenz genommen.
die Grössen der Matrizen sind fest definiert, daher checke ich zur Zeit 
nicht ob die Grösse gleich ist.


also so funktioniert es, ich verstehe aber nicht ganz warum der 2D Array 
Ansatz nicht tut;

        Matrix operator+(const Matrix& f_object)
        {
            Matrix result;
            int i = 0;

            for(int y = 0; y<a.size(); y++)
            {
               std::vector<int> temp;
                for(int z = 0; z<a[y].size(); z++)
                {
                //    result.a[y][z]=(a[y][z] + f_object.a[y][z]);
                     temp.push_back(a[y][z] + f_object.a[y][z]);
                }

               result.a.push_back(temp);
            }
            return result;
        }

[Wilhelm M. (wimalopaan)]

Was soll denn passieren, wenn Du Matrizen unterschiedlicher Dimension 
addierst? Diese Frage solltest Du Dir als erstes beantworten.

Wenn Du dann zu dem Schluss kommst, dass das sinnlos ist, solltest Du 
das Du das Typsystem unterbinden.

[Εrnst B. (ernst)]

Wilhelm M. schrieb:
> Wenn Du dann zu dem Schluss kommst, dass das sinnlos ist, solltest Du
> das Du das Typsystem unterbinden.

Da würde sich anbieten, "Matrix" als Template-Klasse anzulegen, mit den 
Dimensionen und dem Datentyp als Template-Parameter.

Ansonsten: auch wenn "this" und "f_objekt" beides 2×2-Matrizen sind, 
"Matrix result;" ist es nicht.

[Andreas M. (amesser)]

Michael S. schrieb:
> also so funktioniert es, ich verstehe aber nicht ganz warum der 2D Array
> Ansatz nicht tut;

Weil result.a die Dimension (0,0) hat. Du musst result.a schon 
initialisieren. std::vector ist ein dynamisches array.

[Εrnst B. (ernst)]

Beispiel im Anhang...

[Wilhelm M. (wimalopaan)]

Kleine Ergänzung:

#include <iostream>
#include <vector>
#include <type_traits>
template <size_t rows, size_t cols, typename T>
requires std::is_arithmetic_v<T>
class Matrix {
// ...
};

Denn ein

Matrix<42, 43, std::string>

macht ggf. wenig Sinn.

[Michael S. (michaelsmith)]

ahhh, d.h. wenn ich über push_back gehe, brauche ich keine Grösenangaben 
zum Array. Wenn aber Zuweisung über die einzelnen Elemente statt findet, 
dann muss zuerst die Initialisierung her.

PS. danke fürs Template

[Εrnst B. (ernst)]

Wilhelm M. schrieb:
> Denn ein
> Matrix<42, 43, std::string>
> macht ggf. wenig Sinn.

Stimmt natürlich. Würde aber Kompilieren :)

    Matrix<3, 3, std::string> matrixA({ {"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"} });
    Matrix<3, 3, std::string> matrixB({ {"9", "8", "7"}, {"6", "5", "4"}, {"3", "2", "1"} });

    Matrix<3, 3, std::string> matrixC = matrixA + matrixB;

    std::cout << "Matrix A:\n" << matrixA;
    std::cout << "Matrix B:\n" << matrixB;
    std::cout << "Matrix C (A + B):\n" << matrixC;

-->

Matrix A:
1 2 3 
4 5 6 
7 8 9 
Matrix B:
9 8 7 
6 5 4 
3 2 1 
Matrix C (A + B):
19 28 37 
46 55 64 
73 82 91

🤡

[Wilhelm M. (wimalopaan)]

Und da die Matrix dann compilezeit-konstant in ihrer Größe ist, wäre 
natürlich ein std::array als Container besser.

[Εrnst B. (ernst)]

Michael S. schrieb:
> PS. danke fürs Template

Hier noch eine Ergänzung für die Klasse:

    Matrix<cols, rows, T> transpose() const {
        Matrix<cols, rows, T> result;

        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                result[j][i] = data[i][j];
            }
        }

        return result;
    }

Für den Lern-Effekt, wie dir der Compiler mit Templates da hilft Fehler 
schon zur Compile-Zeit zu vermeiden. Für Nicht-Quadratische Matrizen 
gibt transpose einen anderen Datentyp zurück...

[Εrnst B. (ernst)]

Wilhelm M. schrieb:
> Und da die Matrix dann compilezeit-konstant in ihrer Größe ist, wäre
> natürlich ein std::array als Container besser.

Psst, nicht zuviele Neuerungen auf einmal. Aber würde den Code sogar 
einfacher machen.

private:
    std::array<std::array<T, cols>, rows> data;

Und der Matrix()-Konstruktor hat dann nix mehr zu tun.

[Wilhelm M. (wimalopaan)]

Man kann sogar noch etwas weiter gehen und  bspw.

Matrix<2, 3, float> a;
Matrix<2, 3, double> b;

auto c = a + b;

möglich machen. Dann ist man bei TMP und muss / sollte eine Metafunktion 
F(T1, T2) -> T schreiben, also etwa F<float, double> -> double.

[Wilhelm M. (wimalopaan)]

Εrnst B. schrieb:
> Und der Matrix()-Konstruktor hat dann nix mehr zu tun.

Falls Du den cctor meinst: nein.

[Rolf M. (rmagnus)]

Wilhelm M. schrieb:
> Εrnst B. schrieb:
>> Und der Matrix()-Konstruktor hat dann nix mehr zu tun.
>
> Falls Du den cctor meinst: nein.

Ich weiß nicht, was das sein soll, aber er meint offenbar den 
default-Konstruktor Matrix() (wie er ja auch schreibt), der in der 
aktuellen Version dafür sorgt, dass die Vektoren ihren Speicher 
allokieren.

[Wilhelm M. (wimalopaan)]

Rolf M. schrieb:
> Wilhelm M. schrieb:
>> Εrnst B. schrieb:
>>> Und der Matrix()-Konstruktor hat dann nix mehr zu tun.
>>
>> Falls Du den cctor meinst: nein.
>
> Ich weiß nicht, was das sein soll,

die übliche Bezeichnung für copy-constructor

> aber er meint offenbar den
> default-Konstruktor Matrix() (wie er ja auch schreibt), der in der
> aktuellen Version dafür sorgt, dass die Vektoren ihren Speicher
> allokieren.

... den ich dann irgendwie übersehen hatte ...