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 element van de array 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(zweven) = 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 tekenreeksverwerkingsfuncties, 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;
}

Arrays

Array is een verzameling variabelen van hetzelfde type met een gemeenschappelijke naam om ernaar te verwijzen. In C# kunnen arrays eendimensionaal of multidimensionaal zijn. Arrays dienen verschillende doeleinden omdat ze een handige manier bieden om variabelen die gerelateerd zijn, te groeperen.

U kunt arrays in C# op vrijwel dezelfde manier gebruiken als in andere programmeertalen. Ze hebben echter één bijzonderheid: ze worden geïmplementeerd als objecten.

Het gebruik van een array in een programma vereist een procedure van twee stappen, omdat C# arrays als objecten implementeert. Eerst moet u een variabele declareren die toegang heeft tot de array. En ten tweede moet u een exemplaar van de array maken met behulp van de nieuwe operator.

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( static void Main(string args) ( // Declareer een array int myArr = new int; // Initialiseer elk element van de array handmatig myArr = 100; myArr = 23; myArr = 25; myArr = 31; mijnArr = 1; foreach (int i in mijnArr) Console.WriteLine(i);

Houd er rekening mee dat als een array zojuist is gedeclareerd maar niet expliciet is geïnitialiseerd, elk element wordt ingesteld op de standaardwaarde voor het overeenkomstige gegevenstype (elementen van een array van het type bool worden bijvoorbeeld ingesteld op false en elementen van een array array van het type int wordt ingesteld op 0).

Een array initialiseren

Naast het vullen van de array element voor element (zoals weergegeven in het vorige voorbeeld), kunt u deze ook vullen met behulp van een speciale array-initialisatiesyntaxis. Om dit te doen, moet u de elementen in de array tussen accolades ( ) vermelden. Deze syntaxis is handig bij het maken van een array met een bekende grootte en als u snel de beginwaarden ervan moet instellen:

// Syntaxis voor het initialiseren van een array met // het sleutelwoord new int myArr = new int (10,20,30,40,50); // Syntaxis voor het initialiseren van een array zonder gebruik te maken van // een trefwoord new string info = ( "Achternaam", "Voornaam", "Patroniem" ); // Gebruik het nieuwe trefwoord en het gewenste formaat char-symbool = new char ( "X", "Y", "Z", "M" );

Houd er rekening mee dat wanneer u de accolade-syntaxis gebruikt, u de grootte van de array niet hoeft op te geven (zoals u kunt zien bij het maken van de myArr-variabele), omdat de grootte automatisch wordt berekend op basis van het aantal elementen binnen de accolades. Gebruik ook het trefwoord nieuw optioneel (zoals bij het maken van een info-array).

Met het trefwoord var kunt u een variabele definiëren, zodat het onderliggende type door de compiler wordt afgeleid. U kunt ook impliciet getypeerde lokale arrays op een vergelijkbare manier definiëren. Met deze aanpak kunt u een nieuwe arrayvariabele definiëren zonder het type elementen in de array op te geven. Laten we eens kijken naar een voorbeeld:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 ); Console.WriteLine("Arraytype arr1 is (0)",arr1.GetType()); var arr2 = new ("Eén", "Twee", "Drie" ); Console.WriteLine("Arraytype arr2 - (0)",arr2.GetType());

Natuurlijk moeten, net als bij het maken van een array met behulp van de expliciete C#-syntaxis, de elementen die zijn opgegeven in de array-initialisatielijst van hetzelfde onderliggende type zijn (dat wil zeggen dat ze allemaal int, string of MyCar moeten zijn).

Een array van objecten definiëren

In de meeste gevallen wordt bij het definiëren van een array het type element in de array expliciet gespecificeerd. Hoewel dit op het eerste gezicht vrij eenvoudig lijkt, is er één belangrijk kenmerk. De kern van elk type in het .NET-typesysteem (inclusief fundamentele gegevenstypen) is uiteindelijk een basisklasse, System.Object. Het resultaat is dat als u een reeks objecten definieert, de elementen daarin van alles kunnen zijn:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( static void Main(string args) ( // Declareer en initialiseer een array van objecten object arrByObject = ( true, 10, "Hallo", 13.7m ); // Druk het type van elk arraylid af naar de console foreach (objecteer mij in arrByObject) Console.WriteLine("Type (0) - (1)",me,me.GetType());

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, zoals 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?

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

Met arrays kunt u grote hoeveelheden gegevens in een handig formaat opslaan. 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. Voor poker moet u bijvoorbeeld een set van vijf speelkaarten delen. U kunt deze kaarten in een array opslaan en alleen het indexnummer wijzigen om een ​​nieuwe kaart te selecteren, 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. Houd er rekening mee dat de arraygrootte tussen vierkante haakjes achter de arraynaam staat.

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];

Je kunt dit proces als volgt visualiseren:

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 een schaakbord of een boter-kaas-en-eierenbord. 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 afbeelding toont de benodigde 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 op te slaan in een 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 opgegeven arrays declareren , omdat De compiler moet weten hoeveel geheugen hij moet toewijzen. Wanneer we naar een functie gaan, 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:

Int findSmallestRemainingElement(int array, int size, int index) ( int index_of_smallest_value = index; for (int i = index + 1; i

Ten slotte moeten we de swap-functie implementeren. Omdat de functie de originele array zal wijzigen, hoeven we alleen maar de waarden om te wisselen met behulp van een tijdelijke variabele:

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

Om het algoritme te testen, vult u de array met willekeurige getallen en sorteert u deze. Alle programmacode: 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 Het sorteeralgoritme waar we zojuist naar hebben gekeken heet

Een ander type C#-array zijn arrays van arrays, ook wel gekartelde arrays genoemd. Zo'n array van arrays kan worden gezien als een eendimensionale array waarvan de elementen arrays zijn, waarvan de elementen op hun beurt weer arrays kunnen zijn, enzovoort tot op een bepaald niveau van nesten.

In welke situaties zou de behoefte aan dergelijke datastructuren kunnen ontstaan? Deze arrays kunnen worden gebruikt om bomen weer te geven waarin knooppunten een willekeurig aantal kinderen kunnen hebben. Dit kan bijvoorbeeld een stamboom zijn. Pieken van het eerste niveau - Vaders, die vaders vertegenwoordigt, kan worden gegeven door een eendimensionale array, zodat Vaders[ i] - Dit i e vader. De hoekpunten van het tweede niveau worden weergegeven door een reeks arrays - Kinderen, Dus Kinderen[ i] - dit is een reeks kinderen i-de vader, en Kinderen[ i][ J] - dit is het jde kind i e vader. Om kleinkinderen te vertegenwoordigen heb je een derde niveau nodig, dus Kleinkinderen[ i][ J][ k] zal vertegenwoordigen Naar e kleinzoon J e kind i e vader.

Er zijn enkele eigenaardigheden bij het declareren en initialiseren van dergelijke arrays. Als bij het declareren van het type multidimensionale arrays komma's werden gebruikt om de dimensie aan te geven, dan wordt voor gekartelde arrays een duidelijkere symboliek gebruikt: een reeks paren vierkante haakjes; Bijvoorbeeld, int[ ] specificeert een array waarvan de elementen eendimensionale arrays van elementen van het type zijn int.

Het is moeilijker om de arrays zelf te maken en te initialiseren. Je kunt de constructeur hier niet bellen nieuwint, omdat het geen gekartelde array specificeert. In feite moet u de constructor voor elke array op het laagste niveau aanroepen. Dit is de moeilijkheid van het declareren van dergelijke arrays. Laten we beginnen met een formeel voorbeeld:

//array van arrays - formeel voorbeeld
//declaratie en initialisatie
int[ ] jagger= nieuwint[ ] {
nieuwe int[] {5, 7, 9, 11},
nieuwe int[] {2, 8},
nieuwe int[] {6, 12, 4}
};

Array jagger heeft slechts twee niveaus. We kunnen het zien als drie elementen, die elk een array zijn. Voor elke dergelijke array moet u de constructor aanroepen nieuw, om een ​​interne array te maken. In dit voorbeeld krijgen de elementen van de interne arrays hun waarde doordat ze expliciet worden geïnitialiseerd als constante arrays. Uiteraard is de volgende verklaring ook aanvaardbaar:

int[ ] jagger1 = nieuwint[ ] {
nieuwint,
nieuwint,
nieuwint
};

In dit geval ontvangen de array-elementen tijdens de initialisatie nulwaarden. De daadwerkelijke initialisatie moet programmatisch worden uitgevoerd. Het is vermeldenswaard dat in de constructor op het hoogste niveau de constante 3 je kunt het weglaten en gewoon schrijven nieuwint[ ] . De aanroep van deze constructor kan helemaal worden weggelaten - dit wordt geïmpliceerd:

int[ ] jagger2 = {
nieuwe int,
nieuwe int,
nieuwe int
};

Maar constructeurs op een lager niveau zijn noodzakelijk. Nog een belangrijke opmerking: dynamische arrays zijn hier ook mogelijk. Over het algemeen kunnen grenzen op elk niveau uitdrukkingen zijn die afhankelijk zijn van variabelen. Bovendien is het toegestaan ​​dat arrays op het lagere niveau multidimensionaal zijn.