Arrayer i C ++ - Förklara - Initiera - Pointer to Array Exempel

Vad är en matris?

En array är en datastruktur som lagrar ett element av samma datatyp sekventiellt. En C ++ -matris har en fast storlek.

Du kan se en matris som en samling variabler av samma datatyp. Istället för att deklarera varje variabel och tilldela den ett värde individuellt kan du deklarera en variabel (arrayen) och lägga till värdena för de olika variablerna till den. Varje värde som läggs till i matrisen identifieras av ett index.

I denna C ++ -handledning lär du dig:

• Vad är en matris?
• Varför behöver vi matriser?
• Deklarera en array i C ++
• Initiering av matris
• Typer av matriser
• Endimensionell matris
• Flerdimensionell matris
• Tvådimensionell matris
• Tre-dimensionell matris
• Pekare till en matris
• Åtkomst till värdena i en matris
• Fördelar med en matris i C ++
• Nackdelar med en matris i C ++

Varför behöver vi matriser?

Arrayer är mycket viktiga i alla programmeringsspråk. De ger ett mer bekvämt sätt att lagra variabler eller en insamling av data av liknande datatyp tillsammans istället för att lagra dem separat. Varje värde i matrisen kommer åt separat.

Deklarera en array i C ++

Arraydeklaration i C ++ innefattar att ange typen såväl som antalet element som ska lagras av matrisen. 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 matrisen, och den måste vara en giltig C ++ - datatyp.
• Array-Name: Array-Name är namnet som ska tilldelas arrayen.
• Array-Size: 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 matris med namnet ålder och lagra åldrarna på 5 elever enligt följande:

int age[5];

Matrisåldern kommer att lagra 5 heltal som representerar åldrarna för olika elever.

Initiering av matris

Arrayinitialisering är processen att tilldela / lagra element till en matris. Initieringen kan göras i ett enda uttalande eller en efter en. Observera att det första elementet i en matris lagras vid index 0, medan det sista elementet lagras vid index n-1, där n är det totala antalet element i matrisen.

När det gäller åldersgruppen lagras det första elementet i index 0, medan det sista elementet lagras i index 4.

Låt oss använda åldersgruppen för att visa hur matrisinitiering kan göras:

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

Det totala antalet element i {} får inte överstiga det värde som anges i []. 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 [], kommer arrayen kommer bara att vara tillräckligt stor för att hålla elementen som läggs till i {}. Till exempel:

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

Ovanstående uttalande skapar exakt samma array som den föregående. Du kan också tilldela ett element till en matris 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 matrisen med namnet ålder. Detta betyder att 20 kommer att vara det ^fjärde elementet i matrisen.

Typer av matriser

Det finns två typer av C ++ - matriser:

• En dimensionell matris
• Flerdimensionell matris
• Pekare till en matris

Endimensionell matris

Detta är en matris där dataobjekten endast är ordnade linjärt i en dimension. Det kallas vanligtvis en 1-D-array. Syntax:

datatype array-name[size];

• Array-name är namnet på arrayen.
• Storleken är antalet objekt som ska lagras i matrisen.

Till exempel:

#include using namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };for (int x = 0; x < 5; x++){cout <
Produktion:



Här är en skärmdump av koden:

Kodförklaring:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringer till huvudfunktionen () inom vilken programmets logik ska läggas till.
Början av huvudfunktionen ().
Förklarar en matris med namnet ålder för att lagra 5 heltal. De fem heltalen har också initierats.
Skapa en heltalvariabel x med en for-loop.
Början på kroppen för for loop.
Med loopvariabeln x för att iterera över värdena för arrayens ålder och skriva ut dem på konsolen. "\ N" är en nylinjetecken och skrivs ut i en ny rad efter varje iteration.
Slutet på kroppen för en slinga.
Slutet på huvudfunktionens () kropp.

Flerdimensionell matris
Detta är en matris där dataelement är ordnade för att bilda en matris av matriser. En flerdimensionell matris kan ha valfritt antal dimensioner, men tvådimensionella och tredimensionella matriser är vanliga. Syntax:
datatype array-name[d1][d2][d3]… [dn];
Array-namnet är namnet på arrayen som har n-dimensioner. Till exempel:


Tvådimensionell matris
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 betecknar antalet rader medan y anger antalet kolumner. Detta innebär att du identifierar varje element i en 2D-array med hjälp av formuläret a [x] [y], där x är antalet rader och y antalet kolumner som elementet tillhör.
Här är ett exempel på hur du initierar en 2D-array:
int a[2][3] = {{0, 2, 1} , /* row at index 0 */{4, 3, 7} , /* row at index 1 */};
I exemplet ovan har vi en 2D-array som kan ses som en 2x3-matris. Det finns två rader och 3 kolumner. Elementet 0 kan nås som en [0] [1] eftersom den är belägen vid skärningspunkten mellan radindexerad 0 och kolumnindexerad 1. Elementet 3 kan nås som en [1] [2] eftersom det är beläget vid skärningspunkt mellan rad indexerad 1 och kolumn indexerad 2.
Observera att vi helt enkelt lagt till lockiga hängslen för att skilja de olika elementraderna. Initieringen kunde också ha gjorts enligt följande:
int a[2][3] = {0, 2, 1, 4, 3, 7};};
Följande C ++ - exempel visar hur man initierar och korsar en 2D-array:
#include using namespace std;int main(){// a 2x3 arrayint a[3][2] = { {0, 2}, {1, 4}, {3, 7} };// traverse array elementsfor (int i=0; i<3; i++)for (int j=0; j<2; j++){cout << "a[" <
Produktion:

Här är en skärmdump av ovanstående kod:

Kodförklaring:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringer till huvudfunktionen () inom vilken kod ska läggas till.
Början av huvudfunktionen ().
En kommentar. C ++ - kompilatorn hoppar över detta.
Förklarar en 2D-array med 3 rader och 2 kolumner. Objekt har också lagts till i matrisen.
En kommentar. C ++ - kompilatorn hoppar över detta.
Skapa en variabel i med hjälp av a för en loop. Denna variabel kommer att iterera över radindex i matrisen.
Skapa en variabel j med a för en loop. Denna variabel kommer att iterera över kolumnindex i matrisen.
Början på öglorna.
Skriv ut värdena för variablerna i och j på konsolen inom hakparenteser på konsolen.
Skriv ut värdet som lagrats i index [i] [j] i arrayen a.
Slutet på öglorna.
Huvudfunktionen () ska returnera ett heltal om programmet går bra.
Slutet på huvudfunktionens () kropp.

Tre-dimensionell matris
En 3D-array är en array med arrays. 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:
#includeusing 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:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringer till huvudfunktionen () inom vilken programmets logik ska läggas till.
Starten på huvudfunktionen ().
Förklarar en 3D-array med namnet storlek 2x3x2. Värdena för matrisen har också initierats.
Åtkomst till objektet som lagras i index [0] [1] [0] i arrayen och skriva ut det på konsolen.
Åtkomst till objektet som lagras i index [0] [1] [1] i arrayen och skriva ut det på konsolen.
Slutet på huvudfunktionens () kropp.

Pekare till en matris
En pekare är en variabel som innehåller 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 arraycell. Namnet på en matris pekar ständigt på sitt första element. Tänk på deklarationen nedan:
int age[5];
Åldern är en pekare till $ age [0], adressen till det första elementet i en matris med namnet age. Tänk på följande exempel:
#include 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 på ovanstående utdata kan returnera ett annat värde beroende på adressen tilldelad det första elementet i arrayen i datorns minne.
Här är en skärmdump av koden:

Kodförklaring:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringer till huvudfunktionen () inom vilken programmets logik ska läggas till.
Starten på huvudfunktionen ().
Förklarar en pekervariabel med namnet * john.
Att deklarera ett heltal som heter ålder för att lagra 5 heltal. Värdena för heltal har också initierats.
Tilldela variabeln john värdet på adressen för artikeln som lagras i det första indexet för arrayens ålder.
Utskrift av värdet på variabeln john, som är adressen till artikeln som lagras i det första indexet i arrayens ålder.
Utskrift av det första värdet som lagrats i arrayens ålder.
Slutet på huvudfunktionens () kropp.

Arraynamn kan användas som konstanta pekare, och vice versa är också sant. Det betyder att du kan komma åt värdet som lagras i index 3 i array-åldern med * (age + 3). Till exempel:
#include using namespace std;int main() {// an array of 5 elements.int age[5] = { 19, 18, 21, 20, 17 };int *p;p = age;// output array valuescout << "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:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringa till huvudfunktionen () och början på huvudfunktionen ().
En kommentar. C ++ - kompilatorn hoppar över detta.
Förklarar en matris med namnet ålder för att lagra 5 heltal.
Skapa en helpekare p.
Tilldela p värdet på adressen till det första elementet i array-åldern.
En kommentar. C ++ - kompilatorn hoppar över detta.
Skriv ut lite text på konsolen.
Skapa ett heltal x med a för en loop. {Markerar början på kroppen för en slinga.
Skriv ut värdena på x kombinerat med annan text på konsolen.
Skriv ut värdena på * (p + x) på konsolen.
Slutet på 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 för for-slingan.
Skriv ut värdena x från 0 till 4 tillsammans med någon annan text.
Skriv ut värdena * (ålder + x).
Slutet på for-loopens kropp.
Returvärde om programmet körs framgångsrikt.
Slutet på huvudfunktionens () kropp.


Åtkomst till värdena i en matris
Elementen i en matris nås med hjälp av deras 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 säger vi helt enkelt att johns ålder lagras i index 2 för matrisen med namnet ålder. Detta betyder att johns ålder är det tredje värdet i matrisåldern. Här är ett komplett C ++ - exempel som visar hur du får åtkomst till och skriver ut detta värde:
#includeusing namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };int john = age[2];cout << "The age of John is:"<
Produktion:

Här är en skärmdump av koden:

Kodförklaring:

Inkluderar iostream-rubrikfilen i vår kod. Det gör att vi kan läsa från och skriva till konsolen.
Inklusive std-namnområdet för att använda dess klasser och funktioner utan att anropa det.
Ringer till huvudfunktionen () inom vilken kod ska läggas till.
Start av en kropp med huvudfunktionen ().
Deklarerar en matris med namnet ålder för att lagra 5 heltalselement.
Åtkomst till värdet som lagrats vid index 2 i arrayens ålder och lagring av värdet i en variabel med namnet john.
Skriva ut värdet på variabel john på konsolen tillsammans med annan text.


Fördelar med en matris 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 arraydata.
Matriselement 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 arraydata.


Nackdelar med en matris i C ++

En matris har en fast storlek; Därför kan vi inte lägga till nya element efter initialiseringen.
Att fördela mer minne än kravet leder till slöseri med minnesutrymme och mindre allokering av minne kan skapa problem.
Antalet element som ska lagras i en matris måste vara känt i förväg.

Sammanfattning

En matris är en datastruktur som lagrar element av samma datatyp.
Matriselement lagras sekventiellt.
Arrayelementen betecknas med respektive index. Det första elementet är vid index 0, medan det sista elementet är vid index n-1, var är det totala antalet array-element.
Deklarationen av en array innefattar att definiera datatyperna för arrayelementen samt antalet element som ska lagras i arrayen.
En endimensionell matris lagrar element sekventiellt.
En tvådimensionell matris lagrar element i rader och kolumner.
En tredimensionell matris är en matris med matriser.
Element kan läggas till i en matris med hjälp av deras index.
Matriselement nås med hjälp av deras index.
En flerdimensionell matris har mer än en dimension.
Arraynamnet pekar på sitt första element.
Arrayer har en fast storlek, vilket innebär att nya element inte kan läggas till i arrayen efter initialisering.