ich hab ein Problem. Der Compiler gibt mir keinerlei Fehlermeldung doch das Programm stürtzt immer ab. Mein Lehrer weiss auch nicht was falsch ist.

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <vector>
using namespace std;

void fill_matrix (vector<vector<int> >& mat){

    for (int zeile=0;zeile<3;zeile++){
        for(int spalte=0;spalte<3;spalte++){

            mat[zeile][spalte]= rand()%10;
        }
    }
}

void print_matrix(const vector<vector<int> >mat){

    for (int zeile=0;zeile<3;zeile++){
        for(int spalte=0;spalte<3;spalte++){
        cout << mat[zeile][spalte]<<" ";
        }
    cout << "\n";
    }
cout << "\n";
}

void multi_matrix(const vector<vector<int> > mat1,
                 const vector<vector<int> > mat2,
                 vector<vector<int> >& mat3){

    for(int a=0;a<3;a++){

        for(int b=0;b<3;b++){

        mat3[a][b] = mat1[a][b]*mat2[b][a];
        }
    }
}

int main()
{

    srand (time(NULL));

   vector<vector<int> >mat1,mat2,mat3;

    fill_matrix(mat1);
    print_matrix(mat1);
    fill_matrix(mat2);
    print_matrix(mat2);
    multi_matrix(mat1,mat2,mat3);
    print_matrix(mat3);
}

Wäre super wenn mir jemand helfen könnte ich habe keine Idee wie ich das Problem lösen soll. Und ohne es zu lösen kann ich das Programm natürlich auch nicht ausarbeiten. Ich wollte anfangen ne klasse anzulegen und so weiter.

Beste Grüße und danke schonmal
Photon

Edit:
Vektoren aus Vektoren sind etwas unglücklich für Matrizen, du kommst auch mit einem Vektor aus. Am besten baust du dir eine Matrizenklasse (wenn du das schon selbst machen musst und nichts fertiges benutzen darfst), die intern einen Vektor benutzt. Im Forum taucht diese Problem öfter auf, guck mal, ob du mit der Suchfunktion was findest.

Wie kann ich denn ein 2d vector per resize ansprechen bzw. wie benutze ich da pushback?

Und wie geht das ganze nur mit einem Vector?

Sry für die vielen fragen

vector<vector<int> > matrix(3);

matrix[0].resize(3);

int myValue = 5;
matrix[1].push_back(myValue);

Und wie geht das ganze nur mit einem Vector?

Ich werde aus diesem nicht den dritten Thread machen, in dem Dir gesagt wird, wie Du eine 2dimensionale Struktur mit einer 1dimensionalen darstellst.
Mal Dir Deine Matrix auf, und überleg, wie die Indices berechnet werden können, wenn Du alle Reihen nacheinander im Speicher liegen hast.
Danach fügst Du Dein Ergebnis unten ein.

class mat{
  int rows_, cols_;
  std::vector<int> data_;
public:
  mat(int rows, int cols) : rows_(rows), cols_(cols), data_(rows*cols){}
  int rows() const { return rows_; }
  int cols() const { return cols_; }
  int& operator()(int row, int col) { return data_[ /* magie hier */ ]; }
  const int& operator()(int row, int col) const { return data_[ /* magie hier */ ]; }
};

Ist nicht so schwer.

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>

using namespace std;

int main()
{

    srand(time(NULL));

    int row = 3, col = 3, data = row*col,h=0;
    vector<int> matrix;

    for(int i=0;i<data;i++){
        matrix.push_back(rand()%10);
        h++;
        cout << matrix[i] <<" ";
        if(h==row){cout <<"\n"; h=0;}
    }

}

Würde dann in deine erste Funktion die Multiplikation packen und in die zweite einfach nur was zum auslesen?!

Wird mich mal ranmachen. Wir haben leider PowerPoint diese Woche aber ein wenig programmieren nebenbei geht immer

Hmm Du bist auf dem Holzweg.
Ich bezog mich auf Deine Frage,

Photon schrieb:

Und wie geht das ganze nur mit einem Vector?

Und um Dir das nicht (zum wiederholten Male) um die Ohren zu hauen, ohne dass Du es verstehst habe ich eine kleine Übung daraus gemacht.
stell dir vor, Du willst eine 2*4 Matrix aufbauen.

| 0 | 1 | 2 | 3 |
--+---+---+---+---+
0 | A | B | C | D |
--+---+---+---+---+
1 | E | F | G | H |
--+---+---+---+---+

Du definierst und deklarierst das ganze

vector<vector<char>> vv(2, vector<char>(4,' '));

Und denkst Dir: "Das sieht häßlich aus und ist auch noch wenig performant."

Deswegen denkst Du Dir: ich kann doch auch einen Vektor nehmen, mit 2*4 Elementen und die Umrechnung von [reihe][spalte] in Indices selber machen.

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H |
+---+---+---+---+---+---+---+---+

Also z.B. [0][2] in der Struktur oben ist 'C', hat unten den Index 2.

Frage an Dich ist: wie ist die Formel, in die Du [reihe] und [spalte] reinsteckst und hinten Index rauskommt?

Klaro?

@ germaut es waren schon ein paar fehler bei der referenzübergabe von den const variablen drin aber daran lag es auch nicht.

Für jede aufgabe ne Funktion wäre auch schlecht. Eher für jede Rechenart.

Ich werde gleich mal anfangen und mir ne klasse erstellen und dann über indicies halt versuchen das zu lösen so wie in furbles Beispiel.

Ich komme nicht weiter. Ich glaube es hat wa mit public und private zu tun. Gibt es eine besondere art wie ich die funktion schreiben muss?

#include <iostream>
#include <vector>

class matrix{

    unsigned int row, col;
    std::vector<unsigned int> data;

public:

    matrix(unsigned int row,unsigned int col) : row(row),col(col),data(row*col){}

    void fill_matrix(matrix& mat){

        for(unsigned int i=0;i<=mat.data;i++){
            mat.data.push_back(i);

        }

    }
};

Gibt es eine besondere art wie ich die funktion schreiben muss?

Ja, als nicht-member Funktion.

Ich verstehe nicht warum die Anzahl der spalten redundant ist.

Über Fried hab ich ein wenig gelesen das leuchtet mir ein. Also die Stichworte heissen wohl getter/setter?! Ich schau gleich mal nach wie man das macht.

Eine Sache ist mir allerdings noch unklar muss ich ein setter schreiben und die Funktion ausserhalb der klasse oder funktioniert es so wenn ein setter vorhanden ist?

Danke für die Antwort!

unsigned& at(std::size_t i) { return data[i]; }
unsigned const& at(std::size_t i) const { return data[i]; }

Kannst natürlich sowohl auf unsigned als auch für size_t ein (richtiges) Typedef machen.

Ich hab jetzt mal das hier geschrieben

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>

class matrix{

unsigned reihe;
unsigned spalte;
std::vector <unsigned> data;

public:

matrix (int reihe, int spalte):
    reihe(reihe), spalte(spalte), data(reihe*spalte)
    {std::cout<< "\nMatrix wurde erstellt!\n";}

void set_matrix(){

    unsigned a=this->data.size();
    for(unsigned i=0;i<a;i++){
       this->data.push_back(rand()%10);
    }
}

};

int main()
{
    srand(time(NULL));

    unsigned a,b;

    std::cout<<"Wir bauen eine Matrix\n\nBitte anzahl der Reihen angeben: ";
    std::cin>> a;
    std::cout<<"\nBitte anzahl der Spalten angeben: ";
    std::cin>> b;

    matrix mat(a,b);
    mat.set_matrix();

}

Geht das in die richtige Richtung? Oder sollte ich eher noch eine schlichtere set Funktion schreiben die nur 1 pushback macht und diese dann in eine fill Funktion einbinden?

Danke für die geduld und hilfe

Oder sollte ich eher noch eine schlichtere set Funktion schreiben die nur 1 pushback macht und diese dann in eine fill Funktion einbinden?

Richtig. Zuerst ein fundamentaler Setter/Getter, dann Funktionen mit höherer Funktionalität. Und diese dann auch als non-member.

Wie würdest Du eine Funktion schreiben, die einen std::vector komplett mit zufälligen Werten füllt?
Welche Member von std::vector benutzt Du dabei?

Und in einem zweiten Schritt baust Du dann diese, bzw. ähnliche, Member in Deine Matrix.

Auf jeden fall ist mir gerade eine idee gekommen.
Könnte man nicht einfach die ersten beiden fächer vom vector dazu benutzen um die zahl der reihen und spalten zu speichern?

Mir ist auch aufgefallen das die anzahl der spalten für die rechnung garnicht notwendig ist. Mann muss nur die index spalte angeben. Vieleicht mein Sone ja das mit redundant?!

Ich weiss allerdings nicht ob man im konstruktor die matrix dann überhaupt korrekt öffnen kann. Es würde ja vorraussetzen dann man einer variablen der klasse 2 werte übergeben müsste damit eben data=row*col möglich ist. Ich hoffe ihr versteht was ich meine

So oder so Beste Grüße
Photon

Hier nochmal mein Beispiel von oben:

class mat{
  int rows_, cols_;
  std::vector<int> data_;
public:
  mat(int rows, int cols) : rows_(rows), cols_(cols), data_(rows*cols){}
  int rows() const { return rows_; }
  int cols() const { return cols_; }
  int& operator()(int col, int row) { return data_[ row*rows_+col ]; }
  const int& operator()(int col, int row) const { return data_[ row*rows_+col ]; }
};

Dazu ist es doch einfach eine (freie!) fill() Funktion zu schreiben, oder?
Das alles ist keine Magie - bis auf einen überladenen Operator.

Alternativ wäre eine einfache Funktion - wie Sone vorschlug:

class mat{
   // ....
public:
  // ....
  int& at(int col, int row) { return data_[ row*rows_+col ]; }
  const int& at(int col, int row) const { return data_[ row*rows_+col ]; }
};

Mir ist auch aufgefallen das die anzahl der spalten für die rechnung garnicht notwendig ist. Mann muss nur die index spalte angeben. Vieleicht mein Sone ja das mit redundant?!

Redundant heißt so viel wie überflüssig. Und die Anzahl der Spalten ist schon in der Größe des Arrays inbegriffen (Teilen der Größe des Arrays durch die Anzahl der Reihen ergibt ..).

Ich weiss allerdings nicht ob man im konstruktor die matrix dann überhaupt korrekt öffnen kann. Es würde ja vorraussetzen dann man einer variablen der klasse 2 werte übergeben müsste damit eben data=row*col möglich ist. Ich hoffe ihr versteht was ich meine

Du brauchst natürlich schon beide Konstruktorparameter, aber du musst die Anzahl der Spalte nicht als Member halten.

Das alles ist keine Magie - bis auf einen überladenen Operator.

Was ist an einer Operatorfunktion so grundlegend anders als bei einer 'gewöhnlichen' Memberfunktion? Beides Funktionen. Oder meinst du, das kennt er noch nicht?

Das alles ist keine Magie - bis auf einen überladenen Operator.

Was ist an einer Operatorfunktion so grundlegend anders als bei einer 'gewöhnlichen' Memberfunktion? Beides Funktionen. Oder meinst du, das kennt er noch nicht?

Fast sicher.
Aber ich hab's schön kursiv gesetzt, damit er gleich weiss, wo in seinem Buch, bzw. seinen Büchern er nachschlagen muss.

Redundant heißt so viel wie überflüssig. Und die Anzahl der Spalten ist schon in der Größe des Arrays inbegriffen (Teilen der Größe des Arrays durch die Anzahl der Reihen ergibt ..).

Ich würde es trotzdem speichern. Manchmal ist redundanz gut um den Compiler nicht zu verwirren. Und es gibt ganz gute Gründe, weswegen die Arraygröße davon abweichen kann

Ich hab ein problem mit der klasse. der compiler sagt mir das die 2 funktionen nicht im scope von main deklariert sind. Brauch ich da etwa ne prototype funktion? wenn ja wo pack ich die hin eigentlich in die klasse oder?

Liebe Grüße
Photon

#include <iostream>
#include <vector>

class matrix{

private:

    unsigned int row, col;
    std::vector<unsigned int> data;

public:

    matrix(unsigned int row,unsigned int col) : row(row),col(col),data(row*col){}

    void fill_matrix(matrix& mat){

        for(unsigned int i=0;i<=row*col;i++){
            mat.data.push_back(i);
        }
    }

    void print_matrix(const matrix& mat){

    unsigned int a=0;

    for(unsigned int i=0;i<=col;i++){

        for (unsigned int j=0;j<=row;j++){
            std::cout<<mat.data[a];
            }

            std::cout<<"\n";
            a++;
        }
    }
};

int main()
{

    matrix a(3,3);
    fill_matrix(a);
    print_matrix(a);

}

#include <iostream>
#include <vector>

class matrix{

private:

     unsigned int row, col;
     std::vector<unsigned int> data;

public:

     matrix(unsigned int row,unsigned int col) : row(row),col(col),data(row*col){}

     void fill_matrix(){

         for(unsigned int i=0;i<row*col;i++){
            data.push_back(i);
         }
     }

     void print_matrix(){

     unsigned int a=0;

     for(unsigned int i=0;i<col;i++){

         for (unsigned int j=0;j<row;j++){
             std::cout<<data[a];

             }

             std::cout<<"\n";
             a++;
         }
     }
};

int main()
{

     matrix a(3,3);
     a.fill_matrix();
     a.print_matrix();

}