[C++] Dynamisch een multidimensionele array maken

[Verwijderd]

Ik zit met een probleempje. Ik wil dynamisch een multidimensionele array maken, bv int iArray[10][10], maar dan dynamisch. Het lukt mij niet met:

int *iArray,
x = 10,
y = 10;
iArray = new int[x][y];

Ik heb het ook zo geprobeerd:

int *iArray,
x = 10,
y = 10;
iArray = new int[x * y];

iArray[x][y] genereerd vervolgens een foutmelding.
Wie weet hoe dit wel moet?

[Orphix]

Ik vraag me af of dat mogelijk is omdat de compiler dan in een geval als iArray[3][5] niet kan weten hoever het in het geheugen moet springen omdat de dimensies in compile time niet bekend zijn. Je zal dus met pointers moeten gaan werken ipv subscripts. Of met vectoren.

[Verwijderd]

Als je echte meerdimensionale arrays wilt maken moet je elke dimensie apart newen.

code:

int **array;

int x= 10,
    y= 10;

array= new int*[x];

for(int i= 0; i < x; ++i)
  array[i]= new int[y];

Nu kun je adresseren als array[x][y], maar dit is niet erg efficient omdat je verschillende arrays alloceert. Efficienter is het om een "flat array" te alloceren en zelf de index-omrekening te doen:

code:

class MyArray {
private:
  int _dim;
  int *_array;

public:
  MyArray(int xdim, int ydim)
    : _dim(xdim), _array(new int[xdim * ydim]) {}

  ~MyArray() { delete [] _array; }

  int operator () (int x, int y) const
    { return _array[x * _dim + y]; }

  int& operator () (int x, int y)
    { return _array[x * _dim + y]; }
};

Nu kun je adresseren met MyArray(x, y), en je alloceert maar één array.

[Verwijderd]

Op dinsdag 20 november 2001 14:30 schreef Melkor het volgende:
Ik zit met een probleempje. Ik wil dynamisch een multidimensionele array maken, bv int iArray[10][10], maar dan dynamisch. Het lukt mij niet met:

int *iArray,
x = 10,
y = 10;
iArray = new int[x][y];

Ik heb het ook zo geprobeerd:

int *iArray,
x = 10,
y = 10;
iArray = new int[x * y];

iArray[x][y] genereerd vervolgens een foutmelding.
Wie weet hoe dit wel moet?

Hier stond eerst een heleboel onzin, en ook wat dingetjes die geen onzin waren. Nu staat dat allemaal in verbeterde vorm wat verderop in deze thread.

[Verwijderd]

Op dinsdag 20 november 2001 15:29 schreef Xalista het volgende:
Als je beide (of alle) ranges variable wilt hebben kun je het beste een dynamisch array van dynamische arrays van dynamische arrays....enz. declareren en dat is niet inefficient. OO, dat is pas inefficient.

/me zucht

Wedden dat een flat-array adressering sneller is dan arrays van arrays adresseren? En als je niet OO wilt proggen is C++ niet je taal denk ik, gebruik dan C.

[farlane]

Op dinsdag 20 november 2001 15:33 schreef mietje het volgende:
Wedden dat een flat-array adressering sneller is dan arrays van arrays adresseren?

Sneller ? Wellicht. Mooier? Beter portable? Neuh...

[Verwijderd]

Dit gaat wel als je iArray = new int[10][10] gebruikt, maar dan zou je hem net zo goed designtime kunnen declareren.

In het algemeen lukt het als alleen je eerste range een variable is dwz:

int *iArray;
int (*iArray2)[10];
int x,y;
const int v = 10;
const int w = 10;

x = 10;
y = 10;

iArray = new int[10][10]; //gaat goed
iArray = new int[x][y]; //gaat fout
iArray = new int[v][w]; //gaat goed
iArray = new int[10][w]; //gaat fout
iArray = new int[v][10]; //gaat goed

iArray2 = new int[10][10]; //gaat goed
iArray2 = new int[x][10]; //gaat goed
iArray2 = new int[10][y]; //gaat fout

Genoeg voorbeelden?

Bij 3(of meer)d array's mag wederom alleen de eerste range variabel zijn. Je ziet dat je ook de declaratie van je array wat moet aanpassen om van deze methode gebruik te kunnen maken.

Als je beide (of alle) ranges variable wilt hebben kun je het beste een dynamisch array van dynamische arrays van dynamische arrays....enz. declareren en dat is niet inefficient (sorry mietje, ik ben het gewoon niet met je eens). OO, dat is pas inefficient.
En ik heb niks tegen OO, ik programmeer zelfs graag in C++, maar het is wel trager.

[Verwijderd]

Op dinsdag 20 november 2001 15:40 schreef farlane het volgende:
Sneller ? Wellicht. Mooier? Beter portable? Neuh...

Waarom is dit niet portable? Dit is de in de C++ FAQ aangeraden methode voor dit soort array's.

[ewasx]

Als je in plaats van een MD array een vector van vectoren maakt kan het wel weer. Het voordeel daarvan is dat je geen memory management zelf hoeft te doen, het nadeel is dat het wat langzamer is. Maar niet veel volgens de documentatie.