C++ Dynamische toewijzing van arrays met voorbeeld

Wat is een dynamische array?

Een dynamische array lijkt veel op een gewone array, maar de grootte ervan kan worden gewijzigd tijdens de looptijd van het programma. DynamArray-elementen nemen een aaneengesloten geheugenblok in beslag.

Als een array eenmaal is gemaakt, kan de grootte ervan niet meer worden gewijzigd. Een dynamische array is echter anders. Een dynamische array kan groter worden, zelfs nadat deze is gevuld.

Tijdens het maken van een array wordt een vooraf bepaalde hoeveelheid geheugen toegewezen. Dit is niet het geval bij een dynamische array, omdat het geheugen met een bepaalde factor groeit wanneer dat nodig is.

In deze C++ tutorial leer je

• Wat is een dynamische array?
• Factoren die de prestaties van dynamische arrays beïnvloeden
• Het nieuwe zoekwoord
• Dynamisch toegewezen arrays initialiseren
• Formaat van arrays wijzigen
• Dynamisch verwijderen van arrays

Factoren die de prestaties van dynamische arrays beïnvloeden

De initiële grootte van de array en de groeifactor bepalen de prestaties. Let op de volgende punten:

1. Als een array een kleine omvang en een kleine groeifactor heeft, zal het geheugen vaker opnieuw toewijzen. Dit zal de prestaties van de array verminderen.
2. Als een array een grote omvang en een grote groeifactor heeft, heeft deze een enorm stuk ongebruikt geheugen. Hierdoor kunnen bewerkingen voor het wijzigen van de grootte langer duren. Dit zal de prestaties van de array verminderen.

Het nieuwe zoekwoord

In C++ kunnen we een dynamische array maken met het nieuwe sleutelwoord. Het aantal toe te wijzen items wordt aangegeven tussen een paar vierkante haken. De typenaam moet hieraan voorafgaan. Het gevraagde aantal items wordt toegewezen.

Syntaxis:

Het nieuwe zoekwoord heeft de volgende syntaxis:

pointer_variable = new data_type;

De pointer_variable is de naam van de pointervariabele.

Het data_type moet een geldig C++ datatype zijn.

Het sleutelwoord retourneert vervolgens een aanwijzer naar het eerste item. Nadat we de dynamische array hebben gemaakt, kunnen we deze verwijderen met het delete-sleutelwoord.

Voorbeeld 1:

#include<iostream>
using namespace std;
int main() {
	int x, n;
	cout << "Enter the number of items:" << "\n";
	cin >>n;
	int *arr = new int(n);
	cout << "Enter " << n << " items" << endl;
	for (x = 0; x < n; x++) {
		cin >> arr[x];
	}
	cout << "You entered: ";
	for (x = 0; x < n; x++) {
		cout << arr[x] << " ";
	}
	return 0;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Voeg het iostream-headerbestand toe aan ons programma om de functies ervan te gebruiken.
2. Neem de std-naamruimte op in ons programma om de klassen te gebruiken zonder deze aan te roepen.
3. Roep de functie main() aan. De programmalogica moet worden toegevoegd aan de hoofdtekst van de functie.
4. Declareer twee integer-variabelen x en n.
5. Druk wat tekst af op de console en vraag de gebruiker om de waarde van variabele n in te voeren.
6. Lees gebruikersinvoer vanaf het toetsenbord en wijs deze toe aan variabele n.
7. Declareer een array die in totaal n gehele getallen bevat en wijs deze toe aan pointervariabele *arr.
8. Druk een bericht af waarin de gebruiker wordt gevraagd n aantal items in te voeren.
9. Gebruik een for-lus om een ​​lusvariabele x te maken om de items die door de gebruiker zijn ingevoerd te herhalen.
10. Lees de elementen die door de gebruiker zijn ingevoerd en sla ze op in de array arr.
11. Einde van de hoofdtekst van de for-lus.
12. Druk wat tekst af op de console.
13. Gebruik een for-lus om een ​​lusvariabele x te maken om de items van de array te herhalen.
14. Druk de waarden in de array met de naam arr af op de console.
15. Einde van de hoofdtekst van de for-lus.
16. Het programma moet waarde teruggeven na succesvolle voltooiing.
17. Einde van de hoofdtekst van de functie main().

OPMERKING:In het bovenstaande voorbeeld mag de gebruiker elke grootte voor de array opgeven tijdens runtime. Dit betekent dat de grootte van de array wordt bepaald tijdens runtime .

Dynamisch toegewezen arrays initialiseren

Het is gemakkelijk om een ​​dynamische array op 0 te initialiseren.

Syntaxis:

int *array{ new int[length]{} };

In de bovenstaande syntaxis geeft de lengte het aantal elementen aan dat aan de array moet worden toegevoegd. Aangezien we de array op 0 moeten initialiseren, moet deze leeg blijven.

We kunnen een dynamische array initialiseren met behulp van een initialisatielijst. Laten we een voorbeeld maken dat dit aantoont.

Voorbeeld 2:

#include <iostream>
using namespace std;

int main(void) {

	int x; 

	int *array{ new int[5]{ 10, 7, 15, 3, 11 } };

	cout << "Array elements: " << endl;

	for (x = 0; x < 5; x++) {

		cout << array[x] << endl;
	}

	return 0;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Voeg het iostream-headerbestand toe aan ons programma om de functies ervan te gebruiken.
2. Neem de std-naamruimte op in ons programma om de klassen te gebruiken zonder deze aan te roepen.
3. Roep de functie main() aan. De programmalogica moet worden toegevoegd aan de hoofdtekst van de functie.
4. Declareer een integer-variabele met de naam x.
5. Declareer een dynamische array met de naam array met behulp van een initialisatielijst. De array zal 5 integer-elementen bevatten. Merk op dat we de operator "=" tussen de arraylengte en de initialisatielijst niet hebben gebruikt.
6. Druk wat tekst af op de console. De endl is een C++-sleutelwoord dat eindregel betekent. Het verplaatst de cursor naar de volgende zin.
7. Gebruik een for-lus om de array-elementen te herhalen.
8. Druk de inhoud van de array met de naam array af op de console.
9. Einde van de hoofdtekst van de for-lus.
10. Het programma moet waarde teruggeven na succesvolle voltooiing.
11. Einde van de hoofdtekst van de functie main().

Formaat van arrays wijzigen

De lengte van een dynamische array wordt ingesteld tijdens de toewijzingstijd.

C++ heeft echter geen ingebouwd mechanisme om de grootte van een array te wijzigen nadat deze is toegewezen.

U kunt deze uitdaging echter overwinnen door dynamisch een nieuwe array toe te wijzen, de elementen te kopiëren en vervolgens de oude array te wissen.

Let op:deze techniek is gevoelig voor fouten, probeer het daarom te vermijden.

Dynamisch verwijderen van arrays

Een dynamische array moet uit het computergeheugen worden verwijderd zodra het doel is bereikt. De delete-instructie kan u hierbij helpen. De vrijgekomen geheugenruimte kan dan worden gebruikt om een ​​andere set gegevens op te slaan. Maar zelfs als u de dynamische array niet uit het computergeheugen verwijdert, wordt deze automatisch verwijderd zodra het programma wordt beëindigd.

Opmerking:

Om een ​​dynamische array uit het computergeheugen te verwijderen, moet u delete[] gebruiken in plaats van delete. De [] instrueert de CPU om meerdere variabelen te verwijderen in plaats van één variabele. Het gebruik van delete in plaats van delete[] bij het omgaan met een dynamische array kan tot problemen leiden. Voorbeelden van dergelijke problemen zijn geheugenlekken, gegevenscorruptie, crashes, enz.

Voorbeeld 3:

#include<iostream>
using namespace std;
int main() {
	int x, n;
	cout << "How many numbers will you type?" << "\n";
	cin >>n;
	int *arr = new int(n);
	cout << "Enter " << n << " numbers" << endl;
	for (x = 0; x < n; x++) {
		cin >> arr[x];
	}
	cout << "You typed: ";
	for (x = 0; x < n; x++) {
		cout << arr[x] << " ";
	}
	cout << endl;
	delete [] arr;
	return 0;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Neem het iostream-headerbestand op in ons programma om de functies ervan te gebruiken.
2. Neem de std-naamruimte op in ons programma om de klassen te gebruiken zonder deze aan te roepen.
3. Roep de functie main() aan. De programmalogica moet worden toegevoegd aan de hoofdtekst van de functie.
4. Declareer twee variabelen x en n van het gegevenstype integer.
5. Druk wat tekst af op de console. In de tekst wordt de gebruiker gevraagd het aantal cijfers op te geven dat hij zal invoeren.
6. Lees gebruikersinvoer vanaf het toetsenbord. De invoerwaarde wordt toegewezen aan variabele n.
7. Declareer een pointervariabele *arr. De array arr zal wat geheugen reserveren om in totaal n gehele getallen op te slaan.
8. Druk een bericht af op de console waarin de gebruiker wordt gevraagd n cijfers in te voeren.
9. Maak een for-lus en de lusvariabele x om de door de gebruiker ingevoerde getallen te herhalen.
10. Lees de getallen die door de gebruiker zijn ingevoerd en sla ze op in de array arr.
11. Einde van de hoofdtekst van de for-lus.
12. Druk wat tekst af op de console.
13. Gebruik een for-lus en de lusvariabele x om de inhoud van array arr te herhalen.
14. Druk de waarden van de array arr af op de console.
15. Einde van de hoofdtekst van de for-lus.
16. Druk een lege regel af op de console.
17. Maak het geheugen vrij van de array-arr.
18. Het programma zal waarde teruggeven wanneer het succesvol is voltooid.
19. Einde van de hoofdtekst van de functie main().

Samenvatting:

• Gewone arrays hebben een vaste grootte. U kunt hun grootte niet wijzigen nadat ze zijn aangegeven.
• Bij dit type arrays wordt de geheugengrootte bepaald tijdens het compileren.
• Dynamische arrays zijn anders. Hun afmetingen kunnen tijdens runtime worden gewijzigd.
• In dynamische arrays wordt de grootte bepaald tijdens runtime.
• Dynamische arrays in C++ worden gedeclareerd met het nieuwe sleutelwoord.
• We gebruiken vierkante haken om het aantal items op te geven dat in de dynamische array moet worden opgeslagen.
• Als we klaar zijn met de array, kunnen we geheugen vrijmaken met behulp van de delete-operator.
• Gebruik de delete-operator met [] om het geheugen vrij te maken van alle array-elementen.
• Een verwijdering zonder [] maakt het geheugen van slechts een enkel element vrij.
• Er is geen ingebouwd mechanisme om de grootte van C++-arrays te wijzigen.
• Om een ​​array te initialiseren met behulp van een lijstinitialisator, gebruiken we de operator "=" niet.