Een array is een type datastructuur dat wordt gebruikt om de verzameling items van hetzelfde datatype op te slaan die op aangrenzende geheugenlocaties worden bewaard. Arrays kunnen eendimensionaal of multidimensionaal zijn, afhankelijk van het aantal richtingen waarin de array kan groeien. In dit artikel zullen we multidimensionale arrays bestuderen, zoals tweedimensionale arrays en driedimensionale arrays.

Wat is multidimensionale array in C++?

Een multidimensionale array is een array met meer dan één dimensie. Het is de homogene verzameling items waarbij elk element toegankelijk is via meerdere indices.

Multidimensionale array-verklaring

  datatype     arrayName    [    size1][size2]...[sizeN];>

waar,

• data type: Type gegevens dat in de array moet worden opgeslagen.
• arraynaam: Naam van de array.
• maat1, maat2,…, maatN: Grootte van elke dimensie.

Voorbeeld:

Two dimensional array: int two_d[2][4]; Three dimensional array: int three_d[2][4][8];>

Grootte van een multidimensionale array

De grootte van een array is gelijk aan de grootte van het gegevenstype vermenigvuldigd met het totale aantal elementen dat in een array kan worden opgeslagen. We kunnen het totale aantal elementen in een array berekenen door de grootte van elke dimensie van een multidimensionale array te vermenigvuldigen.

Bijvoorbeeld:

int arr1[2][4];>

• De array int arr1[2][4] totaal kan opslaan (2*4) = 8 elementen.
• In C++ kost het int-gegevenstype 4 bytes en hebben we 8 elementen in de array ‘arr1’ van het int-type.
• Totale maat = 4*8 = 32 bytes .

int arr2[2][4][8];>

• Array int arr2[2][4][8] kan totaal (2*4*8) = 64 elementen opslaan.
• De totale omvang van ‘ arr2 ' = 64*4 = 256 bytes .

Om de bovenstaande berekening te verifiëren, kunnen we gebruiken De grootte van() methode om de grootte van een array te bepalen.

C++

>

>

Size of array arr1: 32 bytes Size of array arr2: 256 bytes>

De meest gebruikte multidimensionale arrays zijn:

• Tweedimensionale array
• Driedimensionale array

Tweedimensionale array (of 2D-array)

Een tweedimensionale array in C++ is een verzameling elementen georganiseerd in rijen en kolommen. Het kan worden gevisualiseerd als een tabel of een raster, waarbij elk element toegankelijk is met behulp van twee indices: één voor de rij en één voor de kolom. Net als een eendimensionale array variëren tweedimensionale array-indexen ook van 0 tot n-1 voor zowel rijen als kolommen.

Syntaxis van 2D-array

data_Type array_naam[ N ][ M ];

Waar,

• N: Aantal rijen.
• M: Aantal columns.

We kunnen een 2D-array statisch en dynamisch declareren. Bij statische declaratie wordt geheugen toegewezen tijdens het compileren, en bij dynamisch geheugen wordt dit toegewezen tijdens runtime. Het bovenstaande is de syntaxis voor de statische declaratie van een 2D-array. Als u wilt weten hoe u de 2D-array dynamisch declareert, raadpleegt u dit artikel.

Initialisatie van tweedimensionale arrays in C++

Hieronder worden verschillende manieren gegeven om een ​​2D-array te initialiseren:

• Initialisatielijst gebruiken
• Het gebruik van lussen

1. Initialiseer de 2D-array met behulp van de Initializer-lijst

We kunnen een 2D-array op twee manieren initialiseren met behulp van een initialisatielijst. Hieronder ziet u de eerste methode voor het initialiseren van een 2D-array met behulp van een initialisatielijst.

Eerste methode: De onderstaande array heeft 2 rijen en 4 kolommen. De elementen zijn zo gevuld dat de eerste 4 elementen in de eerste rij worden gevuld en de volgende 4 elementen in de tweede rij.

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

Tweede methode: De onderstaande manier is de schonere manier om een ​​2D-array te initialiseren. De geneste lijst vertegenwoordigt de elementen in een rij en het aantal elementen daarin is gelijk aan het aantal kolommen in een 2D-array. Het aantal geneste lijsten vertegenwoordigt het aantal kolommen.

int x[2][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}};>

2. Initialisatie van 2D-array met behulp van Loops

We kunnen ook een 2D-array initialiseren met behulp van lussen. Om de 2D-array te initialiseren moeten we twee geneste lussen gebruiken en de geneste lussen zijn gelijk aan de dimensie. Om bijvoorbeeld een 3D-array te initialiseren, moeten we drie geneste lussen gebruiken. Laten we een voorbeeld bekijken.

Voorbeeld: In het onderstaande voorbeeld hebben we de 2D-array geïnitialiseerd met 1. De buitenste lus wordt gebruikt om rijen bij te houden. i=0 betekent de eerste rij vanwege indexering 0, op dezelfde manier betekent j=0 de eerste kolom en het combineren hiervan x [0][0] vertegenwoordigt de eerste cel van de 2D-array.

int x[2][4]; for(int i = 0; i <2; i++){  for(int j = 0; j <4; j++){  x[i][j] = 1;  } }>

Toegang tot elementen van tweedimensionale arrays in C++

We hebben toegang tot de elementen van een tweedimensionale array met behulp van rij- en kolomindexen. Het is vergelijkbaar met de positie van matrixelementen, maar het enige verschil is dat de indexering hier begint vanaf 0.

Syntaxis:

speciale tekens naam

array_name[i][j];>

waar,

• i: Index van rij.
• J: Index van de kolom.

Voorbeeld: Hieronder vindt u de index van elementen van de tweede rij en derde kolom.

int x[1][2];>

Laten we dit begrijpen met behulp van code door elementen van een 2D-array af te drukken.

Voorbeeld van 2D-array

C++

>

>

1 2 3 4 5 6 7 8 9 10 11 12>

Uitleg: In de bovenstaande code hebben we de telling geïnitialiseerd met ‘1’ en een 2D-array met 3 rijen en 4 kolommen gedeclareerd. Daarna hebben we de array geïnitialiseerd met de waarde van het aantal en de oplopende waarde van het aantal in elke iteratie van de lus. Vervolgens drukken we de 2D-array af met behulp van een geneste lus en kunnen we in de onderstaande uitvoer zien dat er 3 rijen en 4 kolommen zijn.

Tijdcomplexiteit: O(n*m)
Ruimtecomplexiteit: O(n*m)

waarbij n het aantal rijen is en m het aantal kolommen.

Driedimensionale array in C++

De 3D-array is een datastructuur die elementen opslaat in een driedimensionale kubusvormige structuur. Het kan worden gevisualiseerd als een verzameling van meerdere tweedimensionale arrays die op elkaar zijn gestapeld. Elk element in een 3D-array wordt geïdentificeerd door de drie indices: de rij-index, kolom-index en diepte-index.

Verklaring van driedimensionale array in C++

Om een ​​3D-array in C++ te declareren, moeten we de derde dimensie ervan specificeren, samen met de 2D-dimensies.

Syntaxis:

dataType arrayName[d][r];>

• data type: Type gegevens dat in elk element moet worden opgeslagen.
• arraynaam: Naam van de array
• D: Aantal 2D-arrays of diepte van de array.
• R: Aantal rijen in elke 2D-array.
• C: Aantal kolommen in elke 2D-array.

Voorbeeld:

int array[3][5][2];>

Initialisatie van driedimensionale array in C++

Om de 3D-array in C++ te initialiseren, volgen we dezelfde methoden die we hebben gebruikt om de 2D-array te initialiseren. In de 3D-array hebben we nog een dimensie, dus we moeten nog een geneste lijst met elementen toevoegen.

Een 3D-array in C kan worden geïnitialiseerd met behulp van:

1. Initialisatielijst
2. Lussen

Initialisatie van 3D-array met behulp van Initializer List

Methode 1: Bij deze methode moeten we het totale aantal elementen tussen accolades schrijven, en elk item wordt op zijn positie geplaatst volgens de gegeven dimensie.

int x[3][5][2] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,   10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  20, 21, 22, 23, 24, 25, 26, 27, 28, 30};>

Methode 2 (Beter) : Bij deze methode hebben we de elementen gepartitioneerd met behulp van geneste lijsten en is deze gemakkelijk te lezen.

int x[3][5][2] =   {      {   {0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}   }  ,     {   {10, 11}, {12, 13}, {14, 15}, {16, 17}, {18, 19}   }  ,    {   {20, 21}, {22, 23}, {24, 25}, {26, 27}, {28, 30}   }  ,    }  ;>

Initialisatie van 3D-array met behulp van loops

Deze methode is hetzelfde als het initialiseren van een 2D-array met behulp van lussen met nog een geneste lus voor de derde dimensie.

int x[3][5][2]; for (int i = 0; i <3; i++) {  for (int j = 0; j <5; j++) {  for (int k = 0; k <2; k++) {  x[i][j][k] =   (some_value)  ;  }  } }>

Toegang tot elementen in Three-Dimensional Array in C++

Toegang krijgen tot elementen in 3D-arrays is net zo eenvoudig als toegang krijgen tot elementen in 2D-arrays. Wat we hier extra moeten doen, is het toevoegen van nog een geneste lus om de derde dimensie bij te houden.

C++

>

>

css vetgedrukt

x[0][0][0] = 0 x[0][0][1] = 1 x[0][0][2] = 2 x[0][1][0] = 3 x[0][1][1] = 4 x[0][1][2] = 5 x[1][0][0] = 6 x[1][0][1] = 7 x[1][0][2] = 8 x[1][1][0] = 9 x[1][1][1] = 10 x[1][1][2] = 11>

Uitleg: In de bovenstaande code hebben we de 3D-array geïnitialiseerd met behulp van de lus zoals hierboven uitgelegd met het nummer van 0 tot 7 met behulp van de count-variabele en vervolgens toegang gekregen tot de elementen met behulp van dezelfde lus die werd gebruikt voor het initialiseren van de 3D-array. Het enige verschil is dat in plaats van een element op een bepaalde positie toe te wijzen, bijvoorbeeld x[0][0][1]=1 we drukken het element af dat op die locatie is opgeslagen, zoals te zien in de onderstaande uitvoer.