C++:ssa taulukko on tietorakenne, jota käytetään useiden samantyyppisten tietotyyppien arvojen tallentamiseen viereiseen muistipaikkaan.

Esimerkiksi , jos meidän on tallennettava 4 tai 5 opiskelijan arvosanat, voimme helposti tallentaa ne luomalla 5 eri muuttujaa, mutta entä jos haluamme tallentaa 100 opiskelijan tai vaikkapa 500 opiskelijan arvosanat, niin muuttujien lukumäärän luominen on erittäin haastavaa. ja hallita niitä. Nyt kuvaan tulevat taulukot, jotka voivat tehdä sen helposti luomalla tarvittavan kokoisen taulukon.

Taulukon ominaisuudet C++:ssa

• Array on kokoelma samaa tietotyyppiä olevaa dataa, joka on tallennettu viereiseen muistipaikkaan.
• Matriisin indeksointi alkaa kohdasta 0. Se tarkoittaa, että ensimmäinen elementti on tallennettu 0. indeksiin, toinen 1.:een ja niin edelleen.
• Matriisin elementteihin pääsee käsiksi niiden indekseillä.
• Kun taulukko on ilmoitettu, sen koko pysyy vakiona koko ohjelman ajan.
• Taulukossa voi olla useita ulottuvuuksia.
• Taulukon koko tavuina voidaan määrittää sizeof-operaattorilla, jonka avulla voimme myös löytää taulukon elementtien lukumäärän.
• Löydämme taulukkoon tallennettujen elementtien tyypin vähentämällä vierekkäiset osoitteet.

Array Declaration C++

C++:ssa voimme ilmoittaa taulukon määrittämällä ensin tietotyypin ja sitten taulukon nimen sen koon kanssa.

data_type array_name[Size_of_array];>

Esimerkki

int arr[5];>

Tässä,

• int: Se on taulukkoon tallennettavien tietojen tyyppi. Voimme käyttää myös muita tietotyyppejä, kuten char, float ja double.
• arr: Se on taulukon nimi.
• 5: Se on taulukon koko, mikä tarkoittaa, että taulukkoon voidaan tallentaa vain 5 elementtiä.

Array:n alustus C++:ssa

C++:ssa voimme alustaa taulukon monin tavoin, mutta keskustelemme joistakin yleisimmistä tavoista alustaa taulukko. Voimme alustaa taulukon ilmoittamisen yhteydessä tai ilmoittamisen jälkeen.

1. Alusta taulukko arvoilla C++:ssa

Olemme alustaneet taulukon arvoilla. Aaltosulkeisiin '{}' suljetut arvot on määritetty taulukkoon. Tässä 1 on tallennettu arr[0]:een, 2 arr[1]:een ja niin edelleen. Tässä taulukon koko on 5.

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

2. Alusta taulukko arvoilla ja ilman kokoa C++:ssa

Olemme alustaneet taulukon arvoilla, mutta emme ole ilmoittaneet taulukon pituutta, joten taulukon pituus on yhtä suuri kuin aaltosulkeiden sisällä olevien elementtien lukumäärä.

Oho

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

3. Alusta taulukko ilmoituksen jälkeen (silmukoiden avulla)

Olemme alustaneet taulukon silmukalla taulukon ilmoittamisen jälkeen. Tätä menetelmää käytetään yleensä, kun haluamme ottaa syötteen käyttäjältä tai emme voi määrittää elementtejä yksitellen jokaiseen taulukon indeksiin. Voimme muokata silmukan ehtoja tai muuttaa alustusarvoja vaatimusten mukaan.

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

4. Alusta taulukko osittain C++:ssa

Tässä olemme ilmoittaneet taulukon 'partialArray', jonka koko on '5' ja vain arvoilla '1' ja '2'. Joten nämä arvot tallennetaan kahteen ensimmäiseen indeksiin, ja loput indeksit tallennetaan '0'.

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

5. Alusta taulukko nollalla C++:ssa

Voimme alustaa taulukon, jossa kaikki elementit ovat '0' määrittämällä '0' aaltosulkeiden sisällä. Tämä tapahtuu nollan tapauksessa vain, jos yritämme alustaa taulukon eri arvolla, esimerkiksi '2' tällä menetelmällä, niin '2' tallennetaan vain 0. indeksiin.

int zero_array[5] = {0};>

Matriisin elementin käyttäminen C++:ssa

Taulukon elementteihin pääsee käsiksi määrittämällä taulukon nimi ja sitten taulukon alaindeksioperaattorin [] sisällä olevan elementin indeksi. Esimerkiksi arr[i].

Esimerkki 1: C++-ohjelma, joka havainnollistaa taulukon elementtien käyttöä

// 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>

Päivitä Array Element

Jos haluat päivittää taulukon elementin, voimme käyttää taulukon alaindeksioperaattorin sisällä olevaa indeksiä, jonka haluamme päivittää, ja määrittää uuden arvon.

arr[i] = new_value;>

Kulje taulukko C++:ssa

Voimme kulkea taulukon yli silmukan avulla käyttämällä indeksointia C++:ssa. Ensin olemme alustaneet taulukon 'table_of_two', jossa on 2:n kerrannainen. Sen jälkeen suoritamme for-silmukan 0:sta 9:ään, koska taulukossa indeksointi alkaa nollasta. Siksi indeksien avulla tulostamme kaikki taulukkoon tallennetut arvot.

Esimerkki 2: C++-ohjelma, joka havainnollistaa taulukon läpikulkua

// 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>

Arrayn koko C++:ssa

C++:ssa meillä ei ole pituusfunktiota kuten Javassa taulukon koon löytämiseksi, mutta voimme laskea taulukon koon sizeof()-operaattorilla temppu. Ensin etsitään muistista koko taulukon käyttämä koko ja jaetaan se sitten taulukkoon tallennetun elementin tyypin koolla. Tämä antaa meille taulukkoon tallennettujen elementtien määrän.

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

Esimerkki 3: C++-ohjelma, joka havainnollistaa taulukon koon löytämistä

// 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>

Matriisien ja osoittimien välinen suhde C++:ssa

C++:ssa taulukot ja osoittimet liittyvät läheisesti toisiinsa. Taulukon nimeä käsitellään osoittimena, joka tallentaa taulukon ensimmäisen elementin muistiosoitteen. Kuten olemme aiemmin käsitelleet, In array -elementit tallennetaan vierekkäisiin muistipaikkoihin, minkä vuoksi voimme käyttää kaikkia taulukon elementtejä taulukon nimellä.

Esimerkki 4: Havainnollistaa taulukon ja osoittimien välistä suhdetta

// 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>

Selitys:

Yllä olevassa koodissa määritämme ensin taulukon arr ja ilmoittaa sitten osoitin ptr ja määritä sille taulukko arr. Voimme määrittää arr:n ptr:lle, koska arr on myös osoitin. Tämän jälkeen tulostamme muistiosoitteen arr käyttämällä viiteoperaattoria ( & ) ja tulosta myös osoittimeen tallennettu osoite ptr ja voimme nähdä arr ja ptr, molemmat tallentavat saman muistiosoitteen.

Esimerkki 5: Matriisielementtien tulostaminen ilman indeksointia C++:ssa

Yleensä käytämme ja tulostamme taulukon elementtejä indeksoinnin avulla. Esimerkiksi päästäksesi ensimmäiseen käyttämäämme elementtiin taulukon_nimi[0]. Olemme käsitelleet edellä, että taulukon nimi on osoitin, joka tallentaa ensimmäisen elementin osoitteen ja taulukon elementit tallennetaan vierekkäisiin paikkoihin. Nyt aiomme käyttää taulukon elementtejä käyttämällä vain taulukon nimeä.

// 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>

Selitys

Yllä olevassa koodissa julistimme ensin taulukon arr neljällä elementillä. Tämän jälkeen tulostamme taulukon elementit. Keskustellaan siitä, miten se tehdään. Keskustelimme siitä, että taulukon nimi on osoitin, joka tallentaa taulukon ensimmäisen elementin osoitteen, joten ensimmäisen elementin tulostamiseksi olemme käyttäneet osoittimen viittausta. (*arr) käyttämällä viittauksenpoistooperaattoria (*) joka tulostaa kyseiseen osoitteeseen tallennetut tiedot.

Tulostaaksesi taulukon toisen elementin lisäämme ensin 1 to arr joka vastaa (osoite arr + size_of_one_element *1), joka vie osoittimen heti ensimmäisen jälkeen olevaan osoitteeseen ja sen jälkeen osoitin ei ole käytössä toisen elementin tulostamiseksi. Vastaavasti tulostetaan loput taulukon elementit ilman indeksointia.

Array välitetään funktioon C++:ssa

Jotta taulukoita voitaisiin käyttää tehokkaasti, meidän pitäisi osata välittää taulukoita toimimaan. Voimme välittää taulukoita funktioille argumenttina samoin kuin muuttujat funktioille, mutta tiedämme, että taulukon nimeä käsitellään osoittimena käyttämällä tätä käsitettä, voimme välittää taulukon funktioille argumenttina ja sitten käyttää taulukon kaikkia elementtejä käyttämällä osoitin.

Joten lopulta, taulukot välitetään aina osoittimina funktioon. Katsotaanpa 3 tapaa siirtää taulukko funktiolle, joita käytetään pääasiassa.

1. Array syöttäminen osoittimena

Tässä menetelmässä yksinkertaisesti välitämme taulukon nimen funktiokutsussa, mikä tarkoittaa, että välitämme osoitteen taulukon ensimmäiselle elementille. Tässä menetelmässä voimme muokata funktion taulukkoelementtejä.

Syntaksi

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

2. Array välitetään kokoamattomana taulukkona

Tässä menetelmässä funktio hyväksyy taulukon käyttämällä argumenttina yksinkertaista taulukkoilmoitusta ilman kokoa.

Syntaksi

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

3. Array välitetään kokoisena taulukkona

Tässä menetelmässä funktio hyväksyy taulukon käyttämällä yksinkertaista taulukkoilmoitusta, jonka argumenttina on koko. Käytämme tätä menetelmää määrittämällä taulukon koon vain osoittamaan taulukon kokoa.

Syntaksi

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

Huomautus: Taulukkoa käsitellään osoittimena hyväksytyssä funktiossa riippumatta siitä, mitä menetelmää käytämme. Kun taulukko välitetään osoittimina, ne menettävät tiedot sen koosta, mikä johtaa ilmiöön nimeltä Array Decay.

Esimerkki: Havainnollistaa erilaisia ​​tapoja siirtää taulukoita funktioon

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

Moniulotteiset taulukot C++:ssa

Matriiseja, joissa on useampi kuin yksi ulottuvuus, kutsutaan moniulotteisiksi taulukoiksi. Yleisimmin käytetyt moniulotteiset taulukot ovat 2D-taulukot ja 3D-taulukot. Nämä taulukot esitetään yleensä rivien ja sarakkeiden muodossa.

Moniulotteinen taulukkoilmoitus

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

missä,

• Tietotyyppi: Taulukkoon tallennettavien tietojen tyyppi.
• Array_Name: Taulukon nimi.
• Koko1, Koko2,…, KokoN: Jokaisen ulottuvuuden koko.

Kaksiulotteinen taulukko C++:ssa

C++:ssa kaksiulotteinen taulukko on riveihin ja sarakkeisiin järjestettyjen elementtien ryhmittely. Jokaista elementtiä käytetään kahdella indeksillä: yksi riville ja toinen sarakkeelle, mikä tekee siitä helposti visualisoinnin taulukkona tai ruudukkona.

2D-taulukon syntaksi

data_Type array_name[n][m];>

Missä,

• n: Rivien määrä.
• m: Kolumnien numerot.
  

Esimerkki: C++-ohjelma kaksiulotteisen taulukon havainnollistamiseksi

// 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>

Selitys

Yllä olevassa koodissa olemme ilmoittaneet 2D-taulukon, jossa on 4 riviä ja 4 saraketta, minkä jälkeen alustamme taulukon arvolla (i+j) silmukan jokaisessa iteraatiossa. Sitten tulostetaan 2D-taulukko sisäkkäisen silmukan avulla ja alla olevasta tuloksesta nähdään, että riviä on 4 ja saraketta.

Kolmiulotteinen taulukko C++:ssa

3D-taulukko käyttää kolmea ulottuvuutta. Sen esittämiseen voidaan käyttää kokoelmaa erilaisia ​​päällekkäin pinottuja kaksiulotteisia taulukoita. Kolmea indeksiä – riviindeksiä, sarakeindeksiä ja syvyysindeksiä käytetään yksilöimään jokainen elementti 3D-taulukossa.

Kolmiulotteisen taulukon ilmoitus C++:ssa

Jotta voimme ilmoittaa 3D-taulukon C++:ssa, meidän on määritettävä sen kolmas ulottuvuus yhdessä 2D-mittojen kanssa.

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

Missä,

• Tietotyyppi: Kuhunkin elementtiin tallennettavien tietojen tyyppi.
• Array_Name: Taulukon nimi
• D: 2D-taulukoiden lukumäärä tai taulukon syvyys.
• R: Rivien lukumäärä kussakin 2D-taulukossa.
• C: Sarakkeiden lukumäärä kussakin 2D-taulukossa.

Esimerkki

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

Esimerkki: C++-ohjelma 3d-taulukon havainnollistamiseen

// 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>

Selitys

Yllä olevassa koodissa olemme ilmoittaneet 3D-taulukon ja alustaneet sen käyttämällä kolmea sisäkkäistä silmukkaa. Sen jälkeen tulostimme kaikki 3D-taulukon kerrokset uudelleen käyttämällä kolmea sisäkkäistä silmukkaa, kuten tulosteessa näkyy.

Aiheeseen liittyvät artikkelit

• Moniulotteiset taulukot C++:ssa
• Arrayn ominaisuudet
• Array Decay