Arrays zijn een uiterst belangrijk onderwerp in C++. Ze worden heel vaak in programma's gebruikt en het is noodzakelijk om dit onderwerp grondig te begrijpen. Ik zal je meteen blij maken: het begrijpen en leren gebruiken van arrays is vrij eenvoudig, zelfs voor een beginner.

Waarom zijn arrays nodig en wat zijn ze? U weet inmiddels heel goed dat programmagegevens worden opgeslagen in het . Maar het komt voor dat een programma honderden (of zelfs meer) variabelen van hetzelfde type gegevens moet opslaan, en er ook mee moet werken: waarden toewijzen, wijzigen, enz.

U moet bijvoorbeeld de serienummers van lijnen opslaan. Mee eens - iedereen zou bang zijn bij de gedachte om vijfhonderd variabelen van het type int te creëren, elk een unieke naam te geven en een waarde van 1 tot 500 toe te kennen. (Ik ben al bang :) In dit geval zullen arrays ons eenvoudigweg redden.

Laten we de belangrijkste punten noteren en verder gaan met een praktisch voorbeeld:

• Een array in C++ is een verzameling van een bepaald aantal variabelen van hetzelfde type met dezelfde naam. Bijvoorbeeld, int-array;. Deze invoer betekent dat we een array met de naam hebben gedeclareerd reeks, welke bevat 3 type variabelen int ;
• arrayvariabelen worden elementen genoemd;
• Elk element heeft zijn eigen unieke index: zijn eigen serienummer. Met behulp van een index kunnen we toegang krijgen tot een specifiek element. BELANGRIJK - het indexeren van array-elementen begint vanaf 0 . Dus in de array int-array het eerste element heeft een index 0 , en de laatste is 2 . Om bijvoorbeeld toegang te krijgen tot het nulelement van een array en de waarde ervan te wijzigen, moet u de naam van de array opgeven en de index van het element tussen vierkante haken aangeven - matrix = 33 .

Laten we eens kijken naar een voorbeeld:

C++-arrays

// in dit programma maken we een array met grootte, // met behulp van een for-lus voeren we gegevens in alle cellen // van de array in en geven de inhoud ervan weer op het scherm #include naamruimte std gebruiken; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //declareer een constante int firstArray; //declareer een array met het aantal elementen SIZE for (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

// in dit programma maken we een array met size size, // gebruik de for-lus om gegevens in alle cellen in te voeren // array en geef de inhoud ervan op het scherm weer #erbij betrekken naamruimte std gebruiken; int hoofd() setlocale(LC_ALL, "rus"); const int GROOTTE = 10; //declareer een constante int eersteArray[SIZE]; //declare een array met het aantal elementen SIZE voor (int ik = 0; ik< SIZE ; i ++ ) //vul de waarden in en toon ze op het scherm eersteArray[i] = i+1; // wijs bij de eerste stap van de lus firstArray 1 (0 + 1) toe uit<< i << "-de cel slaat het nummer op"<< firstArray [ i ] << endl ; uit<< endl ; retour 0;

Op regel 12 definiëren we een geheel getalconstante MAAT, die de grootte van de array opslaat (door ons gedefinieerd, het aantal elementen). In regel 13 declareren we een array: we geven het type gegevens aan dat in de arraycellen wordt opgeslagen, geven een naam en geven de grootte aan tussen vierkante haakjes.

Het is belangrijk dat we alleen constante gehele waarden tussen vierkante haken kunnen schrijven. U moet ofwel onmiddellijk een geheel getal tussen vierkante haakjes invoeren wanneer u een array declareert ( int eersteArray;), of definieer een geheel getalconstante voordat u de array declareert en voer de naam van deze constante tussen vierkante haakjes in (zoals in ons voorbeeld).

De tweede methode verdient de voorkeur als u in de loop van het programma meerdere keren toegang moet krijgen tot de array via een lus. Dit wordt verklaard door het feit dat wanneer we een lus declareren, we daarin de voorwaarde kunnen specificeren voor het wijzigen van de teller naar de waarde MAAT .

Stel je voor dat we de grootte van de array moeten veranderen van 10 elementen naar 200. In dit geval hoeven we alleen maar de waarde van de gehele constante te veranderen, en dus zullen we automatisch nieuwe groottewaarden vervangen, zowel in de array en in alle lussen van het programma.

In ons voorbeeld kunt u proberen een ander getal aan de constante toe te voegen MAAT. En je zult zien dat het programma prima zal werken: het zal een array maken met zoveel elementen als je opgeeft, de gegevens invoeren en op het scherm weergeven.

En als de array erg klein is, bijvoorbeeld met 5 elementen, kunt u deze onmiddellijk na declaratie initialiseren:

Dus voor een element met index 0 – eersteArray– krijgt een waarde toegewezen 11 en het laatste element van de array eersteArray- betekenis 1 5 . Er is zo'n truc: je kunt de grootte van de array niet tussen vierkante haken aangeven en dit schrijven:

De vorige invoer is gelijkwaardig aan deze. Alleen in het tweede geval berekent de compiler automatisch de grootte van de array op basis van de hoeveelheid gegevens tussen accolades.

Ook is het tijdens de initiële initialisatie van array-elementen, wanneer de array moet worden ontdaan van “afval” (resterende gegevens van andere programma's in het geheugen), beter om onmiddellijk een waarde aan alle elementen toe te wijzen 0 . Het ziet er zo uit:

Houd er rekening mee dat een dergelijke initialisatie alleen mogelijk is voor het vullen met nullen. Als u de array-elementen met andere getallen wilt vullen, kunt u beter een lus gebruiken. In C++11 (coderingsstandaard) mag u bij gebruik van lijstinitialisatie (initialisatie met accolades) zelfs het teken weggooien = .

Ik zou nog een initialisatietechniek willen laten zien bij het maken van een array. Voor een array van 30 elementen moeten we bijvoorbeeld de waarden invoeren 33 En 44 alleen voor cellen met een index 0 En 1 dienovereenkomstig, en vul de rest met nullen. Dan doen wij dit:

deze gegevens worden ingevoerd in de nul- en eerste cellen, en de rest neemt automatisch de waarde aan 0 .

U kunt het vullen van een array ook organiseren met behulp van de operator cin:

voor (int i = 0; ik< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> eersteArray[i]; )

voor (int ik = 0; ik< size ; i ++ ) //vul de waarden in en toon ze op het scherm

Laatste update: 17-09-2017

Een array vertegenwoordigt een set gegevens van hetzelfde type. De formele definitie van een array is als volgt:

Variabel_type array_naam [array_lengte]

Na het type variabele komt de naam van de array en vervolgens de grootte ervan tussen vierkante haakjes. Laten we bijvoorbeeld een array van 4 getallen definiëren:

Int-nummers;

Deze array heeft vier getallen, maar al deze getallen hebben een ongedefinieerde waarde. We kunnen echter initialisatie uitvoeren en enkele initiële waarden aan deze getallen toewijzen via accolades:

Int-getallen = (1,2,3,4);

De waarden tussen accolades worden ook wel initializers genoemd. Als er minder initialisatoren zijn dan er elementen in de array zijn, worden initialisatoren gebruikt voor de eerste elementen. Als er meer initializers dan elementen in de array aanwezig zijn, zal er een fout optreden tijdens het compileren:

Int-getallen = (1, 2, 3, 4, 5, 6);

Hier heeft de array een grootte van 4, maar er worden 6 waarden aan doorgegeven.

Als de arraygrootte niet expliciet wordt opgegeven, wordt deze afgeleid uit het aantal initialisatoren:

Int-getallen = (1, 2, 3, 4, 5, 6);

In dit geval heeft de array 6 elementen.

Initialisatie van karakterarrays heeft zijn eigen kenmerken. We kunnen zowel een initialisatieset als een string doorgeven aan een karakterarray:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "wereld";

Bovendien zal de array s2 in het tweede geval niet uit 5 elementen bestaan, maar uit 6, omdat bij initialisatie met een string het nulteken “\0” automatisch aan de karakterarray wordt toegevoegd.

In dit geval is het niet toegestaan ​​om een ​​array aan een andere array toe te wijzen:

Int nums1 = (1,2,3,4,5); int nums2 = nums1; // fout nums2 = nums1; // fout

Zodra een array is gedefinieerd, hebben we via index toegang tot de afzonderlijke elementen. Indexen beginnen bij nul, dus om toegang te krijgen tot het eerste element moeten we index 0 gebruiken. Door een element per index te benaderen, kunnen we de waarde ervan verkrijgen of deze wijzigen:

#erbij betrekken int main() ( int getallen = (1,2,3,4); int eerste_getal = getallen; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Het aantal array-elementen kan ook worden bepaald via een constante:

Const int n = 4; int getallen[n] = (1,2,3,4);

Itereren over arrays

Met behulp van lussen kunt u de hele array doorlopen en toegang krijgen tot de elementen via indexen:

#erbij betrekken int main() ( int getallen = (1,2,3,4); int grootte = groottevan(getallen)/groottevan(getallen); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Om een ​​array te doorlopen, moet je eerst de lengte van de array vinden. De operator sizeof wordt gebruikt om de lengte te vinden. In wezen is de lengte van een array gelijk aan de totale lengte van zijn elementen. Alle elementen vertegenwoordigen hetzelfde type en nemen dezelfde grootte in het geheugen in beslag. Daarom vinden we met behulp van de uitdrukking sizeof(numbers) de lengte van de gehele array in bytes, en met behulp van de uitdrukking sizeof(numbers) vinden we de lengte van één element in bytes. Door de twee waarden te delen, kunt u het aantal elementen in de array verkrijgen. En dan herhalen we met behulp van een for-lus alle elementen totdat de teller i gelijk wordt aan de lengte van de array. Als gevolg hiervan worden alle elementen van de array naar de console uitgevoerd:

Maar er is ook een andere vorm van de for-lus, die speciaal is ontworpen voor het werken met verzamelingen, inclusief arrays. Dit formulier heeft de volgende formele definitie:

For(variabel type: verzameling) ( instructies; )

We gebruiken dit formulier om door een array te itereren:

#erbij betrekken int main() ( int getallen = (1,2,3,4); for(int getal: getallen) std::cout<< number << std::endl; return 0; }

Bij het doorlopen van een array wordt elk item dat herhaald wordt, in de getalvariabele geplaatst, waarvan de waarde in een lus naar de console wordt afgedrukt.

Als we het type objecten in de array niet weten, kunnen we de automatische specificatie gebruiken om het type te bepalen:

For(automatisch nummer: getallen) std::cout<< number << std::endl;

Multidimensionale arrays

Naast eendimensionale arrays heeft C++ ook multidimensionale arrays. De elementen van dergelijke arrays zijn op hun beurt arrays, waarbij de elementen ook arrays kunnen zijn. Laten we bijvoorbeeld een tweedimensionale reeks getallen definiëren:

Int-nummers;

Zo'n array bestaat uit drie elementen, waarbij elk element een array van twee elementen vertegenwoordigt. Laten we een array als volgt initialiseren:

Int-getallen = ( (1, 2), (4, 5), (7, 8) );

Geneste accolades geven de elementen voor elke subarray aan. Zo'n array kan ook als een tabel worden weergegeven:

1	2
4	5
7	8

U kunt de accolades ook weglaten tijdens de initialisatie:

Int-getallen = ( 1, 2, 4, 5, 7, 8);

Het is ook mogelijk om niet alle elementen te initialiseren, maar slechts enkele:

Int-getallen = ( (1, 2), (), (7) );

En om toegang te krijgen tot de elementen van een geneste array heb je twee indexen nodig:

Int-getallen = ( (1, 2), (3, 4), (5, 6) ); std::uit<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Laten we een tweedimensionale array herhalen:

#erbij betrekken int main() ( const int rijen = 3, kolommen = 2; int getallen = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

Je kunt ook een andere vorm van de for-lus gebruiken om door de elementen van een multidimensionale array te lopen:

#erbij betrekken int main() ( const int rijen = 3, kolommen = 2; int getallen = ( (1, 2), (3, 4), (5, 6) ); for(auto &subnummers: getallen) ( for(int getal : subnummers) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Om arrays die in een array zijn opgenomen te herhalen, worden verwijzingen gebruikt. Dat wil zeggen dat in de buitenste lus for(auto &subnumbers: getallen) &subnumbers een subarrayreferentie in de array vertegenwoordigt. In de binnenste lus for(int nummer: subnummers) halen we van elke subarray in subnummers de individuele elementen ervan in de getalvariabele en voeren we de waarde ervan uit naar de console.

Bij het oplossen van problemen met een grote hoeveelheid gegevens van hetzelfde type, maakt het gebruik van variabelen met verschillende namen die niet op geheugenadressen zijn geordend het programmeren lastig. In dergelijke gevallen gebruikt de C-taal objecten die arrays worden genoemd.

is een aaneengesloten stukje geheugen dat een reeks objecten van hetzelfde type bevat, aangeduid met één naam.

De array wordt gekenmerkt door de volgende basisconcepten:

Array-element (array-elementwaarde)– een waarde die is opgeslagen in een specifieke geheugencel in de array, evenals het adres van deze geheugencel.
Elk array-element wordt gekenmerkt door drie waarden:

• elementadres - het adres van de startgeheugencel waarin dit element zich bevindt;
• elementindex (volgnummer van het element in de array);
• elementwaarde.

Arrayadres – het adres van het startelement van de array.

Arraynaam is een identificatie die wordt gebruikt om naar array-elementen te verwijzen.

Arraygrootte – aantal array-elementen

Elementgrootte is het aantal bytes dat door één array-element wordt ingenomen.

Grafisch kan de locatie van de array in het computergeheugen worden weergegeven als een doorlopende strook adressen.

De array in de figuur bevat q-elementen met indices van 0 tot q-1. Elk element neemt k bytes in beslag in het computergeheugen, en de rangschikking van elementen in het geheugen is sequentieel.

De adressen van het i-de element van de array zijn

Het arrayadres is het adres van het startelement (nul) van de array. Om toegang te krijgen tot array-elementen wordt het serienummer (index) van het element gebruikt, waarvan de beginwaarde 0 is. Dus als een array q-elementen bevat, variëren de indices van de array-elementen van 0 tot q-1.

Arraylengte is het aantal bytes dat in het geheugen is toegewezen om alle elementen van de array op te slaan.

Arraylengte = Elementgrootte * Aantal elementen

De functie kan worden gebruikt om de grootte van een array-element te bepalen

int groottevan(type);

Bijvoorbeeld,

groottevan(char) = 1;
groottevan(int) = 4;
groottevan(float) = 4;
groottevan(dubbel) = 8;

Arrays declareren en initialiseren

Om een ​​array in C te declareren, wordt de volgende syntaxis gebruikt:

typenaam[dimensie]=(init);

Initialisatie is een reeks initiële waarden van de array-elementen, gespecificeerd tussen accolades, gescheiden door komma's.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // array a van 10 gehele getallen

Als het aantal initialisatiewaarden gespecificeerd tussen de accolades kleiner is dan het aantal array-elementen gespecificeerd tussen de vierkante haakjes, dan zullen alle resterende elementen in de array (waarvoor er niet voldoende initialisatiewaarden waren) nul zijn. Deze eigenschap is handig om te gebruiken om alle elementen van een array op nulwaarden in te stellen.

int b = (0); // array b van 10 elementen geïnitialiseerd op 0

Als de array wordt geïnitialiseerd bij het declareren, worden de constante beginwaarden van de elementen aangegeven, gescheiden door komma's tussen accolades. In dit geval kan het aantal elementen tussen vierkante haken worden weggelaten.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

Bij toegang tot array-elementen wordt de index van het vereiste element tussen vierkante haakjes aangegeven.

Voorbeeld in C

1
2
3
4
5
6
7
8

#erbij betrekken
int hoofd()
{
int a = ( 5, 4, 3, 2, 1 ); // array a bevat 5 elementen
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
retour 0;
}

Resultaat van programma-uitvoering:

Vaak is het echter nodig om de waarden van array-elementen in te stellen tijdens de uitvoering van het programma. Hierbij wordt een arraydeclaratie zonder initialisatie gebruikt. In dit geval is het verplicht het aantal elementen tussen vierkante haken aan te geven.

int a;

Om de beginwaarden van array-elementen in te stellen, wordt heel vaak een parametrische lus gebruikt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#erbij betrekken
int hoofd()
{
int a;
int ik;
// Array-elementen invoeren
voor (i = 0; ik<5; i++)
{
printf("a[%d] = ", ik);
scanf("%d" , &a[i]);
}
// Uitvoerarray-elementen
voor (i = 0; ik<5; i++)
printf("%d ", a[i]); // ruimte in printformaat is vereist
getchar(); getchar();
retour 0;
}

Resultaat van programma-uitvoering

Multidimensionale arrays

Multidimensionale arrays kunnen ook worden gedeclareerd in C. Het verschil tussen een multidimensionale array en een eendimensionale array is dat in een eendimensionale array de positie van een element wordt bepaald door één index, en in een multidimensionale array door meerdere. Een voorbeeld van een multidimensionale array is een matrix.

Algemene vorm van het declareren van een multidimensionale array

typenaam[dimensie1][dimensie2]...[dimensiem];

De elementen van een multidimensionale array bevinden zich in opeenvolgende RAM-cellen in oplopende adresvolgorde. In computergeheugen zijn de elementen van een multidimensionale array in een rij gerangschikt, bijvoorbeeld een array met 2 rijen en 3 kolommen,

int a;

wordt als volgt in het geheugen opgeslagen

Het totale aantal elementen in de gegeven tweedimensionale array wordt bepaald als

Aantal rijen * Aantal kolommen = 2 * 3 = 6.

Het aantal bytes geheugen dat nodig is om de array te huisvesten, wordt gegeven door

Aantal items * Itemgrootte = 6 * 4 = 24 bytes.

Initialiseren van multidimensionale arrays

De waarden van de elementen van een multidimensionale array kunnen, zoals in het eendimensionale geval, worden gespecificeerd door constante waarden wanneer ze worden gedeclareerd, tussen accolades (). In dit geval moet het aantal elementen in rijen en kolommen echter tussen vierkante haken worden aangegeven.

Voorbeeld in C

1
2
3
4
5
6
7
8
9

#erbij betrekken
int hoofd()
{
int a = ( 1, 2, 3, 4, 5, 6 );
printf("%d %d %d\n" , a, a, a);
getchar();
retour 0;
}

Vaker is het echter nodig om de waarden van de elementen van een multidimensionale array in te voeren tijdens de uitvoering van het programma. Voor dit doel is het handig om een ​​geneste parametrische lus te gebruiken.

Voorbeeld in C

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

#define_CRT_SECURE_NO_WARNINGS
#erbij betrekken
int hoofd()
{
int a; // array van 2 rijen en 3 kolommen
int ik, j;
// Array-elementen invoeren
voor (i = 0; ik<2; i++) // loop door lijnen
{
voor (j = 0; j<3; j++) // loop door kolommen
{
printf("a[%d][%d] = ", i, j);
scanf("%d" , &a[i][j]);
}
}
// Uitvoerarray-elementen
voor (i = 0; ik<2; i++) // loop door lijnen
{
voor (j = 0; j<3; j++) // loop door kolommen
{
printf("%d ", a[i][j]);
}
printf("\n" ); // nieuwe regel
}
getchar(); getchar();
retour 0;
}

Een array doorgeven aan een functie

Arrayverwerking kan gemakkelijk worden georganiseerd met behulp van speciale functies. Om een ​​array te verwerken, moet u als argumenten aan de functie doorgeven

• array-adres,
• array-grootte.

De uitzondering vormen de stringverwerkingsfuncties, waarbij het voldoende is om alleen het adres door te geven.

Wanneer variabelen als argumenten aan een functie worden doorgegeven, worden de gegevens als kopieën doorgegeven. Dit betekent dat als een parameterwaarde binnen een functie verandert, dit geen invloed heeft op de waarde ervan binnen de aanroepende functie.

Als een variabel adres (of array-adres) wordt doorgegeven aan een functie, worden alle bewerkingen die in de functie worden uitgevoerd op gegevens binnen het bereik van het opgegeven adres uitgevoerd op de originele gegevens, zodat de originele array (of variabele waarde) kan worden gewijzigd door de aangeroepen functie.

Voorbeeld in C Dan-array van 10 elementen. Verwissel de grootste en startelementen van de array. Gebruik de functie voor maximale zoek- en uitwisselingsbewerkingen van elementen.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define_CRT_SECURE_NO_WARNINGS
#erbij betrekken
// Uitwisselingsfunctie
ongeldige wijziging(int *x, int n)
{
// x - pointer naar array (arrayadres)
// n - arraygrootte
int ik;
int max, index;
maximaal = x;
index = 0;
// Het maximale element vinden
voor (i = 1; ik {
als (x[i]>max)
{
max = x[i];
index = ik;
}
}
// Aandelenbeurs
x = x;
x = maximaal;
}
// Hoofdfunctie
int hoofd()
{
int a;
int ik;
voor (i = 0; ik<10; i++)
{
printf("a[%d] = ", ik);
scanf("%d" , &a[i]);
}
verandering(a, 10); // roep de uitwisselingsfunctie aan
// Uitvoerarray-elementen
voor (i = 0; ik<10; i++)
printf("%d ", a[i]);
getchar();
getchar();
opbrengst
p = p * x[i];
}
retour p;
}
// Hoofdfunctie
int hoofd()
{
int a; // gedeclareerde array a van 5 elementen
int ik;
int pr;
// Array-elementen invoeren
voor (i = 0; ik<5; i++)
{
printf("a[%d] = ", ik);
scanf("%d" , &a[i]); // &a[i] - adres van het i-de element van de array
}
pr = func(a, 5); // bereken het product
printf("\n pr = %d" , pr); // voer het product van even elementen uit
getchar(); getchar();
retour 0;
}

Schort AdBlock op deze site op.

Een array is het eenvoudigste samengestelde gegevenstype. Toen we variabelen bespraken, hadden we een goede analogie met een doos. Laten we teruggaan naar haar. Als een variabele één doos is, dan bestaat een array uit meerdere genummerde, identieke dozen die dezelfde naam hebben en alleen verschillen in hun serienummer.

Fig.1 Variabelen en arrays. Analogie met dozen.

De afbeelding hierboven toont drie arrays:

• een integer-array met 8 elementen genaamd arr_int
• float-array van 11 elementen met de naam arr_float
• karakterarray van 6 elementen genaamd arr_char

Een array heeft, net als een variabele, zijn eigen naam en gegevenstype. Bovendien heeft de array nog één extra kenmerk: de grootte van de array. De grootte van een array is het aantal elementen dat erin kan worden opgeslagen. In onze doosanalogie is dit het aantal dozen.

Let op!

De nummering van array-elementen begint vanaf nul, niet vanaf één.

Een array declareren en initialiseren

Het declareren van een array lijkt sterk op het declareren van een variabele. Het enige verschil is dat u bovendien de grootte van de array tussen vierkante haken moet aangeven. Hier zijn enkele voorbeelden:

Lijst 1.

Int arr_int; dubbele arr_float; vlottergetal;

Voor de arraynaam gelden soortgelijke beperkingen als voor de variabelenaam.

Regel voor naamgeving van arrays

Een arraynaam is een reeks tekens, cijfers en het onderstrepingsteken "_" dat begint met een letter. Brievenbus is belangrijk.

Hier zijn nog enkele voorbeelden van array-declaraties:

Lijst 2.

Int cijfers, volgorde; dubbele prijzen;

Aan een array kunnen, net als aan elke variabele, initiële waarden worden toegewezen wanneer deze worden gedeclareerd. Als array-elementen geen enkele waarde krijgen, slaan ze rommel op, net als gewone variabelen.

Lijst 3.

Int arr_int = (2, 5, 5, 3, 4); dubbele arr_float = (1,2, -2,3, 4,5, 3,83, 0,01, -0,12, 44,2, 123,7, 23,44, -3,7, 7);

Als u aan alle elementen van een array nulwaarden moet toewijzen, kunt u dit als volgt doen:

Lijst 4.

Dubbele arr = (0);

Werken met individuele array-elementen

Om naar een afzonderlijk array-element te verwijzen, moet u de naam en het serienummer ervan tussen vierkante haakjes schrijven. Vergeet niet dat de nummering begint vanaf nul, niet vanaf één.

Laten we bijvoorbeeld de elementen van een array met vijf elementen op het scherm weergeven.

Lijst 5.

#erbij betrekken int main(void)( int arr = (2, 4, 3, 5, 5); printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return (0);

Als de array erg groot is, is het natuurlijk nog steeds een plezier om deze op deze manier element voor element uit te voeren. En niemand doet dit met kleine arrays. Het is beter en correcter om lussen te gebruiken. Bijvoorbeeld:

Lijst 6.

#erbij betrekken int main(void)( int arr = (0); for(int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Het programma in de eerste lus slaat de eerste honderd even getallen op in een array en geeft ze in de tweede lus weer op het scherm.

Laten we, gewapend met onze nieuwe hulpmiddelen, ons programma vanaf het begin van de les herschrijven, zodat het een array gebruikt om statistieken over willekeurige getallen op te slaan.

Lijst 7.

#erbij betrekken #erbij betrekken #erbij betrekken int main(void) ( srand(time(NULL)); int count = (0); int rand_nummer; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Besteed aandacht aan de techniek die in dit programma wordt gebruikt.
Het nulelement van de array slaat het aantal keren dat het getal 0 voorkomt op, het eerste element - het aantal keren dat het getal 1 voorkomt, het tweede element - het getal 2. Dat wil zeggen dat u met het gegenereerde getal zelf kunt bepalen aan welk element van de array u er een moet toevoegen. Daarom is er geen noodzaak voor een schakelaarselectieverklaring. Handig, nietwaar?

Arrays zijn ontworpen om meerdere waarden van hetzelfde type op te slaan. In het programma Fahrenheit naar Celsius hebben we bijvoorbeeld de gemiddelde temperatuurwaarde uit drie berekend. Als er niet drie waarden zijn, maar veel meer, dan moet u hier arrays gebruiken.

Voordat u een array kunt gebruiken, moet u deze definiëren. De definitie van een array omvat: het type gegevens dat in de array is opgeslagen, de naam van de array en het aantal array-elementen tussen vierkante haken:

int-array;

In deze code hebben we een array gedefinieerd met een identificatiearray (naam) van tien elementen van het type int.
In deze vorm zijn alle elementen van de array nog steeds niet geïnitialiseerd. Om ze te initialiseren wanneer ze worden gedeclareerd, moet je de volgende syntaxis gebruiken:

int-array = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

In dit geval krijgt het eerste element van de array de waarde 0 en het laatste element de waarde 9.
Je kunt lussen gebruiken om waarden aan array-elementen toe te wijzen. Het meest geschikt hiervoor is een for-lus.

C++-code int-array; //arraydefinitie voor (int i = 0; i< 10; i++) { array[i] = i; }

Hier hebben we toegang tot elk element van de array via een index - een getal tussen vierkante haakjes. Bij elke iteratie van de lus worden waarden van nul tot 9 aangenomen.

Houd er rekening mee dat de indexnummering begint vanaf nul. Daarom is het aantal indices altijd één minder dan het aantal array-elementen.

Met uitzondering van vierkante haakjes en subscripts wordt een array-element net als elke andere variabele gebruikt.

Snaren

Tot nu toe konden we strings alleen in constanten opslaan: "Voorbeeld van een constante string." We konden slechts één teken in variabelen opslaan: in het char-type. C++ gebruikt twee soorten strings: een array van elementen van het type char en het type str. Voorlopig concentreren we ons op de eerste optie.

Om een ​​string op te slaan hebben we een array nodig. Het ziet er ongeveer zo uit:

char string = ("s", "t", "p", "o"."k", "a");

Gelukkig is er een makkelijkere manier :)

char string = "tekenreeks";

In dit geval wordt automatisch een array van zeven elementen gemaakt. Waarom van de zeven? Het punt is dat elke regel moet eindigen met de tekenconstante "\0", die een lege byte vertegenwoordigt.

Als we in de voorgaande voorbeelden proberen een string van meer dan zes tekens in de stringarray in te voeren, zal de array overlopen omdat U kunt de grootte van een array niet wijzigen terwijl het programma actief is (maar niet altijd):

tekenreeks; // string kan zes tekens en "\0" opslaan

tekenreeks = "tekenreeks!"; // de regel bevat zeven tekens
Dit wordt niet aanbevolen :)

Er is nog een punt waar ik uw aandacht op wil vestigen. Wanneer de gebruiker een tekenreeks invoert, worden spaties geteld als "\0". We zullen nog geen strings in onze programma's invoeren, dus ik zal dit geval niet in detail uitleggen.

Arrays van arrays (tweedimensionale arrays)

Welnu, eindelijk komen we bij het belangrijkste in deze kwestie.

De kaart in strategische (en niet alleen) games (RTS) is verdeeld in cellen (in het Engels - tegel). Het is handig om deze cellen weer te geven met behulp van een tweedimensionale array.

In dit voorbeeld gaan we verder met het programma pseudo_game en simuleren we met behulp van een tweedimensionale array een kaart waarop de speler kan bewegen. Tot nu toe werd ‘beweging’ weergegeven met behulp van x- en y-coördinaten.

We zullen de cellen weergeven met symbolen. De grootte van de "kaart" is 15x20. Vijftien hoog, twintig breed. We vertegenwoordigen de speler met het symbool T.

Voeg eerst het headerbestand toe stdlib.h.

Verbeterd pseudo_spel

Ik geef alleen stukjes code. Het is raadzaam dat u het volledige programma voor ogen heeft. Je kunt het vinden in de sectie 'programmaoverzichten' - pseudo_game_0_2. Het compileert en draait. Kopieer het gewoon naar de editor van uw IDE en volg de tekst.

Initialisatie van gegevens:

C++-code karakteract; // variabele voor het lezen van gebruikersinvoer int ch; // variabele voor het opslaan van de gereduceerde waarde van de variabele act int x = 0; // twee variabelen om de coördinaten van de speler op te slaan int y = 0; char-kaart; // array voor het opslaan van de gamekaart // initialiseren van de array voor (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Een nieuwe operator voor ons is hier de definitie van een tweedimensionale array. Maar het verschilt bijna niet van de eendimensionale versie, er wordt alleen nog een paar vierkante haken aan toegevoegd. Tussen de eerste haakjes hebben we het aantal rijen aangegeven, in de tweede het aantal kolommen.

Daarna initialiseren we in twee lussen elk element van de array met de waarde " " - wat slechts een witruimteteken is. Eerst gaan we in de buitenste lus door alle rijen. Voor elke rij in de binnenste lus "doorkruisen" we de kolommen.

Laat me een gedetailleerd voorbeeld geven: na verschillende iteraties van de buitenste lus wordt de teller i gelijk aan 9. Het lichaam van de buitenste lus begint te worden uitgevoerd: de variabele j (de teller van de binnenste lus) wordt op nul geïnitialiseerd, de voorwaarde wordt gecontroleerd en de hoofdtekst van de binnenste lus wordt uitgevoerd: map = " ";, dat wil zeggen, het eerste teken (index nul) van de tiende regel (vergeet niet dat het aftellen vanaf nul begint) krijgt een spatie toegewezen. Vervolgens wordt aan teller j 1 toegewezen, wordt het lichaam van de lus uitgevoerd... enzovoort totdat teller j gelijk wordt aan 20 - aan de voorwaarde is niet voldaan en de binnenste lus wordt verlaten. Vervolgens wordt de externe teller verhoogd. Nu is het gelijk aan 10 en wordt het lichaam van de buitenste lus opnieuw uitgevoerd...

Na initialisatie met spaties plaatsen we het karakter van ons spel in de eerste kolom van de eerste rij.

Aan het begin van de hoofdlus roepen we de functie system() aan om het scherm van eerdere uitvoer te wissen.

Dan zijn er twee cycli die lijken op initialisatiecycli. Ze worden gebruikt om array-elementen op het scherm weer te geven. Het enige significante verschil is de uitvoer van het nieuweregelteken aan het einde van de hoofdtekst van de eerste lus.

Welnu, dan is er een vertakking waarin wordt bepaald welke toets wordt ingedrukt. De vertakking zelf is sinds de vorige keer weinig veranderd, maar er zijn verschillen in de inhoud van de blokken: ten eerste wijzen we een spatie toe aan de coördinaten waar het object zich bevindt. Dat wil zeggen, we ruimen de vorige plaats op. Vervolgens veranderen we een van de coördinaten. En dan wijzen we aan het array-element met de nieuwe indices het teken "T" toe.

Voorbeeld voor code "75" - verplaatsing naar links:

C++-code als anders (ch == 75) ( map[x][y] = " "; y--; map[x][y] = "T"; )

Nou, dat is het eigenlijk. Op dit moment hebben we een kaart van 15x20 waarop je de pijlen kunt gebruiken om het personage te verplaatsen - de letter "T". Niet slecht voor een zesde les! Deze applicatie wordt de basis voor al onze consoleprogramma's. Grafische verbeteringen zullen er niet zijn. Je kunt eenvoudigweg niet meer uit de DOS-console halen, en we zullen de Windows-console niet overwegen. Dit zal aanzienlijk tijd en moeite besparen.

Ik heb gedetailleerd commentaar gegeven op het pseudo_game-programma en je zult het waarschijnlijk zonder problemen begrijpen. Als dat niet het geval is, lees dan de programmalijst opnieuw en u zult dit probleem pas begrijpen als u het begrijpt :). Oefeningen helpen je de stof te consolideren. Het doen van de oefeningen is verplicht. Als er iets onduidelijk is, schrijf dan naar mijn e-mail - ik zal proberen te helpen.

Oefeningen:

1. In de volledige lijst van het programma heb ik switch-branching gebruikt. De code voor één if-vertakkingsblok wordt hier ook weergegeven. Voeg de resterende if-blokken toe.

2. Nu kan het programma naar niet-bestaande array-elementen schrijven. Controleer of u de kaartlimieten verlaat.

3. Maak ter oefening een programma dat twee velden voor een zeeslag op het scherm tekent. De eerste is voor de speler, de tweede is voor de vijand. Het tweede veld moet zich rechts van het eerste bevinden.
Vul de binnenste cellen in met spaties. Om een ​​rand te tekenen, gebruikt u een minteken en een rechte scheidingslijn: -, |, en voor hoeken gebruikt u een hekje #. Links van elk veld staat een stapel cijfers; bovenaan staan ​​letters.
Het kan meerdere lussen kosten om het hele veld te initialiseren. Zo zou de code eruit kunnen zien om de kolom met getallen in het tweede veld te vullen:

C++-code int-tekenreeks; // variabele die rijen int-kolom vertegenwoordigt; // variabele die de char-kaart van kolommen vertegenwoordigt; kolom = 15; voor (tekenreeks = 2; tekenreeks< 12; string++) { map = string - 1; }