Taulukot sisään C++ | Ilmoita | Alusta | Osoitin taulukkoesimerkkeihin

Miksi tarvitsemme taulukoita?

taulukot ovat erittäin tärkeitä millä tahansa ohjelmointikielellä. Ne tarjoavat kätevämmän tavan tallentaa muuttujia tai samantyyppisten tietojen kokoelmaa yhdessä sen sijaan, että ne tallennettaisiin erikseen. Jokaista taulukon arvoa tarkastellaan erikseen.

Ilmoita taulukko sisään C++

Taulukon ilmoitus sisään C++ sisältää taulukon tallentamien elementtien tyypin ja lukumäärän ilmoittamisen. Syntaksi:

type array-Name [ array-Size ];

Yksiulotteisen taulukon ilmoittamisen säännöt C++.

• Tyyppi: Tyyppi on taulukkoon tallennettavien elementtien tyyppi, ja sen on oltava kelvollinen C++ tietotyyppi.
• Array-Name: Taulukon nimi on taulukolle annettava nimi.
• Array-koko: Ary-Size on taulukkoon tallennettavien elementtien lukumäärä. Sen on oltava kokonaisluku ja suurempi kuin 0.

Voit esimerkiksi luoda taulukon nimeltä ikä ja tallentaa viiden oppilaan iät seuraavasti:

int age[5];

Taulukon ikä tallentaa 5 kokonaislukua, jotka edustavat eri oppilaiden ikää.

Taulukon alustus

Taulukon alustus on prosessi, jossa elementtejä määritetään/tallennustetaan taulukkoon. Alustus voidaan tehdä yhdellä käskyllä ​​tai yksitellen. Huomaa, että taulukon ensimmäinen elementti tallennetaan indeksiin 0, kun taas viimeinen elementti tallennetaan indeksiin n-1, missä n on taulukon elementtien kokonaismäärä.

Ikätaulukon tapauksessa ensimmäinen elementti tallennetaan indeksiin 0, kun taas viimeinen elementti tallennetaan indeksiin 4.

Käytämme ikätaulukkoa osoittamaan, kuinka taulukon alustus voidaan tehdä:

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

{ } -elementtien kokonaismäärä ei voi ylittää [ ] -kentässä ilmoitettua arvoa. Elementti 19 on indeksissä 0, 18 indeksissä 1, 21 indeksissä 2, 20 indeksissä 3 ja 17 indeksissä 4. Jos et ilmoita taulukkoon tallennettavien elementtien määrää [ ]:ssa, taulukko on vain tarpeeksi suuri pitämään sisällään { } -kenttään lisätyt elementit. Esimerkiksi:

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

Yllä oleva lauseke luo täsmälleen saman taulukon kuin edellinen. Voit myös määrittää yhden elementin taulukkoon käyttämällä sen indeksiä. Esimerkiksi:

age[3] = 20;

Yllä oleva lauseke tallentaa arvon 20 taulukon ikä indeksiin 3. Tämä tarkoittaa, että 20 on 4^th taulukon elementti.

Taulukotyypit

On olemassa kahdenlaisia C++ taulukot:

• Yksiulotteinen Array
• Moniulotteinen Array
• Osoitin taulukkoon

Yksiulotteinen taulukko

Tämä on taulukko, jossa tietokohteet on järjestetty lineaarisesti vain yhteen ulottuvuuteen. Sitä kutsutaan yleisesti 1-D-taulukoksi. Syntaksi:

datatype array-name[size];

• Taulukon nimi on taulukon nimi.
• Koko on taulukkoon tallennettavien kohteiden lukumäärä.

Esimerkiksi:

#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";
	}
}

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen, jonka sisään ohjelman logiikka pitäisi lisätä.
4. Main()-funktion rungon alku.
5. Ikänimisen taulukon ilmoittaminen 5 kokonaisluvun tallentamiseksi. Myös 5 kokonaislukua on alustettu.
6. Luo kokonaislukumuuttuja x käyttämällä for-silmukkaa.
7. For-silmukan rungon alku.
8. Käytä silmukkamuuttujaa x toistamaan taulukon iän arvoja ja tulostamaan ne konsoliin. "\n" on rivinvaihtomerkki ja tulostuu uudelle riville jokaisen iteroinnin jälkeen.
9. Rungon loppu silmukalle.
10. Main()-funktion rungon loppu.

Moniulotteinen Array

Tämä on matriisi, jossa tietokohteet on järjestetty muodostamaan taulukoita. Moniulotteisella taulukolla voi olla mikä tahansa määrä ulottuvuuksia, mutta kaksi- ja kolmiulotteiset taulukot ovat yleisiä. Syntaksi:

datatype array-name[d1][d2][d3]...[dn];

Taulukon nimi on sen taulukon nimi, jolla on n ulottuvuutta. Esimerkiksi:

Kaksiulotteinen taulukko

2D-taulukko tallentaa tiedot luetteloon 1-D-taulukon kanssa. Se on matriisi, jossa on rivejä ja sarakkeita. Voit määrittää 2D-taulukon käyttämällä seuraavaa syntaksia:

type array-Name [ x ][ y ];

Tyypin on oltava kelvollinen C++ tietotyyppi. Katso 2D-taulukko taulukkona, jossa x tarkoittaa rivien määrää ja y tarkoittaa sarakkeiden määrää. Tämä tarkoittaa, että tunnistat 2D-taulukon jokaisen elementin muodossa a[x][y], jossa x on rivin lukumäärä ja y niiden sarakkeiden lukumäärä, joihin elementti kuuluu.

Tässä on esimerkki 2D-taulukon alustamisesta:

int a[2][3] = {  
   {0, 2, 1} ,   /*  row at index 0 */
   {4, 3, 7} ,   /*  row at index 1 */
   };

Yllä olevassa esimerkissä meillä on 2D-taulukko, joka voidaan nähdä 2 × 3 -matriisina. Siinä on 2 riviä ja 3 saraketta. Elementtiä 0 voidaan käyttää muodossa [0][1], koska se sijaitsee rivin 0 ja sarakkeen 1 leikkauskohdassa. Elementtiä 3 voidaan käyttää muodossa [1][2], koska se sijaitsee rivin 1 ja sarakkeen 2 leikkauspiste.

Huomaa, että lisäsimme yksinkertaisesti kiharat aaltosulkeet erottaaksemme eri elementtirivit. Alustus olisi voitu tehdä myös seuraavasti:

int a[2][3] = {0, 2, 1, 4, 3, 7};
   };

Seuraavat C++ esimerkki osoittaa, kuinka alustaa ja kulkea 2D-taulukon läpi:

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

lähtö:

Tässä on kuvakaappaus yllä olevasta koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen, johon koodi tulee lisätä.
4. Main()-funktion rungon alku.
5. Kommentti. The C++ kääntäjä ohittaa tämän.
6. Ilmoitetaan 2D-taulukko, jossa on 3 riviä ja 2 saraketta. Myös kohteita on lisätty joukkoon.
7. Kommentti. The C++ kääntäjä ohittaa tämän.
8. Muuttujan i luominen silmukalla a for a. Tämä muuttuja toistuu taulukon riviindeksien yli.
9. Muuttujan j luominen silmukan a:lla. Tämä muuttuja toistuu taulukon sarakeindeksien yli.
10. Silmukoiden rungon alku.
11. Tulosta konsolin muuttujien i ja j arvot konsolin hakasulkeisiin.
12. Tulosta taulukon a indeksiin [i][j] tallennettu arvo.
13. Silmukoiden rungon pää.
14. Main()-funktion pitäisi palauttaa kokonaislukuarvo, jos ohjelma toimii hyvin.
15. Main()-funktion rungon loppu.

Kolmiulotteinen taulukko

3D-taulukko on joukko taulukoita. Jokainen 3D-taulukon elementti tunnistetaan kolmen indeksin sarjalla. 3D-taulukon elementteihin pääsemiseksi käytämme kolmea silmukkaa. Esimerkiksi:

#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";
}

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen, jonka sisään ohjelman logiikka pitäisi lisätä.
4. Main()-funktion rungon alku.
5. Ilmoitetaan 3D-taulukko, jonka koko on 2x3x2. Myös taulukon arvot on alustettu.
6. Matriisin indeksiin [0][1][0] tallennetun kohteen käyttäminen ja sen tulostaminen konsolissa.
7. Matriisin indeksiin [0][1][1] tallennetun kohteen käyttäminen ja sen tulostaminen konsolissa.
8. Main()-funktion rungon loppu.

Osoitin taulukkoon

A osoitin on muuttuja, joka sisältää osoitteen. Muutoin kuin osoittimen käyttäminen muuttujan osoitteen tallentamiseen, voimme käyttää sitä taulukon solun osoitteen tallentamiseen. Taulukon nimi viittaa jatkuvasti sen ensimmäiseen elementtiin. Harkitse alla olevaa julistusta:

int age[5];

Ikä on osoitin $age[0], taulukon ikä-nimisen ensimmäisen elementin osoitteeseen. Harkitse seuraavaa esimerkkiä:

#include <iostream>
using namespace std;
int main()
{
	int *john;

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

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

lähtö:

Huomaa, että yllä olevan lähdön ensimmäinen arvo voi palauttaa eri arvon riippuen tietokoneesi muistissa olevan taulukon ensimmäiselle elementille määritetystä osoitteesta.

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen, jonka sisään ohjelman logiikka pitäisi lisätä.
4. Main()-funktion rungon alku.
5. Osoitinmuuttujan ilmoittaminen nimeltä *john.
6. Ikä-nimisen kokonaislukutaulukon ilmoittaminen 5 kokonaisluvun tallentamiseksi. Myös kokonaislukujen arvot on alustettu.
7. Muuttujan john määrittäminen taulukon iän ensimmäiseen indeksiin tallennetun kohteen osoitteen arvoksi.
8. Tulostetaan muuttujan john arvo, joka on taulukon iän ensimmäiseen indeksiin tallennetun kohteen osoite.
9. Ensimmäisen taulukon ikään tallennetun arvon tulostaminen.
10. Main()-funktion rungon loppu.

Array-nimiä voidaan käyttää vakioosoittimina, ja päinvastoin on myös totta. Tämä tarkoittaa, että voit käyttää taulukon iän indeksiin 3 tallennettua arvoa *(ikä + 3). Esimerkiksi:

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

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen ja main()-funktion rungon alku.
4. Kommentti. The C++ kääntäjä ohittaa tämän.
5. Ikänimisen taulukon ilmoittaminen 5 kokonaisluvun tallentamiseksi.
6. Kokonaislukuosoittimen luominen p.
7. Määritetään p taulukon iän ensimmäisen elementin osoitteen arvo.
8. Kommentti. The C++ kääntäjä ohittaa tämän.
9. Tulosta tekstiä konsoliin.
10. Luo kokonaisluku x käyttämällä a for silmukkaa. { merkitsee for-silmukan rungon alkua.
11. Tulosta x:n arvot yhdistettynä johonkin muuhun konsolin tekstiin.
12. Tulosta *(p + x) -arvot konsolista.
13. For-silmukan rungon loppu.
14. Tulosta tekstiä konsoliin.
15. Luo muuttuja x käyttämällä a for silmukkaa. { merkitsee for-silmukan rungon alkua.
16. Tulosta x:n arvot 0–4 jonkin muun tekstin rinnalle.
17. Tulosta *(ikä + x) arvot.
18. For-silmukan rungon loppu.
19. Palauttaa arvon, jos ohjelma toimii onnistuneesti.
20. Main()-funktion rungon loppu.

Array-taulukon arvojen käyttäminen

Taulukon elementtejä käytetään niiden vastaavien indeksien avulla. Käytettävän elementin indeksi lisätään hakasulkeisiin [ ] välittömästi taulukon nimen jälkeen. Esimerkiksi:

int john = age[2];

Yllä olevassa esimerkissä toteamme yksinkertaisesti, että Johanneksen ikä on tallennettu ikänimisen taulukon indeksiin 2. Tämä tarkoittaa, että Johnin ikä on 3^rd arvo taulukon iässä. Tässä on täydellinen C++ esimerkki, joka näyttää, kuinka tämä arvo voidaan käyttää ja tulostaa:

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

lähtö:

Tässä on kuvakaappaus koodista:

Koodin selitys:

1. Sisältää iostream-otsikkotiedoston koodiimme. Sen avulla voimme lukea konsolista ja kirjoittaa siihen.
2. Mukaan lukien std-nimiavaruus, jotta sen luokkia ja toimintoja voidaan käyttää kutsumatta sitä.
3. Main()-funktion kutsuminen, johon koodi tulee lisätä.
4. Main()-funktion rungon alku.
5. Ikä-nimisen taulukon ilmoittaminen 5 kokonaislukuelementin tallentamiseksi.
6. Matriisiiän indeksiin 2 tallennetun arvon käyttäminen ja sen arvon tallentaminen muuttujaan nimeltä john.
7. Muuttujan john arvon tulostaminen konsoliin muun tekstin rinnalle.

Arrayin edut C++

Tässä on Array-sovelluksen käytön edut/edut C++:

• Matriisielementit voidaan kulkea helposti.
• Helppo käsitellä taulukkotietoja.
• Array elementtejä voidaan käyttää satunnaisesti.
• Taulukot helpottavat koodin optimointia; näin ollen voimme tehdä paljon työtä käyttämällä vähemmän koodia.
• Matriisitiedot on helppo lajitella.

Arrayin haitat C++

• Taulukolla on kiinteä koko; siksi emme voi lisätä siihen uusia elementtejä alustuksen jälkeen.
• Vaatimusta suuremman muistin varaaminen johtaa muistitilan tuhlaukseen, ja vähemmän muistia voi aiheuttaa ongelmia.
• Taulukkoon tallennettavien elementtien lukumäärä on tiedettävä etukäteen.

Yhteenveto

• Taulukko on tietorakenne, joka tallentaa saman tietotyypin elementtejä.
• Taulukon elementit tallennetaan peräkkäin.
• Taulukon elementit on merkitty niiden vastaavilla indekseillä. Ensimmäinen elementti on indeksissä 0, kun taas viimeinen elementti on indeksissä n-1, jossa on taulukon elementtien kokonaismäärä.
• Taulukon määrittelyyn kuuluu taulukon elementtien tietotyypit sekä taulukkoon tallennettavien elementtien lukumäärä.
• Yksiulotteinen taulukko tallentaa elementit peräkkäin.
• Kaksiulotteinen taulukko tallentaa elementit riveihin ja sarakkeisiin.
• Kolmiulotteinen matriisi on joukko taulukoita.
• Elementtejä voidaan lisätä taulukkoon niiden indekseillä.
• Taulukon elementtejä käytetään niiden indeksien avulla.
• Moniulotteisella taulukolla on useampi kuin yksi ulottuvuus.
• Taulukon nimi osoittaa sen ensimmäiseen elementtiin.
• Matriiseilla on kiinteä koko, mikä tarkoittaa, että uusia elementtejä ei voi lisätä taulukkoon sen alustamisen jälkeen.