3d array in classen

kiba91

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){}

Badestrand

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

*D*Evil

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

kiba91

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

Badestrand

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

Th

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.

kiba91

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

mad_martin

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

*D*Evil

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