Statische array: declaratie, vulling, gebruik. VBA-lussen - Voor Volgende en Voor Elk in Excel

Herhaalt een groep uitspraken over elk element van de verzameling.

Voor elk element [ As datatype ] In groep [ uitspraken ] [ Doorgaan voor ] [ uitspraken ] [ Exit For ] [ uitspraken ] Volgende [ element ]

Onderdelen

Eenvoudig voorbeeld

De For Each...Next-lus wordt gebruikt wanneer u een reeks instructies moet herhalen voor elk element van een verzameling of array.

Geneste lussen

For Each-lussen kunnen in elkaar worden genest.

In het volgende voorbeeld worden geneste For Each...Next-structuren gedemonstreerd.

"Maak lijsten met cijfers en letters" met behulp van array-initializers. Dim getallen() As Integer = (1, 4, 7) Dim letters() As String = ("a", "b", "c") " Doorloop de lijst met geneste lussen. Voor elk getal As Integer In cijfers Voor elke letter Als tekenreeks In letters Debug.Write(number.ToString & letter & " ") Volgende Volgende Debug.WriteLine("") "Uitvoer: 1a 1b 1c 4a 4b 4c 7a 7b 7c

Bij het plaatsen van lussen moet elke lus dat hebben unieke naam variabel element.

Je kunt ook elkaar nestelen verschillende soorten managementstructuren. Om te ontvangen aanvullende informatie zie Geneste besturingsstructuren (Visual Basic).

Vertrek naar; Voor

Het volgende voorbeeld laat zien hoe u dit kunt gebruiken Ga door met uitspraken Voor en Afsluiten voor.

Dim getalSeq() As Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) Voor elk getal Als geheel getal In getalSeq "Als getal tussen 5 en 7 ligt, ga dan verder" met de volgende iteratie.<= 8 Then Continue For End If " Display the number. Debug.Write(number.ToString & " ") " If number is 10, exit the loop. If number = 10 Then Exit For End If Next Debug.WriteLine("") " Output: 1 2 3 4 9 10

Een willekeurig aantal Exit For-instructies kan in een For Each-lus worden geplaatst. Wanneer u geneste For Each-lussen gebruikt, zorgt de Exit For-instructie ervoor dat de binnenste lus wordt afgesloten en wordt de besturing doorgegeven aan het volgende nestniveau.

Exit For wordt vaak gebruikt nadat een bepaalde voorwaarde is geëvalueerd, zoals in een If...Then...Else-structuur. U kunt Exit For gebruiken onder de volgende voorwaarden:

Het is niet nodig of mogelijk om door te gaan met itereren. Dit kan worden veroorzaakt door een ongeldige waarde of een interruptverzoek.

De uitzondering wordt opgevangen in Try...Catch...Finally. Je kunt Exit For gebruiken aan het einde van het blok Eindelijk.

Er is een oneindige lus, dat wil zeggen een lus die een groot of zelfs een oneindig aantal keren kan worden uitgevoerd. Als dergelijke omstandigheden zich voordoen, kunt u Exit For gebruiken om de lus te verlaten. Zie Do...Loop-instructie (Visual Basic) voor meer informatie.

Iteratoren

Gebruikt een iterator om aangepaste iteratie over een verzameling uit te voeren. Een iterator kan een functie of een Get-toegang zijn. Het gebruikt de operator Opbrengst om elk element van de verzameling één voor één op te halen.

U moet de extractiterator aanroepen met For Each...Next. Elke iteratie van de For Each-lus roept een iterator aan. Wanneer de Yield-instructie in de iterator wordt bereikt, wordt de expressie in de Yield-instructie geretourneerd en blijft de huidige locatie in de code behouden. De volgende keer dat de iterator wordt aangeroepen, wordt de uitvoering vanaf dat punt hervat.

In het volgende voorbeeld wordt de iteratorfunctie gebruikt. De iteratorfunctie heeft een Yield-instructie, binnen een For...Next-lus. In de ListEvenNumbers-methode creëert For Each voor elke iteratie van de hoofdtekst van de instructie een aanroep naar de iteratorfunctie, die naar de volgende Yield-instructie gaat.

Public Sub ListEvenNumbers() Voor elk getal als geheel getal in EvenSequence(5, 18) Debug.Write(number & " ") Next Debug.WriteLine("") " Uitvoer: 6 8 10 12 14 16 18 End Sub Private Iterator-functie EvenSequence (ByVal firstNumber als geheel getal, ByVal lastNumber als geheel getal) _ As System.Collections.Generic.IEnumerable(Of Integer) " Levert even getallen in het bereik op.

Voor getal = eersteGetal Naar laatsteGetal Als getal Mod 2 = 0 Dan Geef getal Einde Als Volgende Eindfunctie

Zie Iterators (C# en Visual Basic), Yield-operator (Visual Basic) en Iterator (Visual Basic) voor meer informatie.

Technische implementatie Wanneer de For Each...Next-instructie wordt uitgevoerd, Visuele basis

Wanneer alle elementen in de verzameling zijn toegewezen aan de elementvariabele, stopt de For Each-lus en wordt de controle overgedragen naar de instructie die volgt op de Next-instructie.

Als het element niet buiten deze lus is gedeclareerd, moet u het in een For Each-instructie declareren. U kunt het elementtype expliciet declareren met de operator As, of u kunt een typedefinitie gebruiken om het type toe te wijzen. In dit geval is de reikwijdte van het element het belangrijkste deel van de lus. Tegelijkertijd kunt u geen elementen zowel binnen als buiten de lus definiëren.

U kunt optioneel een element opgeven in de Next-instructie. Dit verbetert de leesbaarheid van het programma, vooral als het For Each-lussen heeft genest. In dit geval moet u dezelfde variabele opgeven als in de overeenkomstige For Each-instructie.

U kunt voorkomen dat de waarde van het element binnen de lus wordt gewijzigd. Dit kan ervoor zorgen dat de code moeilijker te lezen en te debuggen is. Het wijzigen van de groepswaarde heeft geen invloed op de verzameling of elementen die zijn gedefinieerd toen de lus voor het eerst werd betreden.

Als er nestinglussen optreden en de Next-extractie van het buitenste nestingniveau wordt gedetecteerd vóór de Next van het binnenste niveau, signaleert de compiler een fout. De compiler kan deze fout echter alleen detecteren als er een element is opgegeven in elke Next-instructie.

Als uw code afhankelijk is van het verplaatsen van een verzameling in een specifieke volgorde, is een For Each...Next-lus geen aanbevolen optie, tenzij u moet weten welke kenmerken het enumerator-object van de verzameling biedt. De verplaatsingsvolgorde wordt niet bepaald door Visual Basic, maar door de enumerator-objectmethode. Dit betekent dat de gebruiker niet kan specificeren welk element eerst naar het element moet worden geschreven, of welk element op een element moet volgen. Het gebruik van een andere lusstructuur, zoals For...Next of Do...Loop, kan betrouwbaardere resultaten opleveren.

Het datatype van een element moet zodanig zijn dat het datatype van de elementen in de groep ernaar kan worden geconverteerd.

Het groepsgegevenstype moet een referentietype zijn dat verwijst naar een verzameling of array die opsombaar is. Meestal betekent dit dat groep verwijst naar een object dat een interface vanuit de naamruimte implementeert Systeemcollecties of interface vanuit naamruimte Systeem.Collecties.Generiek. System.Collections.IEnumerabel specificeert een methode die een enumeratorobject voor de verzameling retourneert. Het enumeratorobject implementeert de interface System.Collections.IEnumerator naamruimten Systeemcollecties, en heeft ook eigenschappen , methoden en . Visual Basic gebruikt ze om door de collectie te navigeren.

Verkleinende transformaties

Als Option Strict Aan is, veroorzaakt de beperkende conversie doorgaans compilerfouten. In een For Each-instructie worden conversies van groeps- naar elementelementen echter tijdens runtime geëvalueerd en uitgevoerd, en kan de compilerfout die door de beperkende conversie wordt veroorzaakt, worden onderdrukt.

In het volgende voorbeeld wordt het toewijzen van m als de initiële waarde voor n niet gecompileerd onder Option Strict, omdat de conversie van lang naar geheel getal een beperkende conversie is. In de For Each-instructie wordt echter geen compilerfout gerapporteerd, ook al vereist de toewijzing aan nummer dezelfde conversie van Long naar Integer. In een For Each-instructie die een groot getal bevat, treedt er tijdens runtime een fout op wanneer .

Option Strict On Module Module1 Sub Main() " De toewijzing van m aan n veroorzaakt een compilerfout wanneer " Option Strict is ingeschakeld.

Dim m As Long = 987 "Dim n As Integer = m " De For Each-lus vereist dezelfde conversie, maar " veroorzaakt geen fouten, zelfs niet als Option Strict is ingeschakeld. For Each number As Integer In New Long() (45, 3, 987) Console.Write(number & " ") Volgende Console.WriteLine() " Uitvoer: 45 3 987 " Hier treedt een runtimefout op omdat 9876543210 " te groot is voor het type Integer.

"Voor elk getal als geheel getal in New Long() (45, 3, 9876543210) " Console.Write(number & " ") "Next Console.ReadKey() End Sub End Module Oproepen naar IEnumerator Aan het begin van de For Each...Next-lus controleert Visual Basic of er per groep naar een geldige verzameling objecten wordt verwezen. Als dit niet het geval is, wordt er een uitzondering gegenereerd. Anders worden de methode en de eigenschap van het enumeratorobject aangeroepen, waarbij het eerste element wordt geretourneerd. Als

VerplaatsVolgende Oproepen naar IEnumerator geeft aan dat er geen volgend element is, dat wil zeggen dat de verzameling leeg is, waarna de For Each-lus stopt en de controle wordt overgedragen naar de instructie die volgt op de Next-instructie. Anders stelt Visual Basic het element in op de waarde van het eerste element en voert het blok met instructies uit. Elke keer dat Visual Basic een Next-instructie tegenkomt, valt deze terug op de For Each-instructie. Opnieuw wordt de methode aangeroepen om het volgende element te verkrijgen en eigendom Oproepen naar IEnumerator Huidig

, en opnieuw, afhankelijk van het resultaat, wordt het blok uitgevoerd of wordt de lus gestopt. Dit proces gaat door tot de methode Retourneert een enumerator-object. U kunt de verzameling doorgaans niet wijzigen door alle elementen toe te voegen, te verwijderen en opnieuw te ordenen. Als de gebruiker de verzameling wijzigt na het uitvoeren van de For Each...Next-lus, wordt het enumerator-object ongeldig en veroorzaakt de volgende poging om toegang te krijgen tot een element van de verzameling een uitzondering.

Deze wijzigingsvergrendeling wordt echter niet gespecificeerd door Visual Basic, maar door de interface-implementatie. Kan worden geïmplementeerd IOntelbaar op een manier die het mogelijk maakt om de collectie tijdens iteratie te veranderen. Als het de bedoeling is om dergelijke dynamische veranderingen door te voeren, is het noodzakelijk om de aard van de implementatie te bepalen IOntelbaar de collectie die wordt gebruikt.

Wisselen van collectiestukken. De eigenschap van het opsommingsobject heeft de ReadOnly (Visual Basic)-modifier en retourneert een lokale kopie van elk element in de verzameling. Dit betekent dat je in een For Each...Next-lus de elementen zelf niet kunt wijzigen. Eventuele wijzigingen hebben alleen invloed op de lokale kopie van Elke keer dat Visual Basic een Next-instructie tegenkomt, valt deze terug op de For Each-instructie. Opnieuw wordt de methode aangeroepen om het volgende element te verkrijgen en achterkant komen niet terug in de basiscollectie. Als een element echter een referentietype is, kunt u de leden van de instantie waarnaar het verwijst, wijzigen. In het volgende voorbeeld wordt het BackColor-element van elk thisControl-element gewijzigd. De operator thisControl zelf kan echter niet worden gewijzigd.

Sub lightBlueBackground(ByVal thisForm As System.Windows.Forms.Form) Voor elke thisControl As System.Windows.Forms.Control In thisForm.Controls thisControl.BackColor = System.Drawing.Color.LightBlue Volgende thisControl End Sub

In het vorige voorbeeld kunt u het BackColor-lid van elk thisControl-element wijzigen, ook al kunt u thisControl zelf niet wijzigen.

Array-doorgang. Omdat de klasse de interface implementeert, hebben alle arrays een methode. Dit betekent dat u ook door arrays kunt itereren met behulp van de For Each...Next-lus. Array-elementen kunnen echter alleen worden gelezen. Dit kan niet worden gewijzigd.

Voorbeeld

In het volgende voorbeeld worden alle mappen in de map C:\ weergegeven met de extensie .

Dim dInfo As New System.IO.DirectoryInfo("c:\") Voor elke map As System.IO.DirectoryInfo In dInfo.GetDirectories() Debug.WriteLine(dir.Name) Volgende

In het volgende voorbeeld wordt de procedure voor het sorteren van een collectie gedemonstreerd. In het voorbeeld worden exemplaren van de klasse Car gesorteerd die is opgeslagen in . De klasse Car implementeert de interface, waarvoor een methode moet worden geïmplementeerd.

De For Each...Next-lus in VBA Excel, de syntaxis en beschrijving van afzonderlijke componenten. Voorbeelden van het gebruik van de For Each...Next-lus.

De For Each... Next-lus in VBA Excel is ontworpen om een ​​blok met instructies uit te voeren met betrekking tot elk element uit een groep elementen (bereik, array, verzameling). Deze prachtige lus wordt gebruikt als het aantal elementen in een groep en hun indexering onbekend zijn, anders verdient het de voorkeur om te gebruiken.

Voor elke...Volgende lus-syntaxis

De vierkante haakjes geven optionele attributen van de For Each...Next-lus aan.

Onderdelen van een For Each... Next Loop

*Als in VBA Excel een For Each...Next-lus wordt gebruikt om de elementen van een verzameling (verzamelingsobject) of array te doorlopen, dan wordt de variabele element moet worden gedeclareerd met een gegevenstype Variant, anders werkt de lus niet.

**Als u uw eigen code niet in een lus gebruikt, gaat de betekenis van het gebruik van een lus verloren.

Voorbeelden van For Each...Next-lussen

Loop over een bereik van cellen

Selecteer op het actieve blad van de Excel-werkmap een celbereik en voer de volgende procedure uit:

Sub test1() Dim element As Range, a As String a = "Gegevens verkregen door For Each... Next:" For Each element In Selection a = a & vbNewLine & "Cell " & element.Address & _ " bevat de waarde : " & CStr(element.Value) Volgende MsgBox een End Sub

Het MsgBox-informatievenster toont de adressen van de geselecteerde cellen en hun inhoud, indien aanwezig. Als er veel cellen zijn geselecteerd, wordt de volledige informatie over alle cellen niet weergegeven vanwege de maximale lengte van de parameter Snel bestaat uit ongeveer 1024 tekens.

Lus voor een verzameling vellen

Kopieer de volgende VBA-procedure naar Excel-werkmappen:

Sub test2() Dim element As Worksheet, a As String a = "Lijst met bladen in dit werkblad:" Voor elk element in werkbladen a = a & vbNewLine & element.Index _ & ") " & element.Name Next MsgBox a Einde sub

Het MsgBox-informatievenster toont een lijst met de namen van alle bladen in de Excel-werkmap, gerangschikt volgens het serienummer van hun labels die overeenkomen met hun indexen.

Lus voor een array

Laten we een lijst met dierennamen aan de array toewijzen en deze in een variabele in de For Each... Next-lus schrijven A. Het MsgBox-informatievenster toont een lijst met diernamen uit de variabele A.

Sub test3() Dim element As Variant, a As String, groep As Variant group = Array("nijlpaard", "olifant", "kangoeroe", "tijger", "muis") "of u kunt de waarden toewijzen van het cellenbereik van de "worker" naar het arrayblad, bijvoorbeeld geselecteerd: group = Selection a = "De array bevat de volgende waarden:" & vbNewLine For Each element In group a = a & vbNewLine & element Next MsgBox a Einde sub

Laten we dezelfde VBA-procedure herhalen, maar de waarde "Parrot" toewijzen aan alle elementen van de array in de For Each...Next-lus. Het MsgBox-informatievenster toont een lijst met dierennamen, die alleen uit papegaaien bestaan, wat bewijst dat het mogelijk is om de waarden van array-elementen in de For Each...Next-lus te bewerken.

Sub test4() Dim element As Variant, a As String, groep As Variant groep = Array("nijlpaard", "olifant", "kangoeroe", "tijger", "muis") "of u kunt de waarden toewijzen van het celbereik van de "worker" tot het arrayblad, bijvoorbeeld het geselecteerde: group = Selection a = "De array bevat de volgende waarden:" & vbNewLine For Each element In group element = "Parrot" a = a & vbNewLine & element Volgende MsgBox a End Sub

Deze code is, net als alle andere in dit artikel, getest in Excel 2016.

Loop door een verzameling submappen en verlaat de lus

In dit voorbeeld zullen we de variabele toevoegen A namen van submappen op de schijf C uw computer. Wanneer de lus de map bereikt Programmabestanden, het wordt toegevoegd aan de variabele A de titel en de boodschap: “Genoeg, ik lees niet verder! Met vriendelijke groet, uw For Each...Volgende cyclus."

Sub test5() Dim FSO As Object, myFolders As Object, myFolder As Object, a As String "Maak een nieuw FileSystemObject en wijs het toe aan de variabele "FSO" Set FSO = CreateObject("Scripting.FileSystemObject") "Haal de lijst op met submappen op station "C" " en wijs "het toe aan de variabele "myFolders" Set myFolders = FSO.GetFolder("C:\") a = "Mappen op station C:" & vbNewLine "We doorlopen de lijst met submappen en voeg hun namen toe aan de variabele "a". Nu we de map "Program Files" hebben bereikt, sluiten we de cyclus af. Voor elke myFolder In myFolders.SubFolders a = a & vbNewLine & myFolder.Name If myFolder.Name = "Program Files" Then a = a & vbNewLine & vbNewLine & "Dat is genoeg, lees verder, dat doe ik niet!" _ & vbNewLine & vbNewLine & "Groeten," & vbNewLine & _ "Je lus is voor elke... Volgende." FSO = Niets MsgBox a End Sub

Het MsgBox-informatievenster toont een lijst met submapnamen op de schijf C uw computer naar de map Programmabestanden inclusief en een bericht uit de cyclus over de beëindiging van zijn werkzaamheden.

Als gevolg van de werking van het programma worden niet alleen de namen van submappen weergegeven die zichtbaar zijn bij het navigeren naar de schijf in Verkenner C, maar ook verborgen mappen en servicemappen. Om een ​​lijst met alle submappen op een schijf te bekijken C, becommentarieer het codegedeelte van Als naar Einde Als inclusief en voer de procedure uit in de VBA Excel-editor.

De For Loop in VBA is een van de populairste loops in Excel. Deze cyclus heeft twee vormen: Voor Volgende En Voor elke volgende. Deze operatoren worden gebruikt om opeenvolgend door een lijst met elementen of getallen te bladeren. Om de lus te beëindigen, kunnen we op elk moment het exit-commando gebruiken. Laten we elk van deze cycli eens nader bekijken.

VBA voor volgende lus

De For Next-lus heeft de volgende syntaxis:

Wat we hier doen is in wezen een lus maken die een variabele gebruikt balie als tijdwaarnemer. Stel de waarde ervan gelijk aan start_teller en verhoog (of verlaag) met 1 tijdens elke beurt. De lus loopt tot de waarde balie zal niet gelijk zijn eind_teller. Wanneer beide waarden overeenkomen, wordt de lus nog een laatste keer uitgevoerd en gestopt.

Voorbeeld van een lus

balie zal gelijk zijn aan 11

VBA reverse For Loop met STEP-instructie

Als u van een grotere waarde naar een kleinere waarde moet gaan, kunt u een lus in de tegenovergestelde richting gebruiken. Hier is een voorbeeld van een omgekeerde lus:

Laatste variabelewaarde balie zal gelijk zijn aan 1.

Zoals je misschien gemerkt hebt, kunnen we de instructie gebruiken StapN om de cyclus zowel vooruit als achteruit te bedienen. Standaardwaarde Stap is 1, maar dit kan worden gewijzigd als het nodig is om waarden over te slaan, dan zal de waarde van n groter zijn dan één, of in de tegenovergestelde richting bewegen, dan zal n negatief zijn.

VBA-lus voor elke...Volgende

De For Each...Next-lus heeft de volgende lus:

Hier de variabele groeps_element behoort tot element_groep(ijzeren logica!!!). Ik bedoel het voorwerp element_groep moet een verzameling objecten zijn. U kunt geen For Each-lus uitvoeren op een afzonderlijk object (Microsoft zal u hiervan onmiddellijk op de hoogte stellen met een 438-fout).

Deze lus doorloopt alle elementen van een verzameling, te beginnen met de allereerste. U kunt deze lus gebruiken als u bijvoorbeeld alle bladen in een werkmap, objecten op een blad, draaitabellen, enzovoort wilt doorlopen.

Hier is een voorbeeld van hoe u een For Each-lus kunt gebruiken om alle bladen in een werkmap te doorlopen:

...of alle draaitabellen op het blad

Een VBA-lus onderbreken

Als u de lus moet verlaten voordat de voorwaarde voor het beëindigen van de lus is bereikt, gebruikt u de opdracht EindeVoor in combinatie met instructies ALS. In het onderstaande voorbeeld verlaten we de lus totdat de beëindigingsvoorwaarde is bereikt; in deze lus wordt de uitgang uitgevoerd op voorwaarde dat de variabele balie zullen gelijk aan 3.

Een deel van een lus overslaan in For Each

Een deel van een lus overslaan en dan teruggaan is een slechte gewoonte. Laten we echter eens naar een voorbeeld kijken:

Hier hebben we één iteratie overgeslagen (wanneer j = 3). Wat zal volgens jou het resultaat van het programma zijn? 3? 5? Nou... eigenlijk is geen van beide opties correct. De lus zal eindeloos doorgaan totdat het geheugen van de computer vol raakt.

Het is echter mogelijk om zonder gevolgen een stap in de cyclus over te slaan. Je kunt de teller met 1 (of een andere waarde) verhogen, waardoor bewerkingen tussen die waarden worden overgeslagen. Hier is een voorbeeld:

Maar nogmaals, dit is een slechte codeerpraktijk en kan in de toekomst tot ongewenste gevolgen leiden bij het schrijven van code. Als u in plaats daarvan enkele iteraties moet overslaan, kunt u de functie If of Case selecteren gebruiken.

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(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] = ", i);
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 het computergeheugen zijn de elementen van een multidimensionale array in een rij gerangschikt, bijvoorbeeld een array met 2 rijen en 3 kolommen,

int a;

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 moet u echter de waarden van de elementen van een multidimensionale array invoeren 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] = ", i);
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] = ", i);
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;
}