Hallo en welkom.
In deze lezing wil ik praten over het concept van een array.
Een array is een concept waarmee: u om in wezen veel verschillende waarden in één
enkele variabele op te slaan.
Arrays zijn gebruikelijk in de meeste programmeertalen.
Ze helpen bij het vereenvoudigen en maken van uw programma veel efficiënter.
Dus we gaan het hebben over het maken en gebruiken van arrays in c.
Een array dus.
Het is heel gebruikelijk in een programma om op te slaan veel gegevenswaarden van een bepaald type.
In een sportprogramma bijv. je wilt misschien de
scores van alle games opslaan of de scores voor elke speler.
Tot nu toe konden we gemakkelijk implementeren, maar we zouden voor elke score een
andere variabele moeten schrijven.
Dus stel je voor dat er een heleboel games zijn.
Ik bedoel, in honkbal zijn er 162 wedstrijden.
Als we een programma zouden schrijven dat was een honkbalprogramma
dat wat statistieken wilde opslaan of zoiets, we zou voor elk spel 162
variabelen moeten maken om de score bij te houden.
Dat is nu een pijn in de kont.
Het zou erg omslachtig zijn.
en het is echt te veel.
Dus dit is waar array in het spel komt, zal een
array dit probleem oplossen.
Je hoeft niet maak 162 variabelen.
U kunt een enkele variabele maken en er op een bepaalde manier toegang toe krijgen.
Met arrays kunt u dus waarden groeperen samen onder één naam.
Je hoeft niet te scheiden variabelen voor elk gegevensitem.
Dus het zal je toestaan om te worden een veel efficiëntere programmeur.
Een array is een vast aantal gegevens items ze zijn allemaal van hetzelfde type.
Dus slechts één probleem met een array is dat je de grootte van de
array niet kunt wijzigen.
Zodra u de array hebt gemaakt, is het zal altijd die maat zijn.
En de andere beperking: is dat u niet meerdere soorten
gegevens kunt opslaan.
Als u een array declareert en het is nog steeds nummers en ints
gaat opslaan, moet het ints opslaan.
Dus een paar beperkingen.
Hoe declareer je een array.
Onthoud dat wanneer u declareert een variabele wat ben je aan het doen?
Je zegt dat dit variabele bestaat in het programma.
En als je aan het declareren bent deze primitieve datatypes,
wijs je geheugenvorm toe.
Wanneer u een array declareert, de gegevensitems in de array
worden elementen genoemd.
Dus dit is een ander concept als je aan een array denkt.
Als ik de term element zeg dat betekent dat ik verwijs naar
een item in de array.
Want onthoud dat een array is veel, veel verschillende waarden
zullen hebben, maar met dezelfde naam.
En zoals we de elementen noemden in de array moet van hetzelfde
type zijn, u kunt gegevenstypen niet mixen en matchen.
Je kunt geen array hebben van 5 ints en 5 longs.
Er bestaat niet zoiets als een single reeks van meerdere gegevenstypen.
Een gebruik van een array declareren in een programma lijkt
op een normale variabele declaratie.
Het enige wat u hoeft te doen is specificeren de naam en gebruik dan haakjes.
Dus dat is het enige verschil dit idee van
vierkante haken na de naam.
Hier is een voorbeeld dit ziet eruit als een
normale variabele declaratie, maar wat je ziet hier heb je deze beugels.
Dat is het enige dat is niet normaal, en er
staat een nummer in.
Het nummer tussen de haakjes geven de maat aan.
Dus hier zeggen we gewoon dat we zijn ga een array
maken met de naam getallen van het type lang dat is gaat 10 elementen bevatten.
Het is dus vrij eenvoudig.
Dit is een nummer een verklaring omdat de puntkomma staat aan het einde, het
is net als een variabele declaratie maar je
hebt die haakjes en een nummer, en dit is de grootte van de array of de array-dimensie.
Zodra je een array hebt gedeclareerd, ben je dan wil je het gaan gebruiken.
Je gaat willen beginnen toegang krijgen
tot de gegevens erin of er gegevens naar schrijven.
Om dat te doen, heb je om te begrijpen hoe de
array in het geheugen wordt opgeslagen en hoe het is daadwerkelijk zal worden benaderd.
Dus een array met elk van de elementen in de array, elk van de gegevensitems, worden
ze benaderd met dezelfde naam.
Dus je gaat nog steeds toegang krijgen het met de naam van de variabele.
Als u echter een specifieke waarde in die straal, je zult
nu iets moeten gebruiken dat an . wordt genoemd index of een subscript, beide termen
worden door elkaar gebruikt.
Deze index- of subscriptwaarde is wordt een getal en het komt ook tussen
haakjes te staan om toegang te krijgen tot een element in de array of om
naar die plek in de array te schrijven: een waarde, volgend op de arraynaam.
Indexwaarden zijn dus sequentieel gehele getallen die beginnen bij 0.
Dus als we het hebben over een array en
het zijn elementen en we praten over de indexen in een array of de subscripts, al die subs kunnen vanaf 0 beginnen.
Dit zegt eigenlijk: dat hun stralen op 0 zijn gebaseerd.
Dus indexwaarden voor elementen in een array van grootte 10 zou zijn van 0 tot 9.
0 gaat dat vertegenwoordigen eerste array-element, en 9 gaat verwijzen naar de laatste
element in een array van grootte 10.
Dit moet je dus begrijpen concept van op 0 gebaseerde arrays.
Intuïtief zou je denken oh I wil toegang tot de
eerste plek in de array, oké, ik geef index één, nee want ze beginnen bij 0.
Het is dus heel, heel gebruikelijk om probeer per ongeluk toegang te krijgen tot een array
en sta er 1 naast omdat je denkt dat ze bij één
beginnen en niet bij 0.
Hier wordt naar verwezen als een uit door 1 fout.
U kunt een eenvoudig geheel getal gebruiken om expliciet te verwijzen naar
het element waartoe u toegang wilt.
Als u bijvoorbeeld toegang wilt tot de 4e waarde in een
array, zou je de naam van de array zeggen en dan tussen haakjes zou je zeggen 3.
Dus arraynaam sub-3 gaat om toegang te krijgen tot de 4e
waarde omdat de arraynaam op 0 is gebaseerd.
Dus je hoeft alleen maar te voorzien een nummer voor het element
waartoe u toegang wilt.
En nogmaals, onthoud dat het 0 basis is.
Dus om toegang te krijgen tot het 4e element, is het 3.
Als u toegang wilt tot de 8e element, je doet index 7.
U kunt ook een index opgeven voor een array-element met behulp van expression.
Je hoeft nu dus alleen nog maar een nummer te gebruiken.
U kunt een uitdrukking in vierkant gebruiken ook haakjes achter de naam.
De uitdrukking moet echter resulteren in een geheel getal, dat overeenkomt met
een van de mogelijke indexwaarden.
Dus als je een array van grootte hebt 10 en je
gebruikt een uitdrukking, die uitdrukking moet evalueren om ofwel 0, willekeurige getallen van 0 tot 9.
Het is ook heel gewoon als je elementen opslaan in een array om een lus te gebruiken om
ze te openen en we gaan om daar ook een voorbeeld van te geven.
Dus hier hebben we bijvoorbeeld een for loop en we initialiseren onze regelvariabele lus naar 0 I
en we zijn verlaten zodra I minder dan 10 is.
En wat doen we hier is dat we alleen
de getallen in de array weergeven.
En dus zeggen we printf getal is procent d
en dan getallen sub-I, I is een variabele.
Je kunt een variabele gebruiken in a variabele uitdrukking zolang
die variabele een getal vertegenwoordigt van 0 t/m 9, en in dit geval wel.
Het is heel gebruikelijk om te gebruiken voor: loops om een array te
doorlopen om toegang te krijgen tot de elementen of schrijf gegevens naar die elementen.
Dus om samen te vatten, hier is een leuke kleine illustratie die ik vond.
Zo is een array opgebouwd.
Als ik een array heb genaamd getallen, je
krijgt de naam van de array gevolgd door haakjes die individuele elementen in
de array identificeren.
Dus ik kan een array declareren door gewoon specificeer het type en
de naam en specificeer vervolgens de grootte tussen haakjes.
En dan wanneer ik toegang wil hebben het, ik gebruik gewoon de
arraynaam gevolgd door de indexwaarde.
En dus voor een array
met a maat 10, dan heb je indexen die geldig zijn van 0 tot 9.
Dus wat gebeurt er als je probeert toegang te krijgen? een element in
de array met een ongeldige index, bijvoorbeeld proberen om toegang te krijgen tot een array van grootte 10 met 11 als
index of 10 is een index.
Je krijgt een array buiten de grenzen fout.
Dus als je een uitdrukking gebruikt of een variabele of een constante
voor een indexwaarde die buiten de ligt bereik van de array en buiten het
bereik array betekent wat?
Nou, het betekent dat het ofwel een negatief is getal of het is een getal
dat groter is dan de grootte, echt groter dan de maat min één omdat er 0 basis is.
Dus als je een array van grootte hebt 10, maat min 1, als het groter is dan
9, heb je een array buiten de grenzen fout.
En het probleem met een array of bounds-fout,
het kan ervoor zorgen dat uw programma crasht, of zelfs erger nog, het kan
ervoor zorgen dat uw programma eruitziet alsof het normaal werkt, maar dan doet het niet normaal.
Dus het produceert niet consistente resultaten.
Soms heb je afval data, data die niets betekent
in de array.
Nogmaals, het is erg onvoorspelbaar wanneer je hebt een array van grenzen fout.
En het probleem is dat de array out-of-bounds fout kan niet worden gecontroleerd
door de compiler omdat de compiler zal niet weten of
je iets toewijst groter is of als u toegang hebt tot iets dat
groter is dan de grootte.
Het wordt nog steeds gecompileerd ook al heb je dit
gebied buiten de grenzen fout.
In wezen de reeks van grenzen fout is een runtime-fout.
Dit kom je niet te weten fout totdat u het programma uitvoert.
En nogmaals, het kan ervoor zorgen dat je programma erg onvoorspelbaar.
Dus je wilt heel, heel zijn op de hoogte van hoe u toegang krijgt tot de array,
welke indexwaarden u bent gebruiken en hoe u gegevens naar de array
schrijft met de indexwaarde.
Let goed op de array-indexen en ook de grenzen.
Als u gegevens naar een array, het is heel, heel eenvoudig.
Je gaat in principe doen gebruik gewoon de index.
Dus een waarde kan worden opgeslagen in een array element eenvoudig door het array-element aan
de linkerkant op te geven kant van het gelijkteken en gebruik vervolgens de haakjes
om de . te specificeren element waarnaar u wilt schrijven.
Dus voor in dit voorbeeld hebben we een array met de naam cijfers, we weten niet hoe groot
het is, het moet zijn groter dan 100, anders zouden we
hier een array-out-of-bounds-fout hebben.
Maar in dit voorbeeld zeggen we: cijfer onder 100 is gelijk aan 95.
De waarde 95 wordt opgeslagen in het element nummer 100
van de cijferreeks, heel eenvoudig.
U geeft gewoon de index op en vervolgens welke waarde u
ook wilt ondertekenen.
U kunt ook variabelen gebruiken om waarden aan een array toe te kennen.
Dus 95 kan worden opgeslagen in een variabele, net zoals je andere variabelen toewijst.
Laten we nu eens doornemen voorbeeld van het gebruik van een array.
Hier is een voorbeeld van het gebruik van een array die gaat
optellen, lees in 10 getallen en geef me dan het gemiddelde van die 10 getallen.
Terwijl we ze lezen in we zijn gaan we de som berekenen,
dan gaan we het gemiddelde weergeven.
Dus op dit punt wil ik nemen dit voorbeeld en ik wil
het in codeblokken plaatsen en proberen uit te voeren door en laat je zien hoe het werkt.
We zijn in onze normale weergave, we zijn in een eenvoudig project en we gaan u laten zien
hoe een array werkt in codeblokken.
Je zult merken dat we in onze hoofdfunctie.
Dit is de inzending naar het programma wijzen.
En op lijn 12 zijn we... een array declareren.
We gaan een aankondigen array van type int van grootte 10.
De maat staat tussen de haakjes, we eindigen met een puntkomma.
Dit is een array die is 10 waarden gaan opslaan.
Als we deze array niet
hadden opgeslagen wat we zouden moeten doen is dat we cijfers 1 moeten zeggen int, graad 2 int, graad 3.
Zie je hoe problematisch dat is is en hoe vervelend het is.
Het is heel fijn dat we dat kunnen maak gewoon een enkele variabele
die 10 items opslaat, en ze zijn gegroepeerd.
Wanneer u items in een array opslaat, wil niet dat de waarden van de gegevens
anders zijn, allemaal verschillende dingen.
Zoals in dit voorbeeld slaan we op cijfers, dus het zijn allemaal cijfers.
U wilt een array geen naam geven iets en dan zeg ik dat
ik mijn cijfers ga opslaan, dat ga ik doen bewaar mijn...
mijn... mijn... wat dan ook, mijn leeftijd daarbinnen en zo.
Zorg ervoor dat u hetzelfde type bewaart van gegevens wanneer u een array bent.
De volgende variabele in de rij 13 is een count-variabele.
Het is gelijk aan 10.
Het wordt het nummer waarden die moeten worden gelezen omdat we
door de array gaan.
Som is lang, we gaan optellen de getallen terwijl we door de waarden gaan
en dan gaat het gemiddelde een float zijn omdat we het gemiddelde van
de getallen willen hebben.
Het eerste wat we gaan doen op regel 17 is
dat we de gebruiker gaan vertellen dat we dat willen voer 10 cijfers in en dan
gaan we de waarden inlezen.
Dus op regel 20 merk je hoe ik ben inspringen
en ik gebruik een goede naamgeving, inspringing en gebruik een goede blokkering van code voor blokken code-inspringing.
Hier op regel 20, verklaar ik mijn loop control variabele.
Ik gebruik een oudere compiler, c compiler 89, dus ik kan het niet declareren
en dezelfde regel initialiseren.
Normaal gesproken zou je dit gewoon doen.
Maar als ik het doe omdat ik aan het rennen ben? C89-compiler krijgt een foutmelding.
Dus ik declareer mijn variabele online 20, en dan gebruik ik een for-lus.
We zijn bekend met for-loops van onze vorige lezingen kunt
u code herhalen.
Hier zeggen we gewoon dat we gaan een tegengestuurde for-lus hebben,
we beginnen bij 0 en we zijn gaat helemaal door tot 10.
Dus we gaan door 10 iteraties, maar je merkt dat
de index 0 is.
Dat is belangrijk omdat we gaan toegang krijgen tot een
array, met behulp van die variabele I.
En dan zul je het uiteindelijk merken van de for-lus, wijzigen we de
regelvariabele van de lus door deze te verhogen.
Dus we gaan uitprinten de waarde van I plus 1 terwijl
we door de array gaan om u te laten zien waar je bent voor de cijfers.
Dus het gaat eigenlijk zeggen als voer graad 1 graad 2 graad 3 graad 4 in.
Het gaat je dan vragen om voer het cijfer in met scanf.
We gaan het opslaan in onze array.
Dat merk je als je sla het op in de
array, het is net als een normale variabele toegang.
Je gebruikt gewoon cijfers, en dan specificeert u de index.
Hier gebruiken we I als onze index.
Dus dat wordt gelijk aan 0 de eerste iteratie, 1 de tweede
iteratie, 2 de derde iteratie.
En het is goed dat we begonnen met 0 omdat arrays op 0
zijn gebaseerd en dan gebruiken we gewoon het adres van de operator, de ampersand.
Terwijl we er doorheen gaan, zijn we gaan de cijfers bij elkaar optellen.
Dus we gaan zeggen som is gelijk aan som plus graad sub I.
Elke klas gaat naar bereken in principe een totaal.
En als we dan eenmaal uit de lus zijn na 10 keer
rennen, gaan we ons gemiddelde gelijk stellen aan de som gedeeld door de telling en
giet het naar een vlotter, we werpen hier.
Dit verandert het gegevenstype.
Onthoud, som gedeeld door telling, som is het lang en telt het als een int en we willen dat naar
een float werpen.
En dan, helemaal aan het einde, zijn we... ik ga het gemiddelde uitprinten.
Dus laten we doorgaan en dit uitvoeren en zorg ervoor dat we geen fouten krijgen, we hebben 0 fouten
en 0 waarschuwingen.
Dus laten we het nu uitvoeren.
En dus gaat het gebeuren precies wat ik noemde.
Het gaat zeggen voer de 10 cijfers in en dan zet het een 1 in een klein teken daar zodat we
weten op welk nummer we zijn.
Het gaat in als 95 32 55, het gaat erin en zet hier gewoon alle
nummers in.
Ze hebben niet noodzakelijkerwijs zin, dat is goed, en mijn laatste nummer 23.
Het gemiddelde van die 10 het cijfer wordt 51. 20.
Maar het is echt leuk omdat we hoef je geen 10 variabelen aan te maken.
We benaderen de array met behulp van de subscript, en we kunnen waarden aan de
array toewijzen met behulp van het subscript.
Dit is eigenlijk toewijzen wanneer we de scanf.
We wijzen gegevens toe aan: dat naar dat subscript.
Als we dit nu zouden veranderen en zeggen dat we bij 1 zijn begonnen en in
plaats van te gaan tellen welke 10 is, stellen we het eigenlijk gelijk.
Dus laten we eigenlijk verander dat niet in 1.
Laten we zeggen dat we gaan beginnen op 0, maar nu gaan
we helemaal naar index 10.
Denk eraan, index 10 is verboden terrein omdat de grootte van de
array 10 is, maar de indexwaarde 0 . is gebaseerd zodat de maximale index 9 is.
En nogmaals, het gaat ons lukken om dit
te compileren omdat compilers geen out-of-bounds-fouten detecteren, het probleem is wanneer we het uitvoeren.
Als we nu het programma uitvoeren, we gaan een groot probleem hebben, we proberen
naar de 11e klas te gaan.
Dus we zullen allemaal goed zijn.
Als we 10 klassen invoeren, het probleem gaat gebeuren als we
bij 11 zijn.
Nu hebben we 11, en we zijn gaan proberen om gegevens op te slaan.
Er is niets ergs gebeurd, maar onze gemiddelde zal niet kloppen.
En het is erg onvoorspelbaar gedrag wanneer u een fout buiten de grenzen heeft.
Dus je wilt er zeker van zijn dat je hebt de oogles tellen en je wilt
er zeker van zijn dat wanneer je hebt toegang tot de informatie, je gaat ook niet
buiten de grenzen.
En dit is de basis van de array, de array
declareren, de grootte specificeren, alleen het gegevenstype en dan de grootte en haakjes, toegang tot de array of het
opslaan van gegevens in de array, waarden toewijzen, met behulp
van het subscript I in de indexen.
En we zouden zelfs de . kunnen uitprinten indexen die ook subscript gebruiken.
Arrays gaan nogal wat gebruikt worden.
We zullen veel voorbeelden hebben met arrays omdat het dingen vereenvoudigt.
Onthoud dat arrays een vaste grootte hebben.
Je kunt de niet veranderen grootte van de klassen.
Het zal altijd zijn 10 terwijl u het programma uitvoert.
Dus als u gegevens hierboven toewijst dat, het gaat niet uitbreiden.
En onthoud ook die cijfers moeten van hetzelfde gegevenstype zijn.
Ik kan geen strings of woorden opslaan in de klas kan ik alleen ints opslaan.
Ik kan geen drijvers in opslaan daar alleen opslaan ints.
Dank u.