Matrix in vector?



  • hallo,
    ich habe ein zweidimensionales array und will es in einem vector speichern.
    mein versuch (erstmal mit einem eindimensionalen, da ich annehme, dass es für zweidimensionale analog geht:

    int main ()
    {
    int n;
    cin >> n;
    vector<int*>  vec ;
    int *Arr;
    Arr = new int[n];   
        for (i=0; i<n; i++)                                 
                Arr[i]=i;
    
    vec.push_back(Arr);
    
    for( int i=0; i < v.size(); i++ )
        cout << v[i];
    delete [] Arr;
    }
    

    Als ausgabe kommt nur: 0x32588 was sehr verdächtig nach der adresse aussieht.
    Mache ich grundlegend etwas falsch oder liegt es an einem detail?

    ach ja: ich will das ganze array/ die ganze "matrix" auf einen platz in v speichern, sonst macht es keinen sinn. geht das? wenn nein wie kann man es sonst realisieren?
    vielen dank für die antworten!



  • Du speicherst mit vec.push_back(Arr) nur einen Pointer auf dein Array (Name des Arrays entspricht Pointer auf das erste Zeichen). Das finde ich auch völlig ok! Warum willst du das anders haben? Wenn du unbedingt die tatsächlichen Elemente des Arrays in dem vector speichern willst, kannst du das Element für Element in einer Schleife machen. Ich schätze, bequemere Möglichkeiten gibt es nicht.



  • vielen dank für die antwort.

    es ist so, dass dieses array mehrmals verändert wird und ich jede "version" dieses arrays brauche...

    also ich müßte auf jedem platz von vec ein ganzes array haben. ist das möglich?

    oder ich mache natürlich einen zweidimensionalen vector, aber da stellt sich die frage, wie ich es mit matrien, also zweidimensionalen arrays anstellen könnte!?



  • Als ausgabe kommt nur: 0x32588 was sehr verdächtig nach der adresse aussieht.
    Mache ich grundlegend etwas falsch oder liegt es an einem detail?

    Was sollte die Ausgabe denn sonst sein, wenn du nur die addresse des arrays im vector speicherst?

    Dein Fehler ist, dass du jetzt eine indirektion zuwenig machst. du hast jetzt ein vector von arrays. auf die elemente eines vectors greifst du dann mit operator [] zu. um dann noch auf die Werte des arrays zuzugreifen, musst du nochmal operator[] zugreifen(ein vector<int*> ist in etwa dasselbe wie int**).

    langer rede kurzer sinn:

    arraySize=//größe von Arr
    for( int i=0; i < v.size(); i++ )
    
    for( int j=0; j < arraySize; j++ )
        cout << v[i][j];
    


  • nun ich habe einen neuen anlauf genommen, wie gesagt, ich muss MEHRERE matrizen speichern.
    also:

    vector<vector <vector<int> > > v ;
    
    int bla=0;
        do  { 
            v.push_back(vector <vector<int>  >());
            for (int i=0;i<m;i++)    
            	 v[i].push_back(vector<int> ());
            for (int i=0;i<m;i++)
                for (j=0;j<m;j++)
                    { 
                    T[i][j]=bla;	
                    v[i][j].push_back(T[i][j]); //version 1
                    //v[bla][i][j]; version 2
                    }
            bla++;
    }
    while(bla<12);
    

    ich habe mal obiges testprogramm gemacht, T ein zweidimensionales array.
    kompiliere ich wie oben angezeigt version 1 kommt ein laufzeitfehler beim ausführen des programms; version 2 wird erst gar nicht kompiliert, denn: "push_back has not been declared"
    was mache ich falsch?



  • niemand eine idee?


  • Administrator

    Irgendwie habe ich das Gefühl, dass du die Sache ein wenig zu komplex angehst, deshalb will ich dir mal ein paar Tipps geben, vielleicht helfen dir die weiter:

    1. Es gibt fertige Matrix-Klassen im Inet, aber gut, dass du es selber versuchen willst!
    2. Wir sind in C++, da gibt es Klassen, womit man eine Matrix darstellen kann.
    3. Verzichte auf mehrdimensionale Arrays und speichere lieber in eindimensionalen. Gerade bei Matrizen geht das sehr gut.
    [11][12][13]
    [21][22][23]
    [31][32][33]
    
    Kann man umwandeln zu:
    [11][12][13][21][22][23][31][32][33]
    
    Wenn du dir merkst, wieviele Spalten die Matrix hat, kannst du schnell drauf zugreifen.
    
    1. Mal ein grobes Beispiel:
    class CMatrix
    {
        // Attributes //
    private:
        std::vector<int> m_MatrixVec;
        unsigned int m_iColumns;
    
        // Constructors & Destructor //
    public:
        CMatrix(unsigned int iRows, unsigned int iColumns)
            : m_MatrixVec(iRows * iColumns)
            , m_iColumns(iColumns)
        { }
    
        ~CMatrix() { };
    
        // Methods //
    public:
        int get_value(unsigned int iRow, unsigned int iCol) const { return m_MatrixVec.at(iRow * m_iColumns + iCol); };
        void set_value(unsigned int iRow, unsigned int iCol, int iValue) { m_Matrix.at(iRow * m_iColumns + iCol) = iValue; }
    }
    
    int main()
    {
        std::vector<CMatrix> m_MatrixVector;
        // Ein Vektor mit mehreren Matrizen.
    }
    

    Natürlich kann man noch Bereichsprüfungen reinnehmen, man könnte auf den Vektor in der Matrix verzichten und lieber auf ein C-Array setzen und vieles mehr.
    Aber etwas sollst du ja auch noch machen :p

    Grüssli


Log in to reply