I C++ er en matrise en datastruktur som brukes til å lagre flere verdier av lignende datatyper i en sammenhengende minneplassering.

For eksempel , hvis vi må lagre karakterene til 4 eller 5 elever, kan vi enkelt lagre dem ved å lage 5 forskjellige variabler, men hva om vi vil lagre karakterene til 100 elever eller si 500 elever, så blir det veldig utfordrende å lage det antallet variabler og administrere dem. Nå kommer matriser inn i bildet som kan gjøre det enkelt ved å bare lage en matrise med ønsket størrelse.

Egenskaper til matriser i C++

• En Array er en samling av data av samme datatype, lagret på en sammenhengende minneplassering.
• Indeksering av en matrise starter fra 0. Det betyr at det første elementet er lagret på 0. indeks, det andre ved 1., og så videre.
• Elementer i en matrise kan nås ved å bruke deres indekser.
• Når en matrise er deklarert, forblir størrelsen konstant gjennom hele programmet.
• En matrise kan ha flere dimensjoner.
• Størrelsen på matrisen i byte kan bestemmes av størrelsen på operatoren som vi også kan finne antall elementer i matrisen.
• Vi kan finne størrelsen på typen elementer som er lagret i en matrise ved å trekke fra tilstøtende adresser.

Array-erklæring i C++

I C++ kan vi deklarere en matrise ved ganske enkelt å spesifisere datatypen først og deretter navnet på en matrise med dens størrelse.

data_type array_name[Size_of_array];>

Eksempel

int arr[5];>

Her,

• int: Det er typen data som skal lagres i arrayet. Vi kan også bruke andre datatyper som char, float og double.
• arr: Det er navnet på arrayen.
• 5: Det er størrelsen på matrisen som betyr at bare 5 elementer kan lagres i matrisen.

Initialisering av Array i C++

I C++ kan vi initialisere en matrise på mange måter, men vi vil diskutere noen vanligste måter å initialisere en matrise på. Vi kan initialisere en matrise på tidspunktet for erklæringen eller etter erklæringen.

1. Initialiser Array med verdier i C++

Vi har initialisert matrisen med verdier. Verdiene omsluttet av krøllete klammeparenteser «{}» er tilordnet matrisen. Her er 1 lagret i arr[0], 2 i arr[1] og så videre. Her er størrelsen på matrisen 5.

int arr[5] = {1, 2, 3, 4, 5};>

2. Initialiser Array med verdier og uten størrelse i C++

Vi har initialisert matrisen med verdier, men vi har ikke deklarert lengden på matrisen, derfor er lengden på en matrise lik antall elementer i krøllete klammer.

fjerner siste commit git

int arr[] = {1, 2, 3, 4, 5};>

3. Initialiser array etter erklæring (ved hjelp av løkker)

Vi har initialisert matrisen ved å bruke en løkke etter å ha deklarert matrisen. Denne metoden brukes vanligvis når vi ønsker å ta innspill fra brukeren, eller vi ikke kan tilordne elementer en etter en til hver indeks i matrisen. Vi kan endre sløyfebetingelsene eller endre initialiseringsverdiene i henhold til kravene.

for (int i = 0; i   arr[i] = value; }>

4. Initialiser en matrise delvis i C++

Her har vi erklært en matrise 'partialArray' med størrelse '5' og kun med verdiene '1' og '2'. Så disse verdiene lagres ved de to første indeksene, og ved resten av indeksene lagres '0'.

int partialArray[5] = {1, 2};>

5. Initialiser matrisen med null i C++

Vi kan initialisere matrisen med alle elementer som '0' ved å spesifisere '0' inne i de krøllete klammeparentesene. Dette vil skje i tilfelle null bare hvis vi prøver å initialisere matrisen med en annen verdi, si '2' ved å bruke denne metoden, så lagres '2' kun ved den 0. indeksen.

int zero_array[5] = {0};>

Tilgang til et element i en matrise i C++

Elementer i en matrise kan nås ved å spesifisere navnet på matrisen, og deretter indeksen til elementet som er omsluttet av matrise-subscript-operatoren []. For eksempel, arr[i].

Eksempel 1: C++-programmet for å illustrere hvordan du får tilgang til matriseelementer

// C++ Program to Illustrate How to Access Array Elements #include  using namespace std; int main() {  int arr[3];  // Inserting elements in an array  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  // Accessing and printing elements of the array  cout << 'arr[0]: ' << arr[0] << endl;  cout << 'arr[1]: ' << arr[1] << endl;  cout << 'arr[2]: ' << arr[2] << endl;  return 0; }>

arr[0]: 10 arr[1]: 20 arr[2]: 30>

Oppdater Array Element

For å oppdatere et element i en matrise, kan vi bruke indeksen som vi ønsker å oppdatere inne i matrise-subscript-operatoren og tilordne den nye verdien.

arr[i] = new_value;>

Gå gjennom en matrise i C++

Vi kan traversere over matrisen ved hjelp av en løkke ved å bruke indeksering i C++. Først har vi initialisert en matrise 'table_of_two' med et multiplum av 2. Etter det kjører vi en for-løkke fra 0 til 9 fordi i en matrise starter indeksering fra null. Derfor, ved å bruke indeksene, skriver vi ut alle verdier som er lagret i en matrise.

Eksempel 2: C++-programmet for å illustrere hvordan man krysser en matrise

// C++ Program to Illustrate How to Traverse an Array #include  using namespace std; int main() {  // Initialize the array  int table_of_two[10]  = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };  // Traverse the array using for loop  for (int i = 0; i < 10; i++) {  // Print the array elements using indexing  cout << table_of_two[i] << ' ';  }  return 0; }>

2 4 6 8 10 12 14 16 18 20>

Størrelsen på en matrise i C++

I C++ har vi ikke lengdefunksjonen som i Java for å finne matrisestørrelse men vi kan beregne størrelsen på en matrise ved å bruke sizeof()-operatoren triks. Først finner vi størrelsen som er okkupert av hele matrisen i minnet og deler den deretter med størrelsen på typen element som er lagret i matrisen. Dette vil gi oss antall elementer som er lagret i matrisen.

data_type size = sizeof(Array_name) / sizeof(Array_name[index]);>

Eksempel 3: C++-programmet for å illustrere hvordan du finner størrelsen på en matrise

// C++ Program to Illustrate How to Find the Size of an // Array #include  using namespace std; int main() {  int arr[] = { 1, 2, 3, 4, 5 };  // Size of one element of an array  cout << 'Size of arr[0]: ' << sizeof(arr[0]) << endl;  // Size of array 'arr'  cout << 'Size of arr: ' << sizeof(arr) << endl;  // Length of an array  int n = sizeof(arr) / sizeof(arr[0]);  cout << 'Length of an array: ' << n << endl;  return 0; }>

Size of arr[0]: 4 Size of arr: 20 Length of an array: 5>

Forholdet mellom matriser og pekere i C++

I C++ er matriser og pekere nært beslektet med hverandre. Matrisenavnet behandles som en peker som lagret minneadressen til det første elementet i matrisen. Som vi har diskutert tidligere, lagres In array-elementer på sammenhengende minneplasseringer, det er grunnen til at vi kan få tilgang til alle elementene i en array ved å bruke array-navnet.

Eksempel 4: Illustrerer forholdet mellom Array og Pointers

// C++ Program to Illustrate that Array Name is a Pointer // that Points to First Element of the Array #include  using namespace std; int main() {  // Defining an array  int arr[] = { 1, 2, 3, 4 };  // Define a pointer  int* ptr = arr;  // Printing address of the arrary using array name  cout << 'Memory address of arr: ' << &arr << endl;  // Printing address of the array using ptr  cout << 'Memory address of arr: ' << ptr << endl;  return 0; }>

Memory address of arr: 0x7fff2f2cabb0 Memory address of arr: 0x7fff2f2cabb0>

Forklaring:

I koden ovenfor definerer vi først en matrise arr og erklær deretter en peker ptr og tilordne array arr til den. Vi er i stand til å tilordne arr til ptr fordi arr også er en peker. Etter det skriver vi ut minneadressen til arr bruker referanseoperatør ( & ) og skriv også ut adressen som er lagret i pekeren ptr og vi kan se arr og ptr, begge lagrer samme minneadresse.

Eksempel 5: Skrive ut matriseelementer uten indeksering i C++

Vi har vanligvis tilgang til og skriver ut array-elementene ved hjelp av indeksering. For eksempel for å få tilgang til det første elementet vi bruker array_name[0]. Vi har diskutert ovenfor at array-navnet er en peker som lagret adressen til det første elementet og array-elementer er lagret på sammenhengende steder. Nå skal vi få tilgang til elementene i en matrise kun ved å bruke matrisenavnet.

// C++ Program to Print Array Elements without Indexing #include  using namespace std; int main() {  // Define an array  int arr[] = { 11, 22, 33, 44 };  // Print elements of an array  cout << 'first element: ' << *arr << endl;  cout << 'Second element: ' << *(arr + 1) << endl;  cout << 'Third element: ' << *(arr + 2) << endl;  cout << 'fourth element: ' << *(arr + 3) << endl;  return 0; }>

first element: 11 Second element: 22 Third element: 33 fourth element: 44>

Forklaring

I koden ovenfor erklærte vi først en matrise arr med fire elementer. Etter det skriver vi ut array-elementene. La oss diskutere hvordan vi gjør det. Vi diskuterte at matrisenavnet er en peker som lagrer adressen til det første elementet i en matrise, så for å skrive ut det første elementet har vi dereferert til den pekeren (*arr) ved hjelp av derereferanseoperator (*) som skriver ut dataene som er lagret på den adressen.

For å skrive ut det andre elementet i en matrise legger vi først til 1 til arr som tilsvarer (adressen til arr + size_of_one_element *1) som tar pekeren til adressen like etter den første, og etter det refererer vi pekeren til å skrive ut det andre elementet. På samme måte skriver vi ut resten av elementene i en matrise uten å bruke indeksering.

Sender Array til funksjon i C++

For å bruke arrays effektivt bør vi vite hvordan vi sender arrays for å fungere. Vi kan sende arrays til funksjoner som et argument på samme måte som vi sender variabler til funksjoner, men vi vet at arraynavnet behandles som en peker ved å bruke dette konseptet, vi kan sende arrayen til funksjoner som et argument og deretter få tilgang til alle elementene i den arrayen pekeren.

Så til slutt, matriser sendes alltid som pekere til funksjonen. La oss se 3 måter å overføre en matrise til en funksjon som er mest brukt.

1. Passerer Array som en peker

I denne metoden sender vi ganske enkelt arraynavnet i funksjonskall som betyr at vi sender adressen til det første elementet i arrayet. I denne metoden kan vi modifisere array-elementene i funksjonen.

Syntaks

return_type   function_name   (   data_type *array_name   ) {     // set of statements  }>

2. Sende Array som en Unsized Array

I denne metoden aksepterer funksjonen matrisen ved å bruke en enkel matriseerklæring uten størrelse som argument.

Syntaks

return_type   function_name    ( data_type array_name[]   ) {    // set of statements  }>

3. Sende Array som en Sized Array

I denne metoden aksepterer funksjonen matrisen ved å bruke en enkel matriseerklæring med størrelse som argument. Vi bruker denne metoden ved å dimensjonere en matrise bare for å indikere størrelsen på en matrise.

Syntaks

return_type function_name(data_type array_name[size_of_array]){  // set of statements }>

Merk: Array vil bli behandlet som en peker i den beståtte funksjonen uansett hvilken metode vi bruker. Når matrisen sendes som pekere, vil de miste informasjonen om størrelsen som fører til et fenomen kalt som Array Decay.

Eksempel: Illustrere ulike måter å sende arrays til en funksjon

#include  using namespace std; // passing array as a sized array argument void printArraySized(int arr[3], int n) {  cout << 'Array as Sized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << arr[i] << ' ';  }  cout << endl; } // passing array as an unsized array argument void printArrayUnsized(int arr[], int n) {  cout << 'Array as Unsized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << *(arr + i) << ' ';  }  cout << endl; } // Passing array as a pointer argument void printArrayPointer(int* ptr, int n) {  // Print array elements using pointer ptr  // that store the address of array passed  cout << 'Array as Pointer Argument: ';  for (int i = 0; i < n; i++) {  cout << ptr[i] << ' ';  } } // driver code int main() {  int arr[] = { 10, 20, 30 };  // Call function printArray and pass  // array and its size to it.  printArraySized(arr, 3);  printArrayUnsized(arr, 3);  printArrayPointer(arr, 3);  return 0; }>

Array as Sized Array Argument: 10 20 30 Array as Unsized Array Argument: 10 20 30 Array as Pointer Argument: 10 20 30>

Flerdimensjonale matriser i C++

Matriser som er deklarert med mer enn én dimensjon kalles flerdimensjonale matriser. De mest brukte flerdimensjonale matrisene er 2D-matriser og 3D-matriser. Disse matrisene er vanligvis representert i form av rader og kolonner.

Flerdimensjonal array-erklæring

Data_Type Array_Name[Size1][Size2]...[SizeN];>

hvor,

• Data-type: Type data som skal lagres i matrisen.
• Array_Name: Navn på matrisen.
• Størrelse1, Størrelse2,..., StørrelseN: Størrelse på hver dimensjon.

Todimensjonal array i C++

I C++ er en todimensjonal matrise en gruppering av elementer ordnet i rader og kolonner. Hvert element er tilgjengelig ved hjelp av to indekser: en for raden og en for kolonnen, noe som gjør det enkelt å visualisere som en tabell eller rutenett.

Syntaks for 2D-array

data_Type array_name[n][m];>

Hvor,

• n: Antall rader.
• m: Antall kolonner.
  

Eksempel: C++-programmet for å illustrere den todimensjonale matrisen

// c++ program to illustrate the two dimensional array #include  using namespace std; int main() {  // Declaring 2D array  int arr[4][4];  // Initialize 2D array using loop  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  arr[i][j] = i + j;  }  }  // Printing the element of 2D array  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  cout << arr[i][j] << ' ';  }  cout << endl;  }  return 0; }>

0 1 2 3 1 2 3 4 2 3 4 5 3 4 5 6>

Forklaring

I koden ovenfor har vi erklært en 2D-matrise med 4 rader og 4 kolonner etter at vi initialiserte matrisen med verdien av (i+j) i hver iterasjon av løkken. Deretter skriver vi ut 2D-matrisen ved hjelp av en nestet sløyfe, og vi kan se i utgangen nedenfor at det er 4 rader og 4 kolonner.

Tredimensjonal array i C++

3D-matrisen bruker tre dimensjoner. En samling av forskjellige todimensjonale arrayer stablet oppå hverandre kan brukes til å representere den. Tre indekser – radindeksen, kolonneindeksen og dybdeindeksen brukes til å identifisere hvert element i en 3D-array unikt.

Erklæring om tredimensjonal array i C++

For å erklære en 3D-matrise i C++, må vi spesifisere dens tredje dimensjon sammen med 2D-dimensjoner.

Data_Type Array_Name[D][R][C];>

Hvor,

• Data-type: Type data som skal lagres i hvert element.
• Array_Name: Navn på matrisen
• D: Antall 2D-arrayer eller dybde på array.
• R: Antall rader i hver 2D-array.
• C: Antall kolonner i hver 2D-array.

Eksempel

int array[3][3][3];>

Eksempel: C++-programmet for å illustrere 3d-arrayet

// C++ program to illustrate the 3d array #include  using namespace std; int main() {  // declaring 3d array  int arr[3][3][3];  // initializing the array  for (int i = 0; i < 3; i++) {  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  arr[i][j][k] = i + j + k;  }  }  }  // printing the array  for (int i = 0; i < 3; i++) {  cout << i << 'st layer:' << endl;  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  cout << arr[i][j][k] << ' ';  }  cout << endl;  }  cout << endl;  }  return 0; }>

0st layer: 0 1 2 1 2 3 2 3 4 1st layer: 1 2 3 2 3 4 3 4 5 2st layer: 2 3 4 3 4 5 4 5 6>

Forklaring

I koden ovenfor har vi erklært en 3D-array og deretter initialisert den ved å bruke tre nestede for-løkker. Etter det skrev vi ut alle lagene i 3D-arrayet igjen ved å bruke tre nestede for løkker som vist i utdataene.

relaterte artikler

• Flerdimensjonale matriser i C++
• Egenskaper til Array
• Array Decay