Arrays binnen C++ | Verklaar | Initialiseren | Verwijzing naar array-voorbeelden

Waarom hebben we arrays nodig?

arrays zijn erg belangrijk in elke programmeertaal. Ze bieden een gemakkelijkere manier om variabelen of een verzameling gegevens van een vergelijkbaar gegevenstype samen op te slaan in plaats van ze afzonderlijk op te slaan. Elke waarde van de array wordt afzonderlijk benaderd.

Declareer een array in C++

Arraydeclaratie in C++ omvat het vermelden van het type en het aantal elementen dat door de array moet worden opgeslagen. Syntaxis:

type array-Name [ array-Size ];

Regels voor het declareren van een array met één dimensie in C++.

• Type: Het type is het type elementen dat in de array moet worden opgeslagen en moet geldig zijn C++ data type.
• Arraynaam: De arraynaam is de naam die aan de array moet worden toegewezen.
• Array-grootte: De array-Size is het aantal elementen dat in de array moet worden opgeslagen. Het moet een geheel getal zijn en groter dan 0.

U kunt bijvoorbeeld een array met de naam leeftijd maken en de leeftijden van vijf leerlingen als volgt opslaan:

int age[5];

De array-leeftijd slaat 5 gehele getallen op die de leeftijden van verschillende studenten vertegenwoordigen.

Array-initialisatie

Array-initialisatie is het proces waarbij elementen aan een array worden toegewezen/opgeslagen. De initialisatie kan in één enkele instructie of één voor één worden uitgevoerd. Merk op dat het eerste element in een array wordt opgeslagen op index 0, terwijl het laatste element wordt opgeslagen op index n-1, waarbij n het totale aantal elementen in de array is.

In het geval van de age-array wordt het eerste element opgeslagen op index 0, terwijl het laatste element wordt opgeslagen op index 4.

Laten we de age-array gebruiken om te demonstreren hoe array-initialisatie kan worden uitgevoerd:

int age[5] = {19, 18, 21, 20, 17};

Het totale aantal elementen binnen de { } kan niet groter zijn dan de waarde vermeld binnen de [ ]. Het element 19 staat op index 0, 18 op index 1, 21 op index 2, 20 op index 3 en 17 op index 4. Als u niet het aantal elementen vermeldt dat in de array moet worden opgeslagen tussen [ ], wordt de array zal alleen groot genoeg zijn om de elementen te bevatten die binnen { } zijn toegevoegd. Bijvoorbeeld:

int age[] = {19, 18, 21, 20, 17};

De bovenstaande verklaring creëert precies dezelfde array als de vorige. U kunt ook één element aan een array toewijzen met behulp van de index. Bijvoorbeeld:

age[3] = 20;

De bovenstaande verklaring slaat de waarde 20 op in index 3 van de array met de naam age. Dit betekent dat 20 de 4 zal zijn^th element van de array.

Soorten arrays

Er zijn twee types C++ arrays:

• Eéndimensionale array
• Multidimensionale matrix
• Wijzer naar een array

Eendimensionale array

Dit is een array waarin de gegevensitems lineair in slechts één dimensie zijn gerangschikt. Het wordt gewoonlijk een 1-D-array genoemd. Syntaxis:

datatype array-name[size];

• De arraynaam is de naam van de array.
• De grootte is het aantal items dat in de array moet worden opgeslagen.

Bijvoorbeeld:

#include <iostream>
using namespace std;

int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	for (int x = 0; x < 5; x++)
	{
		cout <<age[x]<<"\n";
	}
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Het aanroepen van de functie main() waarbinnen de logica van het programma moet worden toegevoegd.
4. Begin van de hoofdtekst van de functie main().
5. Een array met de naam age declareren om 5 gehele getallen op te slaan. De 5 gehele getallen zijn ook geïnitialiseerd.
6. Maak een integer-variabele x met behulp van een for-lus.
7. Het begin van de hoofdtekst van de for-lus.
8. Gebruik de lusvariabele x om de waarden van de array-leeftijd te herhalen en deze op de console af te drukken. De “\n” is een teken voor een nieuwe regel en wordt na elke iteratie op een nieuwe regel afgedrukt.
9. Einde van het lichaam van de for loop.
10. Einde van de hoofdtekst van de functie main().

Multidimensionale matrix

Dit is een array waarin gegevensitems zijn gerangschikt om een ​​array van arrays te vormen. Een multidimensionale array kan een willekeurig aantal dimensies hebben, maar tweedimensionale en driedimensionale arrays zijn gebruikelijk. Syntaxis:

datatype array-name[d1][d2][d3]...[dn];

De arraynaam is de naam van de array die n dimensies zal hebben. Bijvoorbeeld:

Tweedimensionale array

Een 2D-array slaat gegevens op in een lijst met 1-D-array. Het is een matrix met rijen en kolommen. Om een ​​2D-array te declareren, gebruikt u de volgende syntaxis:

type array-Name [ x ][ y ];

Het type moet geldig zijn C++ gegevenstype. Zie een 2D-array als een tabel, waarbij x het aantal rijen aangeeft en y het aantal kolommen. Dit betekent dat je elk element in een 2D-array identificeert met behulp van de vorm a[x][y], waarbij x het aantal rijen is en y het aantal kolommen waarin het element thuishoort.

Hier is een voorbeeld van hoe u een 2D-array kunt initialiseren:

int a[2][3] = {  
   {0, 2, 1} ,   /*  row at index 0 */
   {4, 3, 7} ,   /*  row at index 1 */
   };

In het bovenstaande voorbeeld hebben we een 2D-array die kan worden gezien als een 2×3-matrix. Er zijn 2 rijen en 3 kolommen. Element 0 is toegankelijk als [0][1] omdat het zich bevindt op het snijpunt van rij geïndexeerd 0 en kolom geïndexeerd 1. Element 3 is toegankelijk als [1][2] omdat het zich bevindt op de snijpunt van rij geïndexeerd 1 en kolom geïndexeerd 2.

Merk op dat we eenvoudigweg accolades hebben toegevoegd om de verschillende rijen elementen van elkaar te onderscheiden. De initialisatie had ook als volgt kunnen gebeuren:

int a[2][3] = {0, 2, 1, 4, 3, 7};
   };

De volgende C++ voorbeeld laat zien hoe je een 2D-array initialiseert en doorkruist:

#include <iostream>
using namespace std;
int main() 
{
	// a 2x3 array
	int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };

	// traverse array elements

	for (int i=0; i<3; i++)
		for (int j=0; j<2; j++) 
		
		{
			cout << "a[" <<i<< "][" <<j<< "]: ";
			cout << a[i][j] << endl;
		}
	return 0;
}

Output:

Hier is een screenshot van de bovenstaande code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Het aanroepen van de functie main() waarbinnen code moet worden toegevoegd.
4. Begin van de hoofdtekst van de functie main().
5. Een opmerking. De C++ compiler slaat dit over.
6. Een 2D-array van 3 rijen en 2 kolommen declareren. Er zijn ook items aan de array toegevoegd.
7. Een opmerking. De C++ compiler slaat dit over.
8. Een variabele maken met behulp van een for-lus. Deze variabele herhaalt zich over de rij-indexen van de array.
9. Een variabele j maken met behulp van a for een lus. Deze variabele herhaalt zich over de kolomindexen van de array.
10. Begin van het lichaam van de lussen.
11. Geef de waarden van variabelen i en j weer op de console, tussen vierkante haken.
12. Druk de waarde af die is opgeslagen in index [i][j] van array a.
13. Einde van het lichaam van de lussen.
14. De functie main() zou een geheel getal moeten retourneren als het programma goed werkt.
15. Einde van de hoofdtekst van de functie main().

Driedimensionale array

Een 3D-array is een array van arrays. Elk element in een 3D-array wordt geïdentificeerd door een set van 3 indexen. Om toegang te krijgen tot de elementen van een 3D-array gebruiken we drie for-lussen. Bijvoorbeeld:

#include<iostream>
using namespace std;
void main()
{
	int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};
	cout << "a[0][1][0] = " << a[0][1][0] << "\n";
	cout << "a[0][1][1] = " << a[0][1][1] << "\n";
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Het aanroepen van de functie main() waarbinnen de logica van het programma moet worden toegevoegd.
4. Begin van de hoofdtekst van de functie main().
5. Het declareren van een 3D-array met de naam 2x3x2. De waarden van de array zijn ook geïnitialiseerd.
6. Toegang krijgen tot het item dat is opgeslagen in index [0][1][0] van de array en dit afdrukken op de console.
7. Toegang krijgen tot het item dat is opgeslagen in index [0][1][1] van de array en dit afdrukken op de console.
8. Einde van de hoofdtekst van de functie main().

Wijzer naar een array

A wijzer is een variabele die een adres bevat. Behalve dat we een pointer gebruiken om het adres van een variabele op te slaan, kunnen we deze ook gebruiken om het adres van een arraycel op te slaan. De naam van een array verwijst voortdurend naar het eerste element. Beschouw de onderstaande verklaring:

int age[5];

De leeftijd is een pointer naar $age[0], het adres van het eerste element van een array met de naam age. Bekijk het volgende voorbeeld:

#include <iostream>
using namespace std;
int main()
{
	int *john;

	int age[5] = { 19, 18, 21, 20, 17 };

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

Output:

Houd er rekening mee dat de eerste waarde van de bovenstaande uitvoer een andere waarde kan retourneren, afhankelijk van het adres dat is toegewezen aan het eerste element van de array in het geheugen van uw computer.

Hier is een screenshot van de code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Het aanroepen van de functie main() waarbinnen de logica van het programma moet worden toegevoegd.
4. Begin van de hoofdtekst van de functie main().
5. Het declareren van een pointervariabele met de naam *john.
6. Het declareren van een integer-array met de naam age om 5 gehele getallen op te slaan. De waarden van de gehele getallen zijn ook geïnitialiseerd.
7. Door aan de variabele john de waarde toe te wijzen van het adres van het item dat is opgeslagen in de eerste index van de array-leeftijd.
8. De waarde van variabele john afdrukken, wat het adres is van het item dat is opgeslagen in de eerste index van de array-leeftijd.
9. Afdrukken van de eerste waarde die is opgeslagen in het array-tijdperk.
10. Einde van de hoofdtekst van de functie main().

Arraynamen kunnen worden gebruikt als constante verwijzingen, en omgekeerd geldt dit ook. Dit betekent dat u toegang hebt tot de waarde die is opgeslagen in index 3 van de array-leeftijd met *(leeftijd + 3). Bijvoorbeeld:

#include <iostream>
using namespace std;

int main() {
	// an array of 5 elements.
	int age[5] = { 19, 18, 21, 20, 17 };
	int *p;

	p = age;

	// output array values

	cout << "Using pointer: " << endl;

	for (int x=0; x<5; x++) {
		cout << "*(p + " << x << ") : ";
		cout << *(p + x) << endl;
	}
	cout << "Using age as address: " << endl;

	for (int x = 0; x < 5; x++) {
		cout << "*(age + " << x << ") : ";
		cout << *(age + x) << endl;
	}

	return 0;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Aanroepen van de functie main() en het begin van de hoofdtekst van de functie main().
4. Een opmerking. De C++ compiler slaat dit over.
5. Een array met de naam age declareren om 5 gehele getallen op te slaan.
6. Een integer-aanwijzer maken p.
7. Het toekennen van p de waarde van het adres van het eerste element van de array-leeftijd.
8. Een opmerking. De C++ compiler slaat dit over.
9. Druk wat tekst af op de console.
10. Maak een geheel getal x met behulp van een for een lus. De { markeert het begin van de hoofdtekst van een lus.
11. Druk de waarden van x af, gecombineerd met een andere tekst op de console.
12. Druk de waarden van *(p + x) af op de console.
13. Einde van het lichaam van de lus.
14. Druk wat tekst af op de console.
15. Maak een variabele x met behulp van een for een lus. De { markeert het begin van de hoofdtekst van de for-lus.
16. Print de waarden van x van 0 tot 4 samen met wat andere tekst.
17. Print de waarden van *(leeftijd + x).
18. Einde van de hoofdtekst van de for-lus.
19. Retourneert waarde als het programma succesvol wordt uitgevoerd.
20. Einde van de hoofdtekst van de functie main().

Toegang krijgen tot de waarden van een array

De elementen van een array worden benaderd met behulp van hun respectievelijke indexen. De index van het element dat benaderd moet worden, wordt toegevoegd tussen vierkante haken [ ] direct na de arraynaam. Bijvoorbeeld:

int john = age[2];

In het bovenstaande voorbeeld stellen we eenvoudigweg dat de leeftijd van John is opgeslagen in index 2 van de array genaamd age. Dit betekent dat de leeftijd van John de 3 is^rd waarde in de arrayleeftijd. Hier is een compleet C++ voorbeeld dat laat zien hoe u deze waarde kunt openen en afdrukken:

#include<iostream>
using namespace std;
int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	int john = age[2];
	cout << "The age of John is:"<<john;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Inclusief het iostream headerbestand in onze code. Hiermee kunnen we lezen van en schrijven naar de console.
2. Inclusief de std-naamruimte om de klassen en functies ervan te gebruiken zonder deze aan te roepen.
3. Het aanroepen van de functie main() waarbinnen code moet worden toegevoegd.
4. Begin van een hoofdgedeelte van de functie main().
5. Een array met de naam age declareren om 5 integer-elementen op te slaan.
6. Toegang krijgen tot de waarde die is opgeslagen in index 2 van de array-leeftijd en de waarde ervan opslaan in een variabele met de naam john.
7. Afdrukken van de waarde van variabele john op de console naast andere tekst.

Voordelen van een array-in C++

Hier volgen de voor- en voordelen van het gebruik van Array in C++:

• Array-elementen kunnen gemakkelijk worden doorlopen.
• Eenvoudig te manipuleren arraygegevens.
• Array-elementen zijn willekeurig toegankelijk.
• Arrays vergemakkelijken code-optimalisatie; Daarom kunnen we veel werk verrichten met minder code.
• Eenvoudig te sorteren arraygegevens.

Nadelen van een array in C++

• Een array heeft een vaste grootte; daarom kunnen we er na initialisatie geen nieuwe elementen aan toevoegen.
• Het toewijzen van meer geheugen dan nodig leidt tot verspilling van geheugenruimte, en minder geheugentoewijzing kan een probleem veroorzaken.
• Het aantal elementen dat in een array moet worden opgeslagen, moet vooraf bekend zijn.

Samenvatting

• Een array is een gegevensstructuur waarin elementen van hetzelfde gegevenstype zijn opgeslagen.
• Array-elementen worden opeenvolgend opgeslagen.
• De array-elementen worden aangegeven met behulp van hun respectievelijke indexen. Het eerste element bevindt zich op index 0, terwijl het laatste element zich op index n-1 bevindt, wat het totale aantal array-elementen is.
• De declaratie van een array omvat het definiëren van de gegevenstypen van de array-elementen, evenals het aantal elementen dat in de array moet worden opgeslagen.
• Een eendimensionale array slaat elementen opeenvolgend op.
• Een tweedimensionale array slaat elementen op in rijen en kolommen.
• Een driedimensionale array is een array van arrays.
• Elementen kunnen aan een array worden toegevoegd met behulp van hun indexen.
• Array-elementen zijn toegankelijk via hun indexen.
• Een multidimensionale array heeft meer dan één dimensie.
• De arraynaam verwijst naar het eerste element.
• Arrays hebben een vaste grootte, wat betekent dat er na de initialisatie geen nieuwe elementen aan de array kunnen worden toegevoegd.