C++ Dynamische toewijzing van arrays met voorbeeld

Tijdens het maken van een array wordt er een vooraf bepaalde hoeveelheid geheugen aan toegewezen. Dit is niet het geval bij een dynamische array, omdat deze de geheugengrootte met een bepaalde factor vergroot wanneer dat nodig is.

Factoren die van invloed zijn op de prestaties van dynamische arrays

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 hij 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, zal het een groot stuk ongebruikt geheugen hebben. Hierdoor kunnen resize-bewerkingen langer duren. Dit zal de prestaties van de array verminderen.

Het nieuwe trefwoord

In C++, kunnen we een dynamische array maken met behulp van het nieuwe trefwoord. Het aantal items dat moet worden toegewezen, wordt opgegeven tussen een paar vierkante haken. De typenaam moet hieraan voorafgaan. Het gevraagde aantal items wordt toegewezen.

Syntaxis

Het nieuwe trefwoord heeft de volgende syntaxis:

pointer_variable = new data_type;

De pointer_variable is de naam van het aanwijzervariabele.

Het data_type moet geldig zijn C++ data type.

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

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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Neem het iostream-headerbestand op in ons programma om het te gebruiken functies.
2. Neem de std-naamruimte op in ons programma om de klassen ervan 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 gehele variabelen x en n.
5. Druk wat tekst af op de console waarin de gebruiker wordt gevraagd de waarde van variabele n in te voeren.
6. Lees de gebruikersinvoer van het toetsenbord en wijs deze toe aan variabele n.
7. Declareer dat een array een totaal van n gehele getallen kan bevatten en wijs deze toe aan de 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 door de gebruiker ingevoerde items te herhalen.
10. Lees de door de gebruiker ingevoerde elementen en sla ze op in de array arr.
11. Einde van het lichaam van de for loop.
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 doorlopen.
14. Druk de waarden af ​​in de array met de naam arr op de console.
15. Einde van de hoofdtekst van de for-lus.
16. Het programma moet waarde retourneren na succesvolle voltooiing.
17. Einde van de hoofdtekst van de functie main().

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

Initialiseren van dynamisch toegewezen arrays

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

Syntax:

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

In de bovenstaande syntaxis geeft de lengte het aantal elementen aan dat aan de array moet worden toegevoegd. Omdat we de array op 0 moeten initialiseren, moet dit leeg worden gelaten.

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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

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 ervan 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 geheel getalvariabele met de naam x.
5. Declareer een dynamische array genaamd array met behulp van een initializerlijst. De array bevat 5 gehele getallen. Merk op dat we de operator "=" niet hebben gebruikt tussen de arraylengte en de initializerlijst.
6. Druk wat tekst af op de console. Het einde is een C++ trefwoord dat eindregel betekent. Het verplaatst de cursor naar de volgende zin.
7. Gebruik een for-lus om de array-elementen te doorlopen.
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 retourneren na succesvolle voltooiing.
11. Einde van de hoofdtekst van de functie main().

Het formaat van arrays wijzigen

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

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

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

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

Dynamisch verwijderen van arrays

Een dynamische array moet uit het computergeheugen worden verwijderd zodra zijn doel is bereikt. De verwijderinstructie kan u hierbij helpen. De vrijgekomen geheugenruimte kan vervolgens 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, gegevensbeschadiging, 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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Neem het iostream-headerbestand op in ons programma om de functies ervan te kunnen gebruiken.
2. Neem de std-naamruimte op in ons programma om de klassen ervan 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 geheel getal.
5. Print wat tekst op de console. De tekst zal de gebruiker vragen om het aantal nummers dat hij/zij zal invoeren te noemen.
6. Lees gebruikersinvoer vanaf het toetsenbord. De invoerwaarde wordt toegewezen aan variabele n.
7. Declareer een pointervariabele *arr. De array arr reserveert wat geheugen om in totaal n gehele getallen op te slaan.
8. Druk een bericht af op de console waarin de gebruiker wordt gevraagd n getallen in te voeren.
9. Maak een for-lus en de lusvariabele x om over de door de gebruiker ingevoerde getallen te itereren.
10. Leest de door de gebruiker ingevoerde getallen en slaat 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 retourneert waarde wanneer het met succes is voltooid.
19. Einde van de hoofdtekst van de functie main().

Samenvatting

• Reguliere arrays hebben een vaste grootte. U kunt de grootte ervan niet meer wijzigen zodra deze is aangegeven.
• Bij dit soort arrays wordt de geheugengrootte bepaald tijdens het compileren.
• Dynamische arrays zijn anders. Hun afmetingen kunnen tijdens runtime worden gewijzigd.
• Bij dynamische arrays wordt de grootte tijdens runtime bepaald.
• Dynamische arrays in C++ worden gedeclareerd met het nieuwe trefwoord.
• We gebruiken vierkante haken om het aantal items aan te geven dat in de dynamische matrix moet worden opgeslagen.
• Zodra we klaar zijn met de array, kunnen we het geheugen vrijmaken met behulp van de delete-operator.
• Gebruik de delete-operator met [] om het geheugen van alle array-elementen vrij te maken.
• Een verwijdering zonder [] bevrijdt het geheugen van slechts één enkel element.
• Er is geen ingebouwd mechanisme om het formaat te wijzigen C++ reeksen.
• Om een ​​array te initialiseren met behulp van een lijstinitialisator, gebruiken we de operator “=” niet.