[C] pointer naar een 2 dimensionaal array

[ntsx]

Ik ben bezig met het maken van een applicatie waar ik heel vaak de waardes van array 1 naar array 2 moet kopieren en array2 moet leeghalen...
Ik denk ik maak een pointer naar het ene array en eentje naar het andere zodat ik die alleen maar hoef te wisselen... dit scheelt 128x8 keer kopieren...

maar op de een of andere manier wil dit niet lukken

in mijn h file:

unsigned int a[128][8]; // tabel voor schermlayout
unsigned int b[128][8]; // tabel voor schermlayout
unsigned int** nieuw; // pointer naar tabel a
unsigned int** huidig; // pointer naar tabel b

maar nu gaat builder op zijn gat als ik in de c file dit doe:

nieuw = a;

dit is de error die hij mij nu geeft:

[C++ Error] Unit2.cpp(17): E2034 Cannot convert 'unsigned int ( *)[8]' to 'unsigned int * *'

Ik weet niet wat ik hier precies verkeerd doe... kan iemand mij dit duidelijk maken?

[_Thanatos_]

ik ben niet zo thuis in C++, maar "unsigned int**" is toch een pointer naar een pointer? Dan zul je vast niet bedoelen...

[ntsx]

toch wel... a is een pointer geloof ik. (ik heb het zonder die extra * ook al geprobeerd hoor)

[Zoijar]

type[][] en type** zijn niet hetzelfde in C++ dacht ik...meen me zo iets te herinneren, zal het even opzoeken... Dacht dat het erom ging dat char[5][5] een char* is met 25 items, op een bepaalde manier geindexed. En dat char** een pointer is naar een (array) van pointers. Maar char[][] wordt niet opgelsagen als een array van pointers naar arrays, maar als een platte array met index.

[ Voor 53% gewijzigd door Zoijar op 27-03-2004 20:53 ]

[Soultaker]

Zoijar heeft gelijk. Een array heeft in C niet echt dimensies; hij wordt gepresenteerd door een pointer naar een stuk geheugen waarin meerdere elementen passen. Ook meer-dimensionale arrays worden dus door een enkele pointer gerepresenteerd. Intern zijn er dus eigenlijk alleen 1-dimensionale arrays. Als je in jouw voorbeeld a[i][j] evalueert dan genereert de compiler code voor een 1-dimensionele array x, en herschrijft de expressie naar x[i*8 + j]. Dat is ook de reden dat de grootte van alle behalve één dimensie in het type verwerkt worden.

Een int** is niet eens op hoog nivo een array, want je gebruikt al direct een pointernotatie. Een int** is dus een pointer naar int* en elk 'element' dat je via die variabelen benadert zou dus een pointer naar int moeten zijn en die bestaat in dit geval niet. (Je kunt wel op die manier meer-dimensionale arrays bouwen, maar dat is wat lastiger met alloceren en omwille van de efficientie vaak ook niet aan te raden.)

Om een lang verhaal kort te maken: je moet de types in de declaratie van je variabelen laten overeenstemmen. Dit werkt bijvoorbeeld wel:

C:

unsigned int(*nieuw)[8]; // pointer naar tabel a
unsigned int(*huidig)[8]; // pointer naar tabel b

Als je die notatie wat verwarrend vind, dan ben ik dat met je eens, maar je moet het zo zien: de variabelen zijn pointers, naar een stuk geheugen waarin elementen staan die elk een array van 8 integers zijn. Verder kun je ze gewoon gebruiken als de arrays die je erboven gedeclareerd had.

[Verwijderd]

ntsx schreef op 27 maart 2004 @ 20:49:
toch wel... a is een pointer geloof ik. (ik heb het zonder die extra * ook al geprobeerd hoor)

Toch niet. In C (en C++) is een array een array en een pointer een pointer, en dat zijn in wezen totaal andere dingen. Dus als je 'unsigned int a[128][8];' schrijft dan is a echt een array. Nu is het wel zo dat een array soms als een pointer behandeld wordt -- de naam van een array in een expressie of de naam van een array in de declaratie van een functie parameter wordt door de compiler als een pointer naar het eerste element van de array behandeld (met enkele uitzonderingen, bvb als de naam van een array gebruikt word als de operand van een sizeof() of als het adres van een array wordt berekend door de & operator, etc); een array subscript is altijd equivalent aan een offset van een pointer -- en daardoor denken velen vaak dat arrays eigenlijk pointers zijn. Maar dat is dus niet zo.

Soultaker schreef op 27 maart 2004 @ 21:50:
Als je in jouw voorbeeld a[i][j] evalueert dan genereert de compiler code voor een 1-dimensionele array x, en herschrijft de expressie naar x[i*8 + j].

Niet juist. Een expressie van de vorm 'x[i]' zal door een compiler worden herschreven als '*(x+i)' omdat de C standaard dit gedrag eist, en dus zal je 'a[i][j]' herschreven worden als '*(a+i)[j]' (merk op dat array subscript voorrang heeft op pointer dereference) en tenslotte als *(*(a+i) + j)'. De '+' operatie die je in deze expressie vindt houdt rekening met het type pointer (een array subscript neemt een integer en een pointer-naar-type-T en resulteert in een object van type T), zodat 'x+i' niet betekent 'i bytes na x', maar eigenlijk 'i keer de grootte van een object van type T in bytes na x' als x een pointer-naar-type-T is.
Merk nog op dat de '+' operator hier commutatief is (het maakt niet uit of je x+3 of 3+x schrijf), zodat je een array subscript evengoed 'omgekeerd' kan doen. Je kan dus in C/C++ prima schrijven:

C:

char myname[6];
...
... = 2[myname];  // same as myname[2]
...

Heel handig om te gebruiken bij weddenschappen met beginnende C/C++ programmeurs

Soultaker schreef op 27 maart 2004 @ 21:50:
Een int** is niet eens op hoog nivo een array, want je gebruikt al direct een pointernotatie.

Correct. Pointers worden nooit als array behandeld, terwijl het omgekeerde wel kan gebeuren.

[ Voor 14% gewijzigd door Verwijderd op 28-03-2004 01:35 ]

[ntsx]

Bedankt jongens. mijn lcd'tje refreshed nu 2x zo snel.