Arrayer in C++ | Deklarera | Initiera | Pekare till Array-exempel
Vad är en Array?
En array är en datastruktur som lagrar ett element av samma datatyp sekventiellt. A C++ arrayen har en fast storlek.
Du kan se en matris som en samling variabler av liknande datatyp. Istället för att deklarera varje variabel och tilldela den ett värde individuellt, kan du deklarera en variabel (matrisen) och lägga till värdena för de olika variablerna till den. Varje mervärde som läggs till i arrayen identifieras av ett index.
Varför behöver vi arrayer?
arrayer är mycket viktiga i alla programmeringsspråk. De ger ett bekvämare sätt att lagra variabler eller en samling data av liknande datatyp tillsammans istället för att lagra dem separat. Varje värde i arrayen kommer att nås separat.
Deklarera en array i C++
Array-deklaration in C++ innebär att ange typen samt antalet element som ska lagras av arrayen. Syntax:
type array-Name [ array-Size ];
Regler för att deklarera en endimensionell array i C++.
- Typ: Typen är den typ av element som ska lagras i arrayen och den måste vara giltig C++ data typ.
- Array-namn: Array-Name är namnet som ska tilldelas till arrayen.
- Array-storlek: Array-Size är antalet element som ska lagras i arrayen. Det måste vara ett heltal och större än 0.
Du kan till exempel skapa en array med namnet ålder och lagra åldrarna för 5 elever enligt följande:
int age[5];
Arrayåldern kommer att lagra 5 heltal som representerar olika elevers åldrar.
Initiering av matris
Arrayinitiering är processen att tilldela/lagra element till en array. Initieringen kan göras i en enskild sats eller en efter en. Observera att det första elementet i en array lagras vid index 0, medan det sista elementet lagras i index n-1, där n är det totala antalet element i arrayen.
När det gäller åldersmatrisen kommer det första elementet att lagras vid index 0, medan det sista elementet kommer att lagras i index 4.
Låt oss använda åldersmatrisen för att demonstrera hur matrisinitiering kan göras:
int age[5] = {19, 18, 21, 20, 17};
Det totala antalet element inom { } får inte överstiga värdet som anges inom [ ]. Elementet 19 är vid index 0, 18 vid index 1, 21 vid index 2, 20 vid index 3 och 17 vid index 4. Om du inte anger antalet element som ska lagras i arrayen inom [ ], arrayen kommer bara att vara tillräckligt stor för att hålla de element som läggs till inom { }. Till exempel:
int age[] = {19, 18, 21, 20, 17};
Ovanstående sats kommer att skapa exakt samma array som den föregående. Du kan också tilldela ett element till en array med hjälp av dess index. Till exempel:
age[3] = 20;
Ovanstående uttalande kommer att lagra värdet 20 vid index 3 för den array med namnet ålder. Det betyder att 20 blir 4:anth element i arrayen.
Typer av arrayer
Det finns två typer av C++ arrayer:
- Endimensionell Array
- Flerdimensionell array
- Pekare till en array
Endimensionell array
Detta är en array där dataposterna är ordnade linjärt i endast en dimension. Det kallas vanligtvis en 1-D-array. Syntax:
datatype array-name[size];
- Array-namnet är namnet på arrayen.
- Storleken är antalet objekt som ska lagras i arrayen.
Till exempel:
#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"; } }
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropar funktionen main() där programmets logik ska läggas till.
- Början av huvuddelen av funktionen main().
- Deklarera en array med namnet ålder för att lagra 5 heltal. De 5 heltalen har också initierats.
- Skapa en heltalsvariabel x med en for-loop.
- Början av kroppen av for-slingan.
- Använd loopvariabeln x för att iterera över värdena för arrayåldern och skriva ut dem på konsolen. "\n" är ett nyradstecken och skrivs ut på en ny rad efter varje iteration.
- Slutet av kroppen av för slinga.
- Slutet på huvuddelen av funktionen main().
Flerdimensionell array
Detta är en array i vilken dataobjekt är arrangerade för att bilda en array av arrayer. En flerdimensionell array kan ha hur många dimensioner som helst, men tvådimensionella och tredimensionella arrayer är vanliga. Syntax:
datatype array-name[d1][d2][d3]...[dn];
Arraynamnet är namnet på arrayen som kommer att ha n dimensioner. Till exempel:
Tvådimensionell array
En 2D-array lagrar data i en lista med 1-D-array. Det är en matris med rader och kolumner. För att deklarera en 2D-array, använd följande syntax:
type array-Name [ x ][ y ];
Typen måste vara en giltig C++ datatyp. Se en 2D-array som en tabell, där x anger antalet rader medan y anger antalet kolumner. Det betyder att du identifierar varje element i en 2D-array med formen a[x][y], där x är antalet rader och y antalet kolumner som elementet tillhör.
Här är ett exempel på hur man initierar en 2D-array:
int a[2][3] = { {0, 2, 1} , /* row at index 0 */ {4, 3, 7} , /* row at index 1 */ };
I ovanstående exempel har vi en 2D-array som kan ses som en 2×3-matris. Det finns 2 rader och 3 kolumner. Elementet 0 kan nås som a[0][1] eftersom det är beläget i skärningspunkten mellan rad indexerad 0 och kolumn indexerad 1. Element 3 kan nås som a[1][2] eftersom det är placerat vid skärningspunkten mellan rad indexerad 1 och kolumn indexerad 2.
Observera att vi helt enkelt lagt till lockiga hängslen för att skilja de olika raderna av element åt. Initieringen kunde också ha gjorts på följande sätt:
int a[2][3] = {0, 2, 1, 4, 3, 7}; };
Följande C++ exemplet visar hur man initierar och korsar en 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; }
Produktion:
Här är en skärmdump av ovanstående kod:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropar funktionen main() inom vilken kod ska läggas till.
- Början av huvuddelen av funktionen main().
- En kommentar. De C++ kompilatorn hoppar över detta.
- Deklarera en 2D-array med 3 rader och 2 kolumner. Objekt har också lagts till i arrayen.
- En kommentar. De C++ kompilatorn hoppar över detta.
- Skapa en variabel i med a för en loop. Denna variabel kommer att iterera över radindexen för arrayen.
- Skapa en variabel j med a för en loop. Denna variabel kommer att iterera över arrayens kolumnindex.
- Början av slingornas kropp.
- Skriv ut värdena för variablerna i och j på konsolen inom hakparenteser på konsolen.
- Skriv ut värdet som är lagrat i index [i][j] för arrayen a.
- Änden av slingornas kropp.
- Funktionen main() bör returnera ett heltalsvärde om programmet fungerar bra.
- Slutet på huvuddelen av funktionen main().
Tredimensionell array
En 3D-array är en array av arrayer. Varje element i en 3D-array identifieras av en uppsättning av 3 index. För att komma åt elementen i en 3D-array använder vi tre för loopar. Till exempel:
#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"; }
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropar funktionen main() där programmets logik ska läggas till.
- Början av huvuddelen av main()-funktionen.
- Deklarerar en 3D-array som heter en med storleken 2x3x2. Värdena för arrayen har också initierats.
- Åtkomst till objektet lagrat i index [0][1][0] i arrayen och skriver ut det på konsolen.
- Åtkomst till objektet lagrat i index [0][1][1] i arrayen och skriver ut det på konsolen.
- Slutet på huvuddelen av funktionen main().
Pekare till en array
A pekare är en variabel som har en adress. Förutom att använda en pekare för att lagra adressen till en variabel, kan vi använda den för att lagra adressen till en matriscell. Namnet på en array pekar ständigt på dess första element. Betrakta förklaringen nedan:
int age[5];
Åldern är en pekare till $age[0], adressen till det första elementet i en array med namnet ålder. Tänk på följande exempel:
#include <iostream> using namespace std; int main() { int *john; int age[5] = { 19, 18, 21, 20, 17 }; john = age; cout << john << "\n"; cout << *john; }
Produktion:
Observera att det första värdet av ovanstående utdata kan returnera ett annat värde beroende på adressen som tilldelats det första elementet i arrayen i din dators minne.
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropar funktionen main() där programmets logik ska läggas till.
- Början av huvuddelen av main()-funktionen.
- Deklarera en pekvariabel som heter *john.
- Deklarera en heltalsmatris med namnet ålder för att lagra 5 heltal. Heltalens värden har också initierats.
- Tilldela variabeln john värdet på adressen till objektet som lagrats i det första indexet av arrayåldern.
- Skriver ut värdet för variabel john, som är adressen till objektet som lagras i det första indexet av arrayåldern.
- Skriver ut det första värdet som lagrats i arrayåldern.
- Slutet på huvuddelen av funktionen main().
Arraynamn kan användas som konstanta pekare, och vice versa är också sant. Detta betyder att du kan komma åt värdet lagrat i index 3 för arrayåldern med *(ålder + 3). Till exempel:
#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; }
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropa main()-funktionen och början av huvuddelen av main()-funktionen.
- En kommentar. De C++ kompilatorn hoppar över detta.
- Deklarera en array med namnet ålder för att lagra 5 heltal.
- Skapa en heltalspekare sid.
- Tilldela p värdet på adressen för det första elementet i arrayåldern.
- En kommentar. De C++ kompilatorn hoppar över detta.
- Skriv ut lite text på konsolen.
- Skapa ett heltal x med a för en slinga. Den { markerar början av kroppen för en slinga.
- Skriv ut värdena för x i kombination med annan text på konsolen.
- Skriv ut värdena för *(p + x) på konsolen.
- Änden av kroppen för en slinga.
- Skriv ut lite text på konsolen.
- Skapa en variabel x med a för en loop. { markerar början på kroppen av for-slingan.
- Skriv ut värdena för x från 0 till 4 tillsammans med annan text.
- Skriv ut värdena för *(ålder + x).
- Slutet på kroppen av for-slingan.
- Returnera värde om programmet körs framgångsrikt.
- Slutet på huvuddelen av funktionen main().
Få åtkomst till värdena för en array
Elementen i en array nås med sina respektive index. Indexet för elementet som ska nås läggs till inom hakparenteser [ ] omedelbart efter arraynamnet. Till exempel:
int john = age[2];
I exemplet ovan anger vi helt enkelt att Johns ålder är lagrad i index 2 av den array som heter ålder. Det betyder att Johns ålder är 3rd värde i arrayåldern. Här är en komplett C++ exempel som visar hur du kommer åt och skriver ut detta värde:
#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; }
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
- Inkluderar std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
- Anropar funktionen main() inom vilken kod ska läggas till.
- Start av en kropp av funktionen main().
- Deklarera en array med namnet ålder för att lagra 5 heltalselement.
- Åtkomst till värdet lagrat i index 2 av arrayåldern och lagrar dess värde i en variabel som heter john.
- Skriver ut värdet för variabel john på konsolen tillsammans med annan text.
Fördelar med en Array i C++
Här är fördelar/fördelar med att använda Array i C++:
- Arrayelement kan lätt passeras.
- Lätt att manipulera matrisdata.
- Arrayelement kan nås slumpmässigt.
- Arrayer underlättar kodoptimering; därför kan vi utföra mycket arbete med mindre kod.
- Lätt att sortera matrisdata.
Nackdelar med en Array i C++
- En array har en fast storlek; därför kan vi inte lägga till nya element till den efter initialisering.
- Att allokera mer minne än vad som krävs leder till slöseri med minnesutrymme, och mindre allokering av minne kan skapa problem.
- Antalet element som ska lagras i en array måste vara känt i förväg.
Sammanfattning
- En array är en datastruktur som lagrar element av samma datatyp.
- Arrayelement lagras sekventiellt.
- Arrayelementen betecknas med deras respektive index. Det första elementet är vid index 0, medan det sista elementet är vid index n-1, där är det totala antalet arrayelement.
- Deklarationen av en array involverar att definiera datatyperna för arrayelementen såväl som antalet element som ska lagras i arrayen.
- En endimensionell array lagrar element sekventiellt.
- En tvådimensionell array lagrar element i rader och kolumner.
- En tredimensionell array är en array av arrayer.
- Element kan läggas till i en array med hjälp av deras index.
- Matriselement nås med hjälp av deras index.
- En flerdimensionell array har mer än en dimension.
- Arraynamnet pekar på dess första element.
- Arrayer har en fast storlek, vilket innebär att nya element inte kan läggas till i arrayen efter dess initialisering.