Index Operator überladen



  • Hi !!!

    Ich würde gerne in meinem Programm den Index Operator überladen.
    Ich habe eine Matrix, die aus drei Vektoren besteht:

    vector<double> val;
    vector<double> col;
    vector<double> row;
    

    val steht für den Wert, col, steht für die Spalte und row steht für die Zeile (zu beachten ist, dass row immer sortiert ist).
    Eine Matrix wird dann wie folgt gespeichert:

    1 2 0
    0 2 0
    4 0 1
    val: 1 2 2 4 1
    col: 0 1 1 0 2
    row: 0 0 1 2 2
    

    Zugriff auf z.B. das Element A[2][0] soll folgendermaßen zugegriffen werden:
    Suche in row nach der 3. Die Zahl 3 ist an Positionen 3-4 vorhanden.
    Suche in col an den Positionen 3-4 die "1". Falls gefunden, so gebe den Wert aus val, der an der gefundenen Position liegt. Falls nicht gefunden, so wird 0 ausgegeben.

    Was ich bisher in der Literatur zum Überladen des Operators operator[] gefunden habe, bezog sich immer auf Speicherung der Matrix mit Array.

    operator[](int index){...}
    

    Da liegt mein Problem. Überall wird nur ein Index mit angegeben. Wie kann ich den Operator so überladen, dass ich ein Zugriff auf die wie oben gespeicherte Matrix habe?



  • Kann mich jetzt zwar gewaltig irren, aber ich würde ne Matrix so machen.

    vector<vector<double> > Matrix;
    

    dann musst du nicht mal den [] op überladen. Der funktioniert doch dann schon von Haus aus.

    Wenn Du ihn denn noch überladen willst musst Dir klar sein, dass der erste Aufruf von [] ein objekt (oder Referenz) zurückliefern muss, das wiederum den [] op unterstützt.



  • Ja, so wie Du es schreibst ist eine ander Möglichkeit eine Matrix zu speichern. 😉 Doch das ist schon richtig so wie ich es oben angegeben habe. Die Matrix soll in dieser Art gespeichert werden.



  • Diese Datenstruktur ist nicht gerade einfach zu handlen, finde ich.

    Dann brauchst du ein Zwischenobjekt welches von der Matrix zurückgegeben wird.
    Zum Beispiel so:

    class Matrix 
    {
    public:
       vector<double> val;
       vector<double> col;
       vector<double> row; 
    
       MetaObject operator[](int rowIndex)
       {
          return MetaObject(this, rowIndex);
       }
    };
    
    class MetaObject
    {
    public:
       MetaObject(Matrix* matrix, int row){...}
       double operator[](int colIndex)
       {
          return matrix->GetValue(row, colIndex); //so eine Funktion wird es ja geben
       }
    };
    


  • Hmm, ja das stimmt, das ist wirklich nicht einfach zu handhaben.
    Ich hatte sowas schon befürchtet. 😞

    Aber vielen Dank, ich werde versuchen das umzusetzen.



  • So viele Layer wären mir bei ner Matrix zu viel des guten.
    Würde die versuchen so dünn zu halten wie möglich.
    Außerdem würde ich valarray und keinen vector nehmen, valarray ist der mathematische vektor und vector ist ja nur nen array.
    Wie wäre es mit operator() überladen, dem kannst mehrere Parameter verpassen und nen matrix( row, col ) sieht ja fast genauso schick aus.



  • Oh ja, stimmt, das ist eine gute Idee 👍
    Das Überladen des operator() ist deutlich einfacher zu handhaben 🙂


Log in to reply