Arrays i C++ | Erklære | Initialiser | Pointer to Array Eksempler

Hvorfor har vi brug for arrays?

Arrays er meget vigtige i ethvert programmeringssprog. De giver en mere bekvem måde at gemme variabler eller en samling af data af en lignende datatype sammen i stedet for at gemme dem separat. Hver værdi af arrayet vil blive tilgået separat.

Erklære et array i C++

Array-erklæring i C++ involverer angivelse af typen samt antallet af elementer, der skal lagres af arrayet. Syntaks:

type array-Name [ array-Size ];

Regler for deklaration af et enkeltdimensionelt array i C++.

• Type: Typen er den type elementer, der skal gemmes i arrayet, og den skal være en gyldig C++ datatype.
• Array-navn: Array-navnet er det navn, der skal tildeles til arrayet.
• Array-størrelse: Array-størrelsen er antallet af elementer, der skal gemmes i arrayet. Det skal være et heltal og større end 0.

For eksempel kan du oprette et array med navnet alder og gemme alderen på 5 elever som følger:

int age[5];

Array-alderen vil gemme 5 heltal, der repræsenterer alderen på forskellige elever.

Initialisering af matrix

Array-initialisering er processen med at tildele/lagre elementer til et array. Initialiseringen kan udføres i en enkelt sætning eller en efter en. Bemærk, at det første element i et array er lagret ved indeks 0, mens det sidste element er gemt ved indeks n-1, hvor n er det samlede antal elementer i arrayet.

I tilfælde af aldersarrayet vil det første element blive gemt ved indeks 0, mens det sidste element vil blive gemt ved indeks 4.

Lad os bruge aldersarrayet til at demonstrere, hvordan arrayinitialisering kan udføres:

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

Det samlede antal elementer i { } må ikke overstige den værdi, der er angivet i [ ]. Elementet 19 er ved indeks 0, 18 ved indeks 1, 21 ved indeks 2, 20 ved indeks 3 og 17 ved indeks 4. Hvis du ikke angiver antallet af elementer, der skal lagres i arrayet inden for [ ], arrayet vil kun være stor nok til at indeholde de tilføjede elementer i { }. For eksempel:

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

Ovenstående sætning vil skabe nøjagtig det samme array som det forrige. Du kan også tildele et element til et array ved hjælp af dets indeks. For eksempel:

age[3] = 20;

Ovenstående udsagn vil gemme værdien 20 ved indeks 3 for arrayet navngivne alder. Det betyder, at 20 bliver de 4^th element i arrayet.

Typer af arrays

Der er to typer af C++ arrays:

• Et dimensionelt array
• Multidimensionelt array
• Pointer til et array

One-Dimensional Array

Dette er et array, hvor dataelementerne er arrangeret lineært i kun én dimension. Det kaldes almindeligvis et 1-D-array. Syntaks:

datatype array-name[size];

• Array-navnet er navnet på arrayet.
• Størrelsen er antallet af elementer, der skal gemmes i arrayet.

For eksempel:

#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:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kalder main()-funktionen, hvori programmets logik skal tilføjes.
4. Start af hovedteksten af ​​funktionen main().
5. Erklærer en matrix med navnet alder for at gemme 5 heltal. De 5 heltal er også blevet initialiseret.
6. Opret en heltalsvariabel x ved hjælp af en for-løkke.
7. Begyndelsen af ​​kroppen af ​​for-løkken.
8. Brug af loop-variablen x til at iterere over værdierne for array-alderen og udskrive dem på konsollen. "\n" er et linjeskifttegn og udskrives i en ny linje efter hver iteration.
9. Slutningen af ​​kroppen af til løkke.
10. Slutningen af ​​hoveddelen af ​​funktionen main().

Multidimensionelt array

Dette er et array, hvor dataelementer er arrangeret til at danne en array af arrays. Et multidimensionelt array kan have et hvilket som helst antal dimensioner, men todimensionelle og tredimensionelle arrays er almindelige. Syntaks:

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

Array-navnet er navnet på det array, der vil have n dimensioner. For eksempel:

To dimensionelle array

Et 2D-array gemmer data på en liste med 1-D-array. Det er en matrix med rækker og kolonner. For at erklære et 2D-array skal du bruge følgende syntaks:

type array-Name [ x ][ y ];

Typen skal være en gyldig C++ datatype. Se et 2D-array som en tabel, hvor x angiver antallet af rækker, mens y angiver antallet af kolonner. Det betyder, at du identificerer hvert element i et 2D-array ved hjælp af formen a[x][y], hvor x er antallet af række og y antallet af kolonner, som elementet hører til.

Her er et eksempel på, hvordan man initialiserer et 2D-array:

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

I ovenstående eksempel har vi et 2D-array, der kan ses som en 2×3 matrix. Der er 2 rækker og 3 kolonner. Element 0 kan tilgås som a[0][1], fordi det er placeret i skæringspunktet mellem række indekseret 0 og kolonne indekseret 1. Element 3 kan tilgås som a[1][2], fordi det er placeret ved skæringspunktet mellem række indekseret 1 og kolonne indekseret 2.

Bemærk, at vi blot tilføjede krøllede seler for at adskille de forskellige rækker af elementer. Initialiseringen kunne også være udført som følger:

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

Følgende C++ eksempel viser, hvordan man initialiserer og krydser et 2D-array:

#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:

Her er et skærmbillede af ovenstående kode:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kalder funktionen main() inden for hvilken kode skal tilføjes.
4. Start af hovedteksten af ​​funktionen main().
5. En kommentar. De C++ compiler vil springe dette over.
6. Erklærer et 2D-array med 3 rækker og 2 kolonner. Elementer er også blevet tilføjet til arrayet.
7. En kommentar. De C++ compiler vil springe dette over.
8. Oprettelse af en variabel i ved hjælp af a for en løkke. Denne variabel vil iterere over rækkeindeksene for arrayet.
9. Oprettelse af en variabel j ved hjælp af a for en løkke. Denne variabel vil iterere over kolonneindeksene for arrayet.
10. Start af løkkernes krop.
11. Udskriv værdierne af variable i og j på konsollen inden for firkantede parenteser på konsollen.
12. Udskriv værdien gemt ved indeks [i][j] i arrayet a.
13. Enden af ​​løkkernes krop.
14. Main()-funktionen skal returnere en heltalsværdi, hvis programmet kører fint.
15. Slutningen af ​​hoveddelen af ​​funktionen main().

Tredimensionelt array

Et 3D-array er et array af arrays. Hvert element i et 3D-array er identificeret med et sæt af 3 indekser. For at få adgang til elementerne i et 3D-array bruger vi tre til sløjfer. For eksempel:

#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:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kalder main()-funktionen, hvori programmets logik skal tilføjes.
4. Start af brødteksten af ​​main()-funktionen.
5. Erklærer et 3D-array ved navn an af størrelse 2x3x2. Værdierne af arrayet er også blevet initialiseret.
6. Adgang til elementet, der er gemt i indekset [0][1][0] i arrayet og udskriver det på konsollen.
7. Adgang til elementet, der er gemt i indekset [0][1][1] i arrayet og udskriver det på konsollen.
8. Slutningen af ​​hoveddelen af ​​funktionen main().

Pointer til et array

A pointer er en variabel, der har en adresse. Bortset fra at bruge en pointer til at gemme adressen på en variabel, kan vi bruge den til at gemme adressen på en matrixcelle. Navnet på et array peger konstant på dets første element. Overvej nedenstående erklæring:

int age[5];

Alderen er en pointer til $age[0], adressen på det første element i et array med navnet alder. Overvej følgende eksempel:

#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:

Bemærk, at den første værdi af ovenstående output kan returnere en anden værdi afhængigt af den adresse, der er tildelt det første element i arrayet i din computers hukommelse.

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kalder main()-funktionen, hvori programmets logik skal tilføjes.
4. Start af brødteksten af ​​main()-funktionen.
5. Erklærer en pointervariabel ved navn *john.
6. Erklære en heltal matrix med navnet alder for at gemme 5 heltal. Værdierne af de heltal er også blevet initialiseret.
7. Tildeling af variablen john værdien af ​​adressen på elementet, der er gemt i det første indeks af array-alderen.
8. Udskrivning af værdien af ​​variabel john, som er adressen på det element, der er gemt i det første indeks af array-alderen.
9. Udskrivning af den første værdi, der er gemt i array-alderen.
10. Slutningen af ​​hoveddelen af ​​funktionen main().

Arraynavne kan bruges som konstante pointer, og det omvendte er også sandt. Dette betyder, at du kan få adgang til værdien gemt ved indeks 3 for array-alder med *(alder + 3). For eksempel:

#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:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kaldning af main()-funktionen og start af brødteksten for main()-funktionen.
4. En kommentar. De C++ compiler vil springe dette over.
5. Erklærer en matrix med navnet alder for at gemme 5 heltal.
6. Oprettelse af en heltalsmarkør s.
7. Tildeling af p værdien af ​​adressen på det første element i arrayalderen.
8. En kommentar. De C++ compiler vil springe dette over.
9. Udskriv noget tekst på konsollen.
10. Opret et heltal x ved hjælp af a for en løkke. { markerer begyndelsen af ​​brødteksten for en sløjfe.
11. Udskriv værdierne af x kombineret med anden tekst på konsollen.
12. Udskriv værdierne af *(p + x) på konsollen.
13. Enden af ​​kroppen af ​​for en løkke.
14. Udskriv noget tekst på konsollen.
15. Opret en variabel x ved hjælp af a for en løkke. { markerer begyndelsen af ​​brødteksten i for-løkken.
16. Udskriv værdierne af x fra 0 til 4 sammen med anden tekst.
17. Udskriv værdierne af *(alder + x).
18. Enden af ​​kroppen af ​​for-løkken.
19. Returner værdi, hvis programmet kører korrekt.
20. Slutningen af ​​hoveddelen af ​​funktionen main().

Adgang til værdierne af et array

Elementerne i et array tilgås ved hjælp af deres respektive indekser. Indekset for det element, der skal tilgås, tilføjes i firkantede parenteser [ ] umiddelbart efter matrixnavnet. For eksempel:

int john = age[2];

I ovenstående eksempel angiver vi blot, at johns alder er gemt i indeks 2 i arrayet med navnet alder. Det betyder, at Johns alder er 3^rd værdi i array-alderen. Her er en komplet C++ eksempel, der viser, hvordan du får adgang til og udskriver denne værdi:

#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:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inklusive iostream header-filen i vores kode. Det giver os mulighed for at læse fra og skrive til konsollen.
2. Inkluderer std-navnerummet for at bruge dets klasser og funktioner uden at kalde det.
3. Kalder funktionen main() inden for hvilken kode skal tilføjes.
4. Start af en krop af funktionen main().
5. Erklære en matrix med navnet alder for at gemme 5 heltalselementer.
6. Adgang til værdien gemt ved indeks 2 for array-alder og lagring af dens værdi i en variabel ved navn john.
7. Udskrivning af værdien af ​​variabel john på konsollen sammen med anden tekst.

Fordele ved et array i C++

Her er fordele/fordele ved at bruge Array i C++:

• Array-elementer kan nemt krydses.
• Let at manipulere array-data.
• Array-elementer kan tilgås tilfældigt.
• Arrays letter kodeoptimering; derfor kan vi udføre meget arbejde ved at bruge mindre kode.
• Let at sortere array-data.

Ulemper ved et array i C++

• Et array har en fast størrelse; derfor kan vi ikke tilføje nye elementer til det efter initialisering.
• Tildeling af mere hukommelse end kravet fører til spild af hukommelsesplads, og mindre tildeling af hukommelse kan skabe et problem.
• Antallet af elementer, der skal lagres i et array, skal være kendt på forhånd.

Resumé

• Et array er en datastruktur, der gemmer elementer af samme datatype.
• Array-elementer gemmes sekventielt.
• Array-elementerne er angivet ved hjælp af deres respektive indekser. Det første element er ved indeks 0, mens det sidste element er ved indeks n-1, hvor er det samlede antal array-elementer.
• Deklarationen af ​​et array involverer at definere datatyperne for array-elementerne såvel som antallet af elementer, der skal lagres i arrayet.
• Et endimensionelt array gemmer elementer sekventielt.
• Et todimensionelt array gemmer elementer i rækker og kolonner.
• Et tredimensionelt array er et array af arrays.
• Elementer kan tilføjes til en matrix ved hjælp af deres indekser.
• Array-elementer tilgås ved hjælp af deres indekser.
• Et multidimensionelt array har mere end én dimension.
• Arraynavnet peger på dets første element.
• Arrays har en fast størrelse, hvilket betyder, at nye elementer ikke kan tilføjes til arrayet efter dets initialisering.