3d array in classen



  • hab ein problem bei der erstellung von arrays
    ich will ein 3d-array erstellen wo die größen des arrays
    im konstruktor angegeben werden

    sollte ungefär so aussehen:

    class My{
        unsigned int id [] [] [];
        My(int,int,int);
    
    };
    My::My(int x,int y,int,z):id[x][y][z](0){}
    


  • Wenn die Array-Größe erst im Konstruktor angegeben werden soll, musst du das Array dynamisch verwalten, also mit new/delete



  • Oder std::vector nutzen ...

    class foo
    {
        std::vector< std::vector< std::vector<unsigned int> > > m_data;
    
    public:
        foo(std::size_t x, std::size_t y, std::size_t z) 
        { 
            m_data.resize(x); 
            for (std::size_t i = 0; i < x; ++i) 
            { 
                m_data.at(i).resize(y); 
                for (std::size_t j = 0; j < y; ++j) 
                    m_data.at(i).at(j).resize(z);
            }
        }
    };
    

    finde ich aber unschön 😛 Wie wäre es mit 3D auf 1D abbilden? Hätte doch was 🙂

    Dimension: x = 2, y = 3, z = 4
    0 0 0
    0 0 1
    0 0 2
    0 0 3
    0 1 0
    0 1 1
    0 1 2
    0 1 3
    0 2 0
    0 2 1
    0 2 2
    0 2 3
    1 0 0
    1 0 1
    1 0 2
    1 0 3
    1 1 0
    1 1 1
    1 1 2
    1 1 3
    1 2 0
    1 2 1
    1 2 2
    1 2 3
    

    So viele Elemente haben wir ja. Also x * y * z muss unser std::vector groß sein. Kein Problem...
    Muss dir jetzt nur überlegen, wie du an das richtige Element kommst ...
    x + y * length_x ist es bei 2D also bei einem 10, 20 großen Array wäre dass Element (x, y) folglich an stelle: x + y * 20. Das muss du nur auf 3D übertragen 🙂



  • könnte man nicht den 3d-array erst später definiren
    z.b. im konstruktor
    anstadt in der klasse selbst



  • Nó, geht nicht, weil bei solchen statischen Arrays der Compiler immer schon zur Kompilierzeit (also bevor er die exe-Datei erzeugt) wissen muss, wie groß das Array ist. Wenn du die Argumente beim Konstruktor übergibst, können es ja was-weiß-ich-für-Werte sein, der Compiler weiß also erst zur Laufzeit, wie groß das Array ist - that's the problem 🙂



  • Nein, einfacher als die Abbildung auf ein 1D-Array geht es nicht.
    Die Alternative wäre ein int***, wobei du dann jeweils die Unterarrays dynamisch anlegen müßtest (je Ebene) und das ist zum einen ineffizient und auch sehr fehleranfällig.



  • hab das problem gelöst
    hab einfach c++-array verwendet und bischen mit vector experementirt

    //defini
    std::vector<std::vector<std::vector<int> > > Array3D; 
    // ein leeres 3d-array als typ int
    
    //deklar
    std::vector<std::vector<std::vector<int> > > Array3D
    ( 10,std::vector<std::vector<int> >
    ( 15,std::vector<int( 20, 888 ) ) ); 
    //das array heißt Array3D und hat die größen [10][15][20] 
    //und alle haben den wert 888
    
    //zugriff per: 
    Array3D.at(2).at(2).at(2);
    //zugrif auf [2][2][2]
    //oder
    Array3D[2][2][2];  //müsse eigentlich auch gehen
    


  • Letzteres geht auch, aber ohne Bounds-Prüfung. Das geht dann einfach kaputt, wenn du übers Ziel hinaus schießt mit den Indizes.



  • Jo ... hab ich dir auch bereits geschrieben gehabt ... kommst de schnell drauf 😛 Ist aber nicht die eleganteste Lösung!


Log in to reply