Hallo en welkom.
In deze lezing wil ik praten over multidimensionale arrays.
Tot nu toe, als je dacht aan een array, je zei net dat
een array een variabele is die kan vele soorten gegevens opslaan.
Het kan ingewikkelder worden dan dat.
Je kunt er in principe veel hebben afmetingen van een array.
Dus als je alleen een lineaire array hebt dat is wat we tot nu toe hebben besproken, dat
heet een enkele dimensie.
En we weten dat het een single is dimensie omdat
het slechts één beugel heeft met één maat.
De taal c staat arrays toe van welke omvang dan ook te worden beboet.
Dus dit is een soort van gedacht als een geneste array, een array van een array.
Dus tweedimensionale arrays zijn de meest voorkomende.
Maar je kunt het echt doen driedimensionale
arrays, vierdimensionale arrays, vijfdimensionale arrays, maar er zijn niet veel
use-cases voor 3 4 en 5.
Echt, je gaat ofwel een eendimensionale array hebben die
u in uw programma gebruikt of tweedimensionale array.
tweedimensionale arrays zijn gebruikelijk omdat ze in wezen
rijen en kolommen in een spreadsheet vertegenwoordigen, zo kun je het
een beetje visualiseren of een matrix of een tabel.
Dat is een tweedimensionale array, je hebt rijen en je hebt kolommen.
Zodat u meer gegevens kunt opslaan dan een enkeldimensionale
array door de afmetingen op te geven.
Maar het is heel toepasselijk omdat het op een matrix lijkt.
En er zijn toepassingen die misschien wil je schrijven dat dit concept van een
matrix specifiek heeft een wiskundige toepassing zou hier het
meest relevant zijn.
Maar je kunt gebruiken om tweedimensionaal te doen arrays voor veel verschillende dingen.
Een voorbeeld is een matrix.
Maar nogmaals, visualiseer het als een tabel.
Tweedimensionale arrays zijn gedeclareerd op dezelfde manier
als een eendimensionale array.
Het enige verschil ben jij nu heb nog een set beugels.
Dus in dit voorbeeld declareren we: een matrix met de naam matrix van het
type int die 4 rijen en 5 kolommen heeft.
Dat betekent dat je 20 elementen kunt opslaan binnen die tweedimensionale array.
Dus je zou moeten weten hoe elke afmeting wordt gespecificeerd
met zijn eigen paar vierkante haken.
zo herken je het makkelijk hoeveel dimensies een array heeft.
Als je daar 3 haakjes had, dat? zou een driedimensionale array zijn.
Als je er vier hebt, zijn het er vier.
Deze heeft er 2 dus het is 2.
En tot het eerder colleges hadden er maar één, dus we wisten dat dat
een enkele dimensie was.
Dus kijk naar de haakjes, let daar eens op.
Weer 4 rijen, 5 kolommen, totaal 20 elementen.
Om een tweedimensionale array te initialiseren, het wordt op dezelfde manier geïnitialiseerd
als een eendimensionaal array, hetzelfde type syntaxis, je gaat gewoon
meer toevoegen.
Dus als je de elementen opsomt voor initialisatie worden de
waarden per rij weergegeven.
En het verschil hier is dat wanneer
u de beginwaarden voor elke rij invoert, gaat u doen het tussen accolades, accolades
en dan ga je omsluiten alle rijen tussen accolades.
Het gaat er dus uitzien iets zoals dit.
Als we een reeks getallen maken, dat is van 2 dimensies,
3 rijen en 4 kolommen en we willen initialiseer het, het enige
wat u hoeft te doen is tussen accolades de hele array en voeg vervolgens binnenste geneste
accolades toe voor elke rij.
Dus hier initialiseren we waarden 0 sub-0 tot 10, 0 sub-1 tot 20, 0 sub-2 tot 30
en 0 sub-3 tot 40.
En zo krijg je toegang ook multidimensionale arrays.
Je opent ze met de rij in de kolom.
Je moet het gewoon onthouden dat het op 0 is gebaseerd.
Dus de linker bovenhand die zou rij 1 zijn, kolom 1 zou 00 zijn en dat zou gelijk
zijn aan 10.
Rij 1 kolom 2 zou zijn gelijk aan 20, maar
je zou het openen als nummers 0 sub-1.
Omdat de eerste array 3 . bevat rijen die u opent dat is het nummer dat u opgeeft voor het rijnummer
en dan is het kolomnummer de volgende specificatie voor
toegang tot de array.
Maar individualisering is mooi eenvoudig, scheid dingen
gewoon door opmerkingen met de haakjes.
En als je ze opent, zou je toegang krijgen tot het is net zoals je toegang hebt tot een
normale array, behalve dat je nu toegang hebt dit concept van een rij in een kolom.
Dus het gebruik van de binnenste paren van accolades is eigenlijk optioneel, maar je moet
het gebruiken voor de leesbaarheid.
Als je die beugels niet hebt gegeven, je zou
eigenlijk gewoon 10 20 30 40 15 25 35 kunnen geven, allemaal gewoon achtereenvolgens, maar het is erg moeilijk om te
visualiseren wat je initialiseert.
Als programmeur is leesbaarheid: heel, heel belangrijk omdat het de kwaliteit van de code
verhoogt het is gemakkelijker om de code te onderhouden.
Als ik hier naar kijk, Ik kan gemakkelijk identificeren, vooral
met de opmerkingen, wat ik ben initialiseren naar, naar welke waarden en naar
welke rijen wordt geïnitialiseerd.
Als ik dat als een enkele regel had gewoon opeenvolgende nummers, ik
zou heel snel verdwalen.
Dus hoewel de binnenste haakjes zijn niet nodig, gebruik ze.
Net als bij een eendimensionale array, het is niet vereist dat
de hele array wordt geïnitialiseerd.
U kunt bepaalde gebieden gewoon initialiseren.
Dus in dit voorbeeld zijn we het creëren van een tweedimensionale array
met 4 rijen en 5 kolommen.
We initialiseren alleen de eerste 3 elementen van elke rij.
Dus rij 1 kolom 1 is 10, rij 1 kolom 2 is 5 en rij 1 kolom 3 is een
negatieve 3, en hetzelfde voor de
tweede kolom enzovoort 900 32 31 008.
Voor degenen die we niet hebben ingesteld de 4e en vijfde
waarden van elke rij, die gaan echt automatisch op 0 worden gezet omdat we ze
hebben weggelaten.
En in dit geval ben je eigenlijk moeten zorgen voor
de accolades, de binnenste.
Want hier als we dat deden het zou de
initialisatie helemaal verknald zijn.
Want als je niet had de accolades, het zou het
gewoon achter elkaar doen.
Dus wat er zou gebeuren
is dit zou eigenlijk de eerste 12 elementen initialiseren.
Dus het zou alle . initialiseren elementen in de eerste rij, alle elementen in de tweede
rij en dan de eerste 2 elementen in de derde rij en dan
de rest van de elementen in de derde rij zou de rest van de
elementen in de 4e rij 0 zijn.
Nogmaals, dit is een tweedimensionaal matrix van 4 rijen en 5 kolommen.
Het zou ze gewoon achter elkaar doen.
Dus vergeet de beugel niet als u bent als
u alleen bepaalde initialisatie-elementen wilt specificeren.
U kunt ook doen aangewezen initialisaties.
Vergeet niet dat dit het C99-concept is.
Dat is optioneel in C11 waar u kunt
specifieke indices specificeren die moeten worden geïnitialiseerd.
U kunt dus subscripts gebruiken in de initialisatielijst, net als in een
eendimensionale array als je wilt om een aangewezen initializer te doen, zou je
zoiets als dit doen.
Dus hier declareren we onze matrix array van 4 rijen en 3 kolommen, maar we specificeren eigenlijk dat
0 0 gelijk is aan 1, 1 1 gelijk is aan 5 en 2 2
gelijk is aan 9.
Dus als we nog eens 2 2 zeggen, wat? we zeggen dat rij 2 eigenlijk rij
3 is omdat we beginnen bij 0, kolom 2 die eigenlijk kolom 3 is.
Visualiseer dit opnieuw als: een tabel of een spreadsheet.
En toegang krijgen tot de elementen begint in de linker bovenhoek.
Maar als je begrijpt dat de 4 staat voor de rijen en de
3 staat voor de kolommen, het is vrij intuïtief daarna.
Dus wat dit doet is het is initialiseren van de 3 aangegeven elementen
van de matrix naar gespecificeerde waarden.
Maar wat moet je? merk op dat hier de syntaxis is.
Alle niet-gespecificeerde waarden hier zullen standaard 0 zijn.
Dus dit gaat alleen maar om 3 waarden te initialiseren.
Elke set van de waarden die u do initialize zijn
de elementen in een rij tussen accolades.
En dan de hele initialisatie gaat tussen een ander paar bretels.
Dus je ziet dat we de accolades op de buitenste, net als bij
normale initialisatie en dan hebben we de haakjes om toegang
te krijgen tot de array binnenin.
En dan hebben we komma's om scheid elke rij en elke set rijwaarden
is gescheiden van de volgende reeks door een komma.
Dus de waarden zijn gescheiden en ook de rij-indexen.
Nu alleen omdat we dat zeiden we hebben 2 dimensies en
daar hebben we het over gehad; jij kan eigenlijk veel andere dimensies hebben.
Alles waar ik het over heb gehad 2 dimensies geldt ook
voor 3 dimensies 4 dimensies 5 dimensies.
Dus als je wilde aangeven a
3-dimensionale array, je zou het doen met 3 vierkante haken.
Dus hier is een array met de naam box van het type int van 10 20 en 30.
Misschien wilt u een driedimensionale
array misschien als je xyz-waarden van een soort opslaat, u hoeft dit waarschijnlijk niet te doen.
Driedimensionale arrays en omhoog zijn echt niet gebruikelijk.
Als samenvatting kunt u een eendimensionale array als
een rij gegevens, enkele rij, tweedimensionaal array als een tabel
een matrix of spreadsheet, in een driedimensionaal array kun je visualiseren als een
stapel gegevenstabellen, dus een stapel tabellen.
Als je zoveel gegevens nodig had, het zal heel moeilijk zijn om er
toegang toe te krijgen en waarschijnlijk verwarrend.
En iedereen die dit volhoudt programma voor een driedimensionale
array of hoger, gaat het waarschijnlijk om te verdwalen
om erachter te komen wat er aan de hand is, maar je kunt het opnieuw en
als je ooit een van deze moet herhalen een, twee, driedimensionale arrays, ga je
waarschijnlijk een lus gebruiken.
En hoe meer afmetingen je hebt in de lus, hoe meer geneste lussen
u zult hebben.
Dus als je een driedimensionale array, je krijgt
3 geneste lussen.
En als je een wilt verwerken vierdimensionale array, je
krijgt 4 geneste lussen.
Dus wat betreft het initialiseren van een array dat is hoger dan 2 dimensies, nogmaals, je
gaat toepassen hetzelfde soort dingen, je gaat het gewoon
een beetje uitbreiden.
Dus een driedimensionale array heeft 3 niveaus
van geneste accolades met het binnenste niveau met een set initialisatiewaarden voor
elke rij, dus het zou er ongeveer zo uit zien.
Hier hebben we een driedimensionale array, 2 3 en 4, in wezen
een stapel gegevenstabellen.
En het eerste blok van 3 rijen, we
gaan initialiseren en het tweede blok van 3 rijen we gaan initialiseren.
Dus wat dit zegt is weer eerste blok en tweede blok omdat we niet hebben geïnitialiseerd
het derde en het vierde blok, alleen het eerste
en het tweede.
Dus we hebben 4 blokken en jij kan als elk blok een
stapel gegevenstabellen beschouwen, elk blok met rijen en kolommen.
Dus het eerste blok wordt alleen de eerste 3 rijen initialiseren, dat is alles wat
we hebben is 3 rijen.
En dan gaat het tweede blok om de volgende 3 rijen te initialiseren, maar de derde
en de vierde blokken worden niet geïnitialiseerd.
Als u de . wilt
initialiseren derde en vierde blokken, zou je meer binnenbeugels hebben, accolades enzovoort.
Hetzelfde geldt echter voor de degenen die u niet initialiseert,
worden ze geïnitialiseerd op 0.
Maar nogmaals, je kunt zien hoe het wordt erg vervelend en
ook erg moeilijk te volgen.
Wanneer u de elementen wilt verwerken in een dimensionale array, zei ik,
ga je geneste lussen gebruiken.
Nogmaals, het gaat overeenkomen direct naar het aantal afmetingen.
En elke lus gaat naar itereren over één matrixdimensie.
Het gaat er dus uitzien iets zoals dit.
Dit is een voorbeeld van een driedimensionale reeks.
Je hebt een buitenste lus en dan heb je 2 binnenlussen.
De buitenste lus wordt de eerste buitenste array, dus de buitenste lus zou er in wezen doorheen gaan de rijen, de
tweede gaat door de kolommen en de derde
men zal door de blokken gaan.
Nogmaals, wat zou je moeten opvallen is wauw, dit wordt
echt harig en echt vervelend, echt snel.
Dus probeer driedimensionaal te vermijden vierdimensionale arrays en ik zie niet eens
veel nut gevallen ervoor, een en twee zijn echt alles
wat je gaat gebruiken.
Maar begrijp multidimensionaal arrays zijn een mogelijkheid in c, een manier om meer gegevens op te slaan
en toegang te krijgen tot dezelfde naam met veel gegevenselementen. Dank u.