Manieren om array-elementen op te sommen c. Arrays gebruiken met dynamische geheugentoewijzing

Wat zijn arrays in C?

Hoe arrays in C declareren?

Hoe arrays in C te initialiseren?

Arrays in C voor dummies.

Arrays in C

Een array in C is een verzameling elementen van hetzelfde type die toegankelijk zijn via de index. De elementen van arrays in C bevinden zich achter elkaar in het geheugen van de computer.

Een eenvoudig voorbeeld van het maken en vullen van een array in C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ;)

Wij krijgen:

In het voorbeeld declareren we een array met elementen van het type int:

hier is de arraynaam nArr, het aantal array-elementen is drie, het type array-elementen is int.

Een array is een verzameling elementen. Naar elk element van de array kan worden verwezen met zijn nummer. Het nummer wordt gewoonlijk een index genoemd. De array-elementen zijn genummerd vanaf nul. Laten we een waarde toewijzen aan het eerste element van de array, en het eerste element heeft index nul:

Laten we een waarde toewijzen aan het tweede element van de array, en het tweede element heeft index één:

Laten we een waarde toewijzen aan het derde element van de array, en het derde element heeft index twee:

Wanneer we array-elementen op het scherm weergeven, krijgen we hun waarden. Zoals dit:

printf("nArr\t=\t%d\n", nArr);

Om een ​​element van een array te verkrijgen, moet u de naam van de array en de index van het element opgeven:

Dit is het eerste element van de array, omdat het eerste element index nul heeft.

Wijs de waarde van het derde element van de array toe int-variabele A:

de index van het derde element van de array is twee, aangezien indices vanaf nul worden geteld.

Nu algemene regel declaraties van arrays in C: bij het declareren van een array moet u de naam, het type elementen en het aantal elementen opgeven. Het aantal elementen is een natuurlijk getal, d.w.z. het geheel is positief. Nul kan niet het aantal elementen zijn. U kunt geen variabel aantal array-elementen opgeven. Hier zijn voorbeelden van array-declaraties in C:

int nArr; // Er is aangegeven dat een array honderd gehele getallen kan bevatten;
zweven fArr; // Er is een array gedeclareerd die is ontworpen om 5 float-nummers op te slaan;
char cArr; // Er is aangegeven dat een array twee karakters kan opslaan;

Het zou een vergissing zijn om een ​​array met een variabel aantal elementen te declareren:

Int varElem;
int nArr; // Fout! Het aantal elementen kan niet op een variabele worden ingesteld;

Maar u kunt het aantal elementen instellen constante waarde: of een direct positief geheel getal 1, 2, 3... of een constante:

Const int arrayLengte = 3;
int nArr;

Wanneer u een array in C declareert, kunt u deze onmiddellijk initialiseren:

int nMassiv = (1, 2, 3);

U kunt het aantal array-elementen tussen vierkante haakjes weglaten als alle array-elementen zijn geïnitialiseerd:

int nMassiv = (1, 2, 3);

het aantal elementen wordt in dit geval automatisch bepaald.

U kunt slechts een deel van de elementen van een array definiëren wanneer u deze declareert:

int nMassiv = (1, 2);

in dit voorbeeld zijn de eerste twee elementen van de array geïnitialiseerd, maar is het derde ongedefinieerd.

Voorbeeld van een karakterarray:

char cArr = ("S", "B", "P");

Bij het declareren van een array kunt u het aantal elementen van een variabele niet opgeven. Maar u kunt variabelen gebruiken bij toegang tot array-elementen:

Intindi = 0;
char cr = cArr;

Dit wordt gebruikt bij het werken met lussen. Voorbeeld:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

In het voorbeeld vullen we in de eerste lus de array met elementen van het type int, en in de tweede lus geven we deze elementen op het scherm weer.

Laten we doorgaan met het leren van de basisprincipes van C++. In dit artikel gaan we kijken naar arrays.

Met arrays kunt u dat doen handig formaat houden groot aantal gegevens. In wezen reeks is een variabele die meerdere waarden onder één naam opslaat, maar aan elke waarde wordt een eigen index toegewezen. is een lijst met waarden waartoe indexen worden gebruikt.

Inleiding tot arrays

Je kunt een array als volgt visualiseren:

Dit is een set van enkele waarden die achter elkaar, onder één naam, worden opgeslagen. Om deze waarden te verkrijgen hoeft u geen nieuwe variabelen aan te maken, u hoeft alleen maar de index aan te geven waaronder de waarde in de array is opgeslagen. U moet bijvoorbeeld een set van vijf distribueren speelkaarten voor poker kun je deze kaarten in een array en voor selectie opslaan nieuwe kaart verander alleen het indexnummer, in plaats van een nieuwe variabele te gebruiken. Hierdoor kunt u dezelfde code gebruiken om alle kaarten te initialiseren en als volgt te schrijven:

Kaart1 = getRandomCard(); Kaart2 = getRandomCard(); Kaart3 = getRandomCard(); Kaart4 = getRandomCard(); Kaart5 = getRandomCard();

Voor (int i = 0; ik< 5; i++) { card[i] = getRandomCard(); }

Stel je nu het verschil voor als er 100 variabelen zijn!

Syntaxis

Om een ​​array te declareren, moet je twee dingen opgeven (naast de naam): het type en de grootte van de array:

Int mijn_array[6];

Deze regel declareert een array van zes gehele waarden. Merk op dat de grootte van de array is ingesloten vierkante haakjes achter de arraynaam.

U gebruikt vierkante haken om toegang te krijgen tot array-elementen, maar deze keer specificeert u de index van het element waartoe u toegang wilt krijgen:

Mijn_array[3];

Visualiseer dit proces je kunt dit doen:

my_array verwijst naar de gehele array, terwijl my_array alleen naar het eerste element verwijst, en my_array naar het vierde. merk dat op indexering elementen in een array beginnen bij 0. Toegang tot array-elementen zal dus altijd plaatsvinden met een offset, bijvoorbeeld:

Int mijn_array[4]; // array-declaratie my_array[2] = 2; // stel de waarde van de derde (namelijk de derde!) in op 2

Multidimensionale arrays declareren in C++

Arrays kunnen ook worden gebruikt om multidimensionale gegevens weer te geven, zoals schaakbord of een boter-kaas-en-eierenveld. Bij het gebruik van multidimensionale gegevens worden meerdere indexen gebruikt om toegang te krijgen tot array-elementen.

Om een ​​tweedimensionale array te declareren, moet u de dimensie van twee dimensies opgeven:

Int tic_tac_toe_board;

Visualisatie van een array met indices van zijn elementen:

Om toegang te krijgen tot de elementen van een dergelijke array, hebt u twee indexen nodig: één voor de rij en één voor de kolom. De foto laat zien vereiste indexen om toegang te krijgen tot elk van de elementen.

Arrays gebruiken

Als je arrays gebruikt, kun je niet zonder . Om een ​​lus te doorlopen, initialiseert u eenvoudigweg een variabele op nul en verhoogt u deze totdat deze de grootte van de array overschrijdt: een patroon dat precies goed is voor een lus.

Het volgende programma demonstreert het gebruik van een lus om een ​​tafel van vermenigvuldiging te maken en het resultaat daarin op te slaan tweedimensionale array:

#erbij betrekken naamruimte std gebruiken; int main() ( int array; // Declareer een array die op een schaakbord lijkt voor (int i = 0; i< 8; i++) { for (int j = 0; j < 8; j++) { array[i][j] = i * j; // Задаем значения каждого элемента } } cout << "Multiplication table:\n"; for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { cout << "[ " << i << " ][ " << j << "] = "; cout << array[i][j] << " "; cout << "\n"; } } }

Arrays doorgeven aan functies

Zoals je kunt zien, werken verschillende elementen van de C++-taal met elkaar samen. Net als bij lussen kunnen arrays worden gebruikt in combinatie met .

Om een ​​array aan een functie door te geven, geeft u eenvoudigweg de naam op:

Int-waarden[ 10 ]; som_array(waarden);

En wanneer u een functie declareert, specificeert u een array als argument:

Int sum_array(int-waarden);

Houd er rekening mee dat we de dimensie van de array niet specificeren in de functieargumenten. Dit is normaal; bij eendimensionale arrays is het niet nodig om de dimensie op te geven. Wanneer moet de maat worden aangegeven arrays declareren , omdat De compiler moet weten hoeveel geheugen hij moet toewijzen. Bij het doorgeven aan een functie geven we eenvoudigweg een bestaande array door; het is niet nodig om de grootte op te geven, omdat We creëren geen nieuwe. Omdat we geven een array door aan de functie, binnen de functie kunnen we dat doen wijziging, in tegenstelling tot eenvoudige variabelen die door waarde worden doorgegeven, heeft het wijzigen van deze waarde binnen de functie op geen enkele manier invloed op de oorspronkelijke variabele.

Omdat we de grootte van de array in de functie niet weten, moeten we de dimensie als tweede argument doorgeven:

Int sumArray(int-waarden, int-grootte) ( int som = 0; for (int i = 0; i< size; i++) { sum += values[ i ]; } return sum; }

Wanneer we multidimensionale arrays doorgeven, moeten we alle dimensies specificeren behalve de eerste:

Int check_tic_tac_toe(int bord);

U kunt uiteraard de eerste dimensie opgeven, maar deze wordt genegeerd.

Dit onderwerp zal in meer detail worden besproken in het artikel over aanwijzingen.

Laten we voorlopig een functie schrijven die de som van de array-elementen berekent:

#erbij betrekken naamruimte std gebruiken; int sumArray(int-waarden, int size) ( int sum = 0; // de lus stopt wanneer i == size, omdat de index van het laatste element = size - 1 for (int i = 0; i< size; i++) { sum += values[i]; } return sum; } int main() { int values; for (int i = 0; i < 10; i++) { cout << "Enter value "<< ik <<": "; cin >> waarden[i];<< sumArray(values, 10) << endl; }

) uit

Sorteer een array

#erbij betrekken Laten we het probleem oplossen van het sorteren van een reeks van 100 door de gebruiker ingevoerde getallen:< 100; i++) { cout << "Enter value "<< ik <<": "; cin >naamruimte std gebruiken; int main() ( int waarden[ 100]; for (int i = 0; i

> waarden[ ik ];

))

Klaar, het enige dat je nog hoeft te doen is deze array te sorteren :) Hoe sorteren mensen gewoonlijk arrays? Ze zoeken naar het kleinste element erin en plaatsen dat bovenaan de lijst. Vervolgens zoeken ze naar de volgende minimumwaarde en plaatsen deze direct na de eerste, enzovoort.< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Dit hele ding lijkt op een cyclus: we doorlopen de array, beginnend met het eerste element, zoeken naar de minimumwaarde in het resterende deel, en wisselen deze elementen om. Laten we beginnen met het schrijven van de code om deze bewerkingen uit te voeren:

Void sort(int array, int size) ( for (int i = 0; i< size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

Nu kunt u nadenken over het implementeren van twee hulpmethoden: findSmallestRemainingElement en swap. De methode findSmallestRemainingElement moet de array doorlopen en het kleinste element vinden, beginnend bij index i:

Void swap(int array, int eerste_index, int tweede_index) ( int temp = array[ eerste_index ]; array[ eerste_index ] = array[ tweede_index ]; array[ tweede_index ] = temp; )

Om het algoritme te testen, vult u de array met willekeurige getallen en sorteert u deze. Alle programmacode:

#erbij betrekken #erbij betrekken #erbij betrekken naamruimte std gebruiken; int findSmallestRemainingElement(int array, int grootte, int index); void swap(int array, int eerste_index, int tweede_index); void sort(int array, int size) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

Het sorteeralgoritme waar we zojuist naar hebben gekeken heet invoegsoort , dit is niet het snelste algoritme, maar het is gemakkelijk te begrijpen en te implementeren. Als je grote hoeveelheden data moet sorteren, kun je beter complexere en snellere algoritmen gebruiken.

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 genaamd 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; //declare een constante int firstArray; //declare 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; }

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 tijdens 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 het 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]; )

• Handleiding

In dit bericht zal ik proberen eindelijk zulke subtiele concepten in C en C++ als pointers, referenties en arrays te begrijpen. In het bijzonder zal ik de vraag beantwoorden of C-arrays pointers zijn of niet.

Notaties en aannames

• Ik ga ervan uit dat de lezer begrijpt dat bijvoorbeeld C++ referenties heeft, maar C niet, dus ik zal je er niet voortdurend aan herinneren over welke taal (C/C++ of C++) ik het heb, de lezer zal dit vanuit de context begrijpen;
• Ook ga ik ervan uit dat de lezer C en C++ al op een basisniveau kent en bijvoorbeeld de syntaxis kent voor het declareren van een link. In deze post zal ik ingaan op een nauwgezette analyse van de kleine dingen;
• Ik zal typen aanduiden zoals de declaratie van de TYPE-variabele van het overeenkomstige type eruit zou zien. Ik zal het type “array met lengte 2 ints” bijvoorbeeld aanduiden als int TYPE;
• Ik neem aan dat we vooral te maken hebben met gewone gegevenstypen zoals int TYPE , int *TYPE , enz., waarvoor de operatoren =, &, * en andere niet worden overschreven en gewone dingen aanduiden;
• "Object" betekent altijd "alles dat geen referentie is", niet "een instantie van een klasse";
• Overal, behalve waar specifiek vermeld, worden C89 en C++98 geïmpliceerd.

Aanwijzingen en links

Int x; int *y = // U kunt een adres uit elke variabele halen met behulp van de adresopnamebewerking "&". Deze bewerking retourneert een pointer int z = *y; // Van een pointer kan dereferentie worden verwijderd met behulp van de dereferentieoperator "*". Deze bewerking retourneert het object waarnaar de aanwijzer verwijst

Laat me je ook aan het volgende herinneren: char is altijd precies één byte en in alle C- en C++-standaarden is de grootte van (char) == 1 (maar de standaarden garanderen niet dat een byte precies 8 bits bevat :)). Als u verder een getal toevoegt aan een aanwijzer naar een bepaald type T, zal de werkelijke numerieke waarde van deze aanwijzer toenemen met dit getal vermenigvuldigd met de grootte van (T) . Dat wil zeggen, als p van het type T *TYPE is, dan is p + 3 equivalent aan (T *)((char *)p + 3 * sizeof (T)) . Soortgelijke overwegingen zijn van toepassing op aftrekken.

Koppelingen. Nu over de koppelingen. Koppelingen zijn hetzelfde als verwijzingen, maar met een andere syntaxis en enkele andere belangrijke verschillen, die later zullen worden besproken. De volgende code verschilt niet van de vorige, behalve dat deze koppelingen gebruikt in plaats van verwijzingen:
int x; int &y = x; int z = y;

Als er links van het toewijzingsteken een verwijzing staat, is het onmogelijk om te weten of we de verwijzing zelf willen toewijzen of het object waarnaar deze verwijst. Daarom wijst een dergelijke toewijzing altijd toe aan een object, niet aan een referentie. Maar dit geldt niet voor de initialisatie van de link: uiteraard wordt de link zelf geïnitialiseerd. Daarom is er, zodra een referentie is geïnitialiseerd, geen manier meer om deze zelf te wijzigen, dat wil zeggen dat de referentie altijd persistent is (maar niet het object ervan).

Lwaarde. De uitdrukkingen die kunnen worden toegewezen, worden lvalues ​​genoemd in C, C++ en vele andere talen (dit is een afkorting van ‘linkerwaarde’, d.w.z. links van het gelijkteken). De overige expressies worden rwaarden genoemd. Variabelenamen zijn uiteraard lwaarden, maar dit zijn niet de enige. De expressies a, some_struct.some_field, *ptr, *(ptr + 3) zijn ook lwaarden.

Het verrassende feit is dat referenties en waarden in zekere zin hetzelfde zijn. Laten we speculeren. Wat is waarde? Het is iets dat kan worden toegeëigend. Dat wil zeggen, dit is een soort vaste plek in het geheugen waar je iets kunt plaatsen. Dat wil zeggen: het adres. Dat wil zeggen, een pointer of een link (zoals we al weten zijn pointers en links twee syntactisch verschillende manieren om het concept van een adres in C++ uit te drukken). Bovendien is het meer een link dan een pointer, aangezien de link links van het gelijkteken kan worden geplaatst en dit een toewijzing betekent aan het object waarnaar de link verwijst. Dus lvalue is een referentie.

Oké, maar (bijna elke) variabele kan ook links van het gelijkteken staan. Dus (zo'n) variabele is een referentie? Bijna. Een expressie die een variabele vertegenwoordigt, is een verwijzing.

Met andere woorden, laten we zeggen dat we int x hebben gedeclareerd. Nu is x een int TYPE-variabele en niets anders. Het is een int en dat is alles. Maar als ik nu x + 2 of x = 3 schrijf, dan is in deze expressies de subexpressie x van het type int &TYPE . Omdat deze x anders niet anders zou zijn dan bijvoorbeeld 10, en er (net als tien) niets aan toegewezen zou kunnen worden.

Dit principe (“een uitdrukking die een variabele is, is een referentie”) is mijn uitvinding. Dat wil zeggen, ik heb dit principe in geen enkel leerboek, standaard, enz. gezien. Het vereenvoudigt echter veel en is handig om als correct te beschouwen. Als ik een compiler zou implementeren, zou ik de variabelen in de expressies eenvoudigweg als referenties behandelen, en dit is heel goed wat echte compilers zouden moeten doen.

Het principe “elke waarde is een referentie” is ook mijn uitvinding. Maar het principe ‘elke referentie is een waarde’ is een volledig legaal, algemeen aanvaard principe (uiteraard moet de link een verwijzing zijn naar een veranderlijk object, en dit object moet toewijzing mogelijk maken).

Nu zullen we, rekening houdend met onze conventies, strikt de regels formuleren voor het werken met referenties: als bijvoorbeeld int x wordt gedeclareerd, dan heeft de expressie x nu het type int &TYPE . Als deze uitdrukking (of een andere uitdrukking van het linktype) nu links van het gelijkteken staat, dan wordt deze in vrijwel alle andere gevallen (bijvoorbeeld in de situatie x + 2) precies als link gebruikt; automatisch geconverteerd naar het int TYPE type (door een andere bewerking, waarna de referentie niet wordt geconverteerd naar het object &, zoals we later zullen zien). Links van het gelijkteken kan alleen een link staan. Alleen een referentie kan een (niet-const) referentie initialiseren.

Operaties * en &. Onze conventies geven ons een nieuwe manier om naar de * en & operaties te kijken. Nu wordt het volgende duidelijk: de *-operatie kan alleen worden toegepast op een pointer (vooral is dit altijd al bekend geweest) en geeft een verwijzing naar hetzelfde type terug. & wordt altijd toegepast op een verwijzing en retourneert een pointer van hetzelfde type. Dus * en & veranderen pointers en referenties in elkaar. Dat wil zeggen dat ze in wezen helemaal niets doen en alleen de essentie van de ene syntaxis vervangen door de essentie van een andere! Dus, en in het algemeen, is het niet helemaal correct om de handeling van het nemen van een adres te noemen: het kan alleen worden toegepast op een reeds bestaand adres, het verandert eenvoudigweg de syntactische uitvoeringsvorm van dit adres.

Merk op dat pointers en referenties worden gedeclareerd als int *x en int &x . Zo wordt het principe ‘declaratie suggereert gebruik’ opnieuw bevestigd: de declaratie van een pointer herinnert je eraan hoe je er een link van kunt maken, en de declaratie van een link doet het tegenovergestelde.

Merk ook op dat &*EXPR (hier is EXPR een willekeurige uitdrukking, niet noodzakelijkerwijs een enkele identificatie) gelijkwaardig is aan EXPR wanneer dit zinvol is (d.w.z. wanneer EXPR een pointer is), en *&EXPR ook gelijk is aan EXPR wanneer dit zinvol is betekenis (dat wil zeggen wanneer EXPR een link is).

Arrays

Net zoals alle lokale variabelen (onthoud dat we ervan uitgaan dat alle codevoorbeelden zich binnen functies bevinden) zich op de stapel bevinden, bevinden zich ook arrays op de stapel. Dat wil zeggen, de bovenstaande code leidde tot de toewijzing van een enorm geheugenblok van grootte 5 * sizeof (int) rechtstreeks op de stapel, waarin onze hele array zich bevindt. Je hoeft niet te denken dat deze code een soort verwijzing is die verwijst naar geheugen dat zich ergens ver weg op de heap bevindt. Nee, we hebben een array verklaard, een echte. Hier op de stapel.

Waaraan zal de grootte van (x) gelijk zijn? Uiteraard zal deze gelijk zijn aan de grootte van onze array, d.w.z. 5 * sizeof (int) . Als we schrijven
struct foo (int a; int b; );
dan zal de ruimte voor de array opnieuw volledig binnen de structuur worden toegewezen, en de grootte van deze structuur zal dit bevestigen.

U kunt het adres (&x) uit de array halen, en dit zal een echte verwijzing zijn naar de plaats waar deze array zich bevindt. Het type van de expressie &x zal, zoals gemakkelijk te begrijpen is, int (*TYPE) zijn. Aan het begin van de array bevindt zich het nulelement, dus het adres van de array zelf en het adres van het nulelement zijn numeriek hetzelfde. Dat wil zeggen, &x en &(x) zijn numeriek gelijk (hier heb ik de beroemde uitdrukking &(x) geschreven, sterker nog, niet alles is er zo eenvoudig in, we komen hier later op terug). Maar deze expressies hebben verschillende typen - int (*TYPE) en int *TYPE , dus vergelijken met == zal niet werken. Maar je kunt de void *-truc gebruiken: de volgende expressie zal waar zijn: (void *)&x == (void *)&(x) .

Oké, laten we aannemen dat ik je ervan heb overtuigd dat een array slechts een array is en niet iets anders. Dus waar komt al deze verwarring tussen pointers en arrays vandaan? Feit is dat de naam van de array bij vrijwel elke bewerking wordt omgezet in een verwijzing naar het nulelement.

Dus hebben we int x gedeclareerd. Als we nu x + 0 schrijven, dan converteert dit onze x (die van het type int TYPE was, of preciezer gezegd int (&TYPE)) naar &(x), d.w.z. een verwijzing naar het nulelement van de array x. Nu is onze x van het type int *TYPE .

Het converteren van een arraynaam naar void * of het toepassen van == erop, converteert die naam ook vooraf naar een pointer naar het eerste element, dus:
&x == x // compilatiefout, verschillende typen: int (*TYPE) en int *TYPE (void *)&x == (void *)x // true x == x + 0 // true x == &( x) // waar

Operatie. De notatie a[b] is altijd gelijk aan *(a + b) (ik wil u eraan herinneren dat we niet overwegen de operator en andere bewerkingen opnieuw te definiëren). De notatie x betekent dus het volgende:

• x is gelijk aan *(x + 2)
• x + 2 verwijst naar die bewerkingen die de naam van een array converteren naar een verwijzing naar het eerste element, dus dit gebeurt
• Vervolgens is, volgens mijn uitleg hierboven, x + 2 gelijk aan (int *)((char *)x + 2 * sizeof (int)) , d.w.z. x + 2 betekent "verschuif de aanwijzer x met twee ints"
• Ten slotte wordt een dereferentiebewerking uit het resultaat gehaald en halen we het object op dat zich op deze verschoven aanwijzer bevindt

De typen deelnemende expressies zijn als volgt:
x // int (&TYPE), na typeconversie: int *TYPE x + 2 // int *TYPE *(x + 2) // int &TYPE x // int &TYPE

Ik merk ook op dat er geen array links van de vierkante haakjes hoeft te staan; daar kan een aanwijzer staan. U kunt bijvoorbeeld (x + 2) schrijven en dit is gelijk aan x. Ik zal ook opmerken dat *a en a altijd equivalent zijn, zowel in het geval dat a een array is als wanneer a een pointer is.

Zoals ik beloofd heb, ga ik nu terug naar &(x) . Het is nu duidelijk dat in deze expressie eerst x wordt geconverteerd naar een pointer, vervolgens het bovenstaande algoritme wordt toegepast op deze pointer, resulterend in een waarde van het type int &TYPE , en ten slotte met behulp van & wordt geconverteerd naar het type int *TYPE . Daarom was het een beetje valsspelen om deze complexe uitdrukking (waarbinnen al een conversie van array naar pointer wordt uitgevoerd) te gebruiken om het iets eenvoudigere concept van conversie van array naar pointer uit te leggen.

En nu de laatste vraag: wat is &x + 1? Welnu, &x is een verwijzing naar de hele array, + 1 resulteert in een stap naar de hele array. Dat wil zeggen, &x + 1 is (int (*))((char *)&x + sizeof (int )), dat wil zeggen, (int (*))((char *)&x + 5 * sizeof (int )) ( hier is int (*) int (*TYPE)). Dus &x + 1 is numeriek gelijk aan x + 5, en niet x + 1 zoals je zou denken. Ja, uiteindelijk wijzen we naar geheugen dat zich buiten de array bevindt (direct na het laatste element), maar wat maakt het uit? In C is er immers nog steeds geen controle op het overschrijden van de grenzen van een array. Merk ook op dat de uitdrukking *(&x + 1) == x + 5 waar is. Je kunt het ook zo schrijven: (&x) == x + 5 . Het zal ook waar zijn *((&x)) == x , of, wat hetzelfde is, (&x) == x (tenzij we natuurlijk een segmentatiefout tegenkomen bij het proberen toegang te krijgen tot de limieten van ons geheugen: )).

Een array kan niet als argument aan een functie worden doorgegeven. Als u int x of int x in de functiekop schrijft, is dit equivalent aan int *x en wordt er altijd een pointer doorgegeven aan de functie (de sizeof van de doorgegeven variabele zal dezelfde zijn als die van de pointer). In dit geval wordt de arraygrootte die in de header is opgegeven, genegeerd. U kunt eenvoudig int x in de header opgeven en daar een array met lengte 3 doorgeven.

In C++ is er echter een manier om een ​​arrayverwijzing naar een functie door te geven:
void f (int (&x)) ( // sizeof (x) hier is 5 * sizeof (int) ) int main (void) ( int x; f (x); // OK f (x + 0); // Kan niet int y; f (y); // Kan niet, verkeerde maat)
Bij een dergelijke overdracht geeft u nog steeds alleen een link door en geen array, d.w.z. de array wordt niet gekopieerd. Maar je krijgt nog steeds een paar verschillen vergeleken met het normale doorgeven van aanwijzers. Er wordt een verwijzing naar de array doorgegeven. U kunt in plaats daarvan geen aanwijzer doorgeven. U moet precies de array van de opgegeven grootte doorgeven. Binnen de functie zal een verwijzing naar een array zich precies hetzelfde gedragen als een verwijzing naar een array, het zal bijvoorbeeld de grootte hebben van een array.

En het meest interessante is dat deze overdracht als volgt kan worden gebruikt:
// Bereken de lengte van de sjabloonarray size_t len ​​(t (&a)[n]) ( return n; )
De std::end-functie in C++11 voor arrays wordt op een vergelijkbare manier geïmplementeerd.

"Aanwijzer naar array". Strikt genomen is een "pointer naar een array" slechts een pointer naar een array en niets anders. Met andere woorden:
int(*a); // Dit is een verwijzing naar een array. De meest echte. Het is van het type int (*TYPE) int b; int *c = b; // Dit is geen verwijzing naar een array. Het is slechts een aanwijzer. Wijzer naar het eerste element van een array int *d = new int; // En dit is geen verwijzing naar een array. Dit is een aanwijzer
Soms betekent de uitdrukking "pointer naar een array" echter informeel een pointer naar het geheugengebied waarin de array zich bevindt, zelfs als het type pointer niet geschikt is. Volgens dit informele begrip zijn c en d (en b + 0) verwijzingen naar arrays.

Multidimensionale arrays. Als int x wordt gedeclareerd, dan is x geen array met lengte 5 van enkele wijzers die ergens ver weg wijzen. Nee, x is nu een enkel monolithisch blok van 5 x 7 dat op een stapel is geplaatst. sizeof(x) is gelijk aan 5 * 7 * sizeof(int) . De elementen zijn als volgt in het geheugen gerangschikt: x, x, x, x, x, x, x, x enzovoort. Wanneer we x schrijven, ontwikkelen gebeurtenissen zich als volgt:
x // int (&TYPE), na conversie: int (*TYPE) x // int (&TYPE), na conversie: int *TYPE x // int &TYPE
Hetzelfde geldt voor **x. Merk op dat in de uitdrukkingen, bijvoorbeeld x + 3 en **x + 3, het ophalen van het geheugen in werkelijkheid slechts één keer plaatsvindt (ondanks de aanwezigheid van twee sterretjes), op het moment dat de uiteindelijke referentie van het type int &TYPE eenvoudigweg naar int wordt geconverteerd. TYPE. Dat wil zeggen, als we zouden kijken naar de assemblagecode die wordt gegenereerd op basis van de uitdrukking **x + 3, zouden we daarin zien dat de bewerking van het ophalen van gegevens uit het geheugen daar slechts één keer wordt uitgevoerd. **x + 3 kan ook anders geschreven worden als *(int *)x + 3 .

Laten we nu eens naar deze situatie kijken:
int **y = nieuwe int *; for (int i = 0; i != 5; ++i) ( y[i] = nieuwe int; )

Wat is j nu? y is een pointer naar een array (in de informele zin!) van pointers naar arrays (opnieuw in de informele zin). Nergens verschijnt hier een enkel blok van maat 5 x 7, er zijn 5 blokken van maat 7 * sizeof (int) die ver uit elkaar kunnen liggen. Wat is jij?
y // int **&TYPE y // int *&TYPE y // int &TYPE
Als we nu y + 3 schrijven, gebeurt het ophalen van het geheugen twee keer: een ophaalactie uit de y-array, en een daaropvolgende ophaalactie uit de y-array, die ver weg kan zijn van de y-array. De reden hiervoor is dat er geen conversie van de arraynaam naar een verwijzing naar het eerste element plaatsvindt, in tegenstelling tot het multidimensionale array x-voorbeeld. Daarom is **y + 3 hier niet gelijk aan *(int *)y + 3 .

Ik zal het nog een keer uitleggen. x is gelijk aan *(*(x + 2) + 3) . En y is gelijk aan *(*(y + 2) + 3) . Maar in het eerste geval is het onze taak om het “derde element in de tweede rij” te vinden in een enkel blok van maat 5 x 7 (uiteraard zijn de elementen genummerd vanaf nul, dus dit derde element zal in zekere zin het vierde :)). De compiler berekent dat het gewenste element daadwerkelijk op de 2 * 7 + 3e plaats in dit blok staat en extraheert dit. Dat wil zeggen, x is hier gelijk aan ((int *)x) , of, wat hetzelfde is, *((int *)x + 2 * 7 + 3) . In het tweede geval haalt het eerst het tweede element in de y-array op, en vervolgens het derde element in de resulterende array.

In het eerste geval, als we x + 2 doen, verschuiven we onmiddellijk met 2 * sizeof (int ) , d.w.z. met 2 * 7 * sizeof (int) . In het tweede geval is y + 2 een verschuiving met 2 * sizeof (int *) .

In het eerste geval zijn (void *)x en (void *)*x (en (void *)&x !) dezelfde pointer, in het tweede geval niet.

Een array is een gegevensstructuur die wordt weergegeven als een groep cellen van hetzelfde type, verenigd onder één enkele naam. Arrays worden gebruikt om grote hoeveelheden gegevens van hetzelfde type te verwerken. De naam van de array is wat pointers zijn, ik zal het je later vertellen. Een individuele datacel van een array wordt een array-element genoemd. De elementen van een array kunnen gegevens van elk type zijn. Arrays kunnen één of meer dan één dimensie hebben. Afhankelijk van het aantal dimensies worden arrays onderverdeeld in eendimensionale arrays, tweedimensionale arrays, driedimensionale arrays, enzovoort, tot een n-dimensionale array. Eendimensionale en tweedimensionale arrays worden het vaakst gebruikt bij het programmeren, dus we zullen alleen deze arrays beschouwen.

Eendimensionale arrays in C++

Eendimensionale array is een array met één parameter die het aantal elementen van de eendimensionale array karakteriseert. In feite is een eendimensionale array een array die slechts één rij en n aantal kolommen kan hebben. De kolommen in een eendimensionale array zijn de elementen van de array. Figuur 1 toont de structuur van een eendimensionale array met gehele getallen A. De grootte van deze array is 16 cellen.

Figuur 1 - Arrays in C++

Merk op dat de maximale index van een eendimensionale array A is 15, maar de grootte van de array is 16 cellen, omdat de nummering van arraycellen altijd begint bij 0. De celindex is een niet-negatief geheel getal waarmee u toegang kunt krijgen tot elke cel van de array en er acties op kunt uitvoeren ( de cel).

//syntaxis voor het declareren van een eendimensionale array in C++: /*datatype*/ /*naam van een eendimensionale array*/; //een voorbeeld van het declareren van een eendimensionale array, weergegeven in figuur 1: int a;

waarbij int een geheel getal is;

A is de naam van een eendimensionale array;
16 is de grootte van een eendimensionale array, 16 cellen.

Altijd direct na de naam van de array staan ​​vierkante haakjes waarin de grootte van de eendimensionale array wordt gespecificeerd; dit is wat de array onderscheidt van alle andere variabelen.

//een andere manier om eendimensionale arrays te declareren int mas, a;

Er worden twee eendimensionale arrays mas en a gedeclareerd met respectievelijk de maten 10 en 16. Bovendien zullen bij deze declaratiemethode alle arrays hetzelfde gegevenstype hebben, in ons geval - int.

// arrays kunnen worden geïnitialiseerd wanneer ze worden gedeclareerd: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // initialisatie van een eendimensionale array

Initialisatie van een eendimensionale array wordt uitgevoerd tussen accolades na het teken gelijk aan, wordt elk array-element gescheiden van het vorige door een komma.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // initialiseren van de array zonder de grootte ervan te bepalen.

In dit geval bepaalt de compiler zelf de grootte van de eendimensionale array. De grootte van een array kan alleen worden weggelaten bij het initialiseren ervan; bij het normaal declareren van een array moet de grootte van de array worden opgegeven. Laten we een eenvoudig programma ontwikkelen om een ​​eendimensionale array te verwerken.

// array.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// code Code::Blokken

// Dev-C++-code

// array.cpp: definieert het toegangspunt voor de consoletoepassing. #erbij betrekken naamruimte std gebruiken; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

IN lijnen 10 - 11 Er is een eendimensionale array met gehele getallen met de naam array1 gedeclareerd en geïnitialiseerd, waarvan de grootte 16 cellen is, dat wil zeggen dat een dergelijke array 16 getallen kan opslaan. Elke arrayverwerking is alleen mogelijk in combinatie met lussen. Welke lus u moet kiezen voor het verwerken van de array, is aan u om te beslissen. Maar het is het meest geschikt voor deze taak. We zullen de tellervariabeleteller gebruiken om toegang te krijgen tot de elementen van de eendimensionale array array1. De voortzettingsvoorwaarde van de for-lus bevat een strikt ongelijkheidsteken, aangezien er geen zestiende index bestaat in de eendimensionale array array1. En aangezien de nummering van cellen vanaf nul begint, zijn er 16 elementen in de array. In de hoofdtekst van de for-lus drukt de cout-operator de elementen van een eendimensionale array af (zie figuur 2).

Obrabotka massiva indexeert element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Druk op een willekeurige toets om door te gaan. . .

Figuur 2 - Arrays in C++

Laten we een ander programma ontwikkelen voor het verwerken van een eendimensionale array in C++. Het programma moet achtereenvolgens tien ingevoerde cijfers van het toetsenbord lezen. Alle ingevoerde getallen worden opgeteld en het resultaat wordt op het scherm weergegeven.

// array_sum.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// code Code::Blokken

// Dev-C++-code

// array_sum.cpp: Definieert het toegangspunt voor de consoletoepassing. #erbij betrekken naamruimte std gebruiken; int main(int argc, char* argv) ( int array1; // declareer een integer-array cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>array1; // lees cijfers die zijn ingevoerd via het toetsenbord<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Voordat een array wordt verwerkt, moet deze worden gedeclareerd, en de grootte van een eendimensionale array is 10, aangezien dit wordt bepaald door de voorwaarde van de taak. In de somvariabele accumuleren we de som van de elementen van een eendimensionale array. De eerste for-lus vult de gedeclareerde eendimensionale array met getallen die via het toetsenbord zijn ingevoerd, lijnen 12 - 13. De countervariabele wordt gebruikt om sequentieel toegang te krijgen tot de elementen van de eendimensionale array array1 , beginnend bij index 0 en tot en met de 9e. De tweede for-lus geeft de elementen van de array weer, regels 15 - 16. De derde for-lus leest opeenvolgend de elementen van een eendimensionale array en somt deze op, de som wordt geaccumuleerd in de somvariabele. regels 17 - 18. Het resultaat van het programma wordt getoond in Figuur 3.

Voer elementi massiva in: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) som = 45 Druk op een willekeurige toets om door te gaan. . .

Figuur 3 - Arrays in C++

Eerst werden alle 10 getallen opeenvolgend ingevoerd, waarna een eendimensionale array werd weergegeven en de som van de getallen in de array werd afgedrukt.

Tweedimensionale arrays in C++

Tot nu toe hebben we eendimensionale arrays overwogen, die niet altijd daartoe beperkt kunnen worden. Stel dat u bepaalde gegevens uit een tabel moet verwerken. Een tabel heeft twee kenmerken: het aantal rijen en het aantal kolommen. Ook in een tweedimensionale array zijn er, naast het aantal array-elementen, kenmerken als het aantal rijen en het aantal kolommen van een tweedimensionale array. Dat wil zeggen, visueel gezien is een tweedimensionale array een gewone tabel, met rijen en kolommen. In feite is een tweedimensionale array een eendimensionale array van eendimensionale arrays. De structuur van een tweedimensionale array, genaamd a, met de afmetingen m bij n wordt hieronder weergegeven (zie figuur 4).

Figuur 4 - Arrays in C++

waarbij m het aantal rijen van een tweedimensionale array is;
n is het aantal kolommen van een tweedimensionale array;
m * n — aantal array-elementen.

// syntaxis voor het declareren van een tweedimensionale array /*datatype*/ /*arraynaam*/;

Bij het declareren van een tweedimensionale array, maar ook bij het declareren van een eendimensionale array, moet u allereerst het volgende specificeren:

• gegevenstype;
• arraynaam.

Daarna geven de eerste vierkante haken het aantal rijen van de tweedimensionale array aan, en geven de tweede vierkante haken het aantal kolommen van de tweedimensionale array aan. Een tweedimensionale array wordt visueel onderscheiden van een eendimensionale array door een tweede paar vierkante haken. Laten we eens kijken naar een voorbeeld van het declareren van een tweedimensionale array. Laten we zeggen dat we een tweedimensionale array moeten declareren met een aantal elementen gelijk aan 15. In dit geval kan een tweedimensionale array drie rijen en vijf kolommen hebben, of vijf rijen en drie kolommen.

// voorbeelddeclaratie van een tweedimensionale array: int a;

• a is de naam van de integer-array
• het getal tussen de eerste vierkante haken geeft het aantal rijen van de tweedimensionale array aan, in dit geval zijn het er 5;
• het getal tussen de tweede vierkante haakjes geeft het aantal kolommen van de tweedimensionale array aan, in dit geval zijn het er 3.

// initialisatie van een tweedimensionale array: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1));

Deze array heeft 5 rijen en 3 kolommen. na het toewijzingsteken worden algemene accolades geplaatst, waarbinnen zoveel paren accolades worden geplaatst als er lijnen in een tweedimensionale array zouden moeten zijn, en deze accolades worden gescheiden door komma's. Schrijf in elk paar accolades de elementen van een tweedimensionale array, gescheiden door komma's. Bij alle accolades moet het aantal elementen hetzelfde zijn. Omdat er vijf lijnen in de array staan, zijn er ook vijf binnenste paren haakjes. Tussen de binnenste haakjes staan ​​drie elementen, aangezien het aantal kolommen drie is. Grafisch ziet onze array eruit als een tweedimensionale tabel (zie figuur 5).

Figuur 5 - Arrays in C++

In elke cel van een tweedimensionale array A de waarde wordt weergegeven, het adres van deze cel wordt weergegeven in de rechter benedenhoek. Het celadres van een tweedimensionale array is de arraynaam, het rijnummer en het kolomnummer.

Laten we een eenvoudig programma ontwikkelen voor het verwerken van een tweedimensionale array, genaamd "Labyrinth". Het labyrint moet worden gebouwd op basis van een tweedimensionale array. We zullen naar eigen goeddunken de grootte van het labyrint kiezen.

// array2.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castuit<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// code Code::Blokken

// Dev-C++-code

(176); naamruimte std gebruiken; int main(int argc, char* argv) ( // 1-voorwaardelijk “muren van het doolhof” // 2-“juist pad, uitgang uit het doolhof” // 0-“vals pad” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // initialisatie van een tweedimensionale array ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,)); // twee lussen - intern en extern, die toegang krijgen tot elk element van de array voor (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castuit<< " "; // вывести два пробела cout << endl; } return 0; }

De juiste en valse paden kunnen worden aangegeven met hetzelfde nummer, bijvoorbeeld nul, maar voor de duidelijkheid wordt het juiste pad aangegeven met het cijfer 2. De array is handmatig geïnitialiseerd, alleen om het programma te vereenvoudigen. Omdat het programma een tweedimensionale array verwerkt, zijn er twee lussen nodig om tussen elementen van de tweedimensionale array te schakelen. De eerste for-lus schakelt tussen rijen van een tweedimensionale array. Omdat er 33 rijen in een tweedimensionale array zijn, wordt de tellervariabele i verhoogd van 0 naar 33, lijn 46. Binnen de eerste lus bevindt zich een for-lus die door de rijelementen van een tweedimensionale array loopt. In de hoofdtekst van de tweede for-lus wordt een conversiebewerking voor unaire gegevenstypen uitgevoerd binnen - static_cast<>() , waarmee tekennummer 176 wordt afgedrukt. De conversiebewerking van het gegevenstype wordt gedupliceerd om de breedte van het doolhof te vergroten. Het resultaat van het programma (zie figuur 6).

Figuur 6 - Arrays in C++