Initialiseren van Arrays

[erv]

Hallo,

Is er inmiddels een mogelijkheid om een array dynamisch te initialliseren ?

Bas

 

[Neo Angelus]

Ik hoop dat ik de vraag goed begrijp en niet fout antwoord geef. Anders spijt het me, maar als ik het goed heb is de vraag hoe je een array kan maken met een niet vaststaande lengte?

Want dan kan ik drie oplossingen bedenken. De meest simpele(vind ik simpel tenminste) is gebruik te maken van vectors.Zie deze link over het gebruik van vectors.

Of(en alsjeblieft als ik het fout uitleg verbeter me) een pointer naar een array, maar dan moet je zelf memory allocaten, voordat je er gebruik van kan maken.

Bijvoorbeeld stel ik wil een array van int's maken dan wordt het:

int * intArray;
int lengteVDArray = 10;
intArray = (int*) malloc (lengteVDArray * sizeof(int));

Malloc allocate geheugen ruimte om plaats te maken voor de array. Omdat malloc(x), x geheugen ruimte allocate hebben we x * {grootte in het geheugen van wat in de array komt} nodig. Om te bepalen hoeveel geheugen ruimte iets inneemt is het mogelijk om sizeof({het type})} te gebruiken.(verbeter me als ik het fout heb)

Vanwege dit principe is het ook simpel om voor het gemak een hulp functie met behulp van een template te schrijven.

Voorbeeld:

template <class T>
T* makeArray(int length){
	return (T*) malloc (length * sizeof(T));
}

Hierdoor is het mogelijk om alleen maar;

int * intArray = makeArray<int>(10);

intArray[5] = 5;

te hoeven schrijven voor een array van ints van 10 lang .

Je moet er wel aan denken dat de Array geen default waardes heeft. Er wordt gewoon een stuk geheugen gepakt. Om de array een default waarde te geven kan natuurlijk gebruik worden gemaakt van polymorphie en het volgende stukje code:

template <class T>
T* makeArray(int length,T defaultValue){
	T* tmpA = (T*) malloc (length * sizeof(T));
	for(int i=0;i<length;i++){
		tmpA[i] = defaultValue;
	}
	return tmpA;
}

Let er bij dit alles op, dat er na gebruik van de arrays het stukje geheugen weer vrij moet worden gegeven door free(x) aan te roepen. Waarbij x de pointer is naar de array.(hoeft niet persé)

Nu het laatste. Wat heel erg lijkt op de vorige(maar geprefereerd schijnt te worden) is het gebruik van new and delete[] i.p.v. malloc and free. Delete[] is op precies de zelfde manier te gebruiken als free.

En i.p.v.

(T*) malloc (length * sizeof(T));

moet er

new T[length]

worden geschreven.

Dus bij een array van ints en van dynamische lengte length zijn er de volgende mogelijkheden

//include needed
#include <vector>


std::vector<int> intArray;
intArray.resize(length);

of

int* intArray = (int*)malloc(length*sizeof(int));

//na gebruik opruimen
free(intArray);

of

int* intArray = new int[length]

//na gebruik opruimen
delete[] intArray;

Ik hoop dat je er iets aan hebt. Voor een betere uitleg zie:
Vector


malloc
free

new & delete

Hoop dat je er mee geholpen bent.

 

[Supersnail]

Bijvoorbeeld stel ik wil een array van int's maken dan wordt het:

int * intArray;
int lengteVDArray = 10;
intArray = (int*) malloc (lengteVDArray * sizeof(int));

In C++ kan dit makkelijker met "new" ipv malloc.

int * intArray;
int lengteVDArray = 10;
intArray = new int[lengteVDArray];

Voor het opruimen na gebruik, gebruik je dan "delete".

delete intArray;

 

[Neo Angelus]

Die mogelijkheid had ik toch ook gegeven


Maar moet je voor het opruimen van een array niet delete[] gebruiken en delete voor het opruimen van een single object wat gemaakt is met new?(of maakt dat niet uit...)

http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=287
http://msdn.microsoft.com/en-us/library/k826zd10(VS.80).aspx

 

[Supersnail]

Die mogelijkheid had ik toch ook gegeven

Je hebt gelijk. Daar heb ik helemaal overheen gelezen, sorry.

Maar moet je voor het opruimen van een array niet delete[] gebruiken en delete voor het opruimen van een single object wat gemaakt is met new?(of maakt dat niet uit...)

Je hebt wederom gelijk. Voor het opruimen van een array moet je "delete[]" gebruiken (en ik moet voortaan beter opletten als ik hier reageer ).

 

[Murdocki]

maaruh waar jullie het over hebben is declaratie ( op het stukje van default waardes na dan ) weet niet of dit is wat jij bedoelde erv? mis kan je anders iets beter beschrijven wat je nou precies wilt doen

 

[erv]

Ik heb inmiddels al opgelost. Ik bedoeld eigenlijk hoe je bij een array met oneindige lengte (in mijn geval gemaakt met een pointer en new[] ) alle beginwaarde op 0 zet.

initialiseren is dat je meteen een beginwaarde voor een variable instelt , dus bijvoorbeeld:

int a = 3;
int array[3] = { 0,1,2} ;
int array_b[100000] = {0}; // In dit geval staan alle 100000 waardes op 0

Ik vroeg me af of je dit ook bij een dynamische array kon. Ik heb het maar gedaan met een for-lus. werkt net zo goed.

Maar ing bedankt voor de reacties