>> [Muziek]
DOUG LLOYD: Oké.
Werken met enkele variabelen is best leuk.
Maar wat als we willen werken met veel variabelen,
maar we willen niet een stelletje hebben verschillende namen vliegen rond onze code?
In dit geval zijn arrays gaan om binnen te komen echt handig.
Arrays zijn een echt fundamentele data structuur voor elke programmeertaal
die u wilt gebruiken.
En ze zijn echt, echt nuttig, in het bijzonder, zoals we zullen zien, in CS 50.
>> We maken gebruik van arrays te houden waarden van hetzelfde gegevenstype
in aaneengesloten geheugenlocaties.
Dat wil zeggen, het is een manier dat we kunnen groeperen
een bos van gehele getallen samen in geheugen of een stel tekens
of drijft in het geheugen echt dicht bij elkaar en werken
mee zonder elkaar te een eigen unieke naam, die kan
krijgt lastig na een tijdje.
>> Nu, een manier om arrays analogize is na te denken over uw lokale post
kantoor voor een tweede.
Dus stap uit de buurt van de programmering en gewoon je ogen dicht
en visualiseren in je geest uw plaatselijke postkantoor.
Meestal, in de meeste bericht kantoren, er is een grote bank
een postkantoor dozen op de muur.
>> Een array is een gigantische blok aaneengesloten geheugen,
op dezelfde manier dat een e- bank in uw postkantoor
is een grote ruimte op de wand van het postkantoor.
Arrays zijn verdeeld in kleine, identiek gerangschikte blokken van de ruimte,
die elk genoemd element, in Net zoals de wand van de paal
office is verdeeld in kleine, identiek gerangschikte blokken van de ruimte,
die noemen we een postbus.
Elk element van de array slaan een aantal gegevens,
net zoals elke postbus staat een zekere post houden.
>> Wat kan worden opgeslagen in elk element van de array variabelen dezelfde gegevens
type, zoals int of char, gewoon zoals in uw postbus,
je kunt alleen fit dingen van een soortgelijk type,
zoals brieven en kleine pakketten.
Tenslotte kunnen we toegang elk element van de array direct per index nummer,
net zoals we kunnen toegang tot onze postkantoor vak door te weten het postbusnummer.
Hopelijk die analogie helpt je je hoofd te krijgen
rond het idee van arrays door analogizing naar iets anders
dat je waarschijnlijk al vertrouwd met.
>> In C, de elementen van een array geïndexeerd vanaf 0, niet 1.
En dit is echt belangrijk.
En in feite is dit de reden waarom we, in CS 50, en waarom informatici vaak
zal tellen van 0, is door de matrix C
indexering, die altijd begint bij 0.
Als een matrix bestaat uit n elementen, het eerste element van die array
zich op index 0, en het laatste element van de array
zich op index n 1 min.
Opnieuw, als er n elementen in onze matrix, de laatste index n minus 1.
>> Als onze array elementen 50, de eerste element zich op index 0,
en het laatste element zich op index 49.
Helaas, of gelukkig, afhankelijk van uw perspectief,
C is hier erg soepel.
Het zal u niet verhinderen uit te gaan van de grenzen van de array.
Je zou kunnen openen de min 3 element van de array
of de 59ste element van de array, Als uw array slechts 50 elementen.
Het zal je programma niet stoppen compileren, maar tijdens runtime,
u kunt tegenkomen een gevreesde segmentation fault
als je begint om toegang tot het geheugen die buiten de grenzen van het
vroeg je je programma om u te geven.
Dus wees voorzichtig.
>> Wat doet een array verklaring eruit?
Hoe kunnen we de code een array in bestaan zoals wij coderen elke andere variabele?
Er zijn drie delen van een array declaration-- een type, een naam,
en een grootte.
Dit is vergelijkbaar met een variabele verklaring, die
is slechts een type en een naam, de grootte element
het speciale geval van een array, want we krijgen een bos van hen
op hetzelfde moment.
>> Dus het type is wat voor soort variabele die u wil elk element van de matrix zijn.
Wil dat het een array van gehele getallen?
Daarna moet uw gegevens type int zijn.
Wilt u er een te zijn reeks van dubbels of praalwagens?
Soort gegevens moeten dubbel zijn of zweven.
De naam is wat je wilt u uw serie noemen.
Wat wil je met deze reusachtige naam bank van gehele getallen of vlotters of chars
of dubbelspel, of wat je hebt?
Wat wil je ook wilt noemen?
Vrij duidelijk.
>> Tenslotte grootte, die gaat binnenkant van vierkante haken,
is hoeveel elementen je zou als je array bevatten.
Hoeveel gehele getallen wil je?
Hoeveel wagens wil je?
>> Dus bijvoorbeeld, int student rangen 40.
Dit verklaart een array genaamd Student rangen, die bestaat uit 40 getallen.
Mooie duidelijk, hoop ik.
Hier is een ander voorbeeld.
Dubbele menuprijzen 8.
Dit creëert een array met de naam Menuprijzen, dat bestaat uit
ruimte in het geheugen voor acht tweepersoonskamers.
>> Als u denkt dat van elk element van een array van het type data-type,
dus bijvoorbeeld een enkel element van een array van het type int, op dezelfde manier
zou denken van een ander variabele van het type int,
alle bekende bewerkingen die we eerder besproken in de Operations
video zal zinvol.
Dus hier kunnen we een array te verklaren van Booleans genaamd Truthtable,
die bestaat uit ruimte voor 10 Booleans.
>> En dan, net als we konden alleen maar te wijzen een waarde aan andere variabele van het type
Boolean, kunnen we iets zeggen zoals Truthtable vierkant haakje
2, dat is hoe we aangeven welk element van de waarheid tafel?
Het derde element van het waarheid tafel, want vergeet niet,
we tellen vanaf 0.
Dus dat is hoe we geven de derde element van de waarheid tafel.
Truthtable 2 is gelijk aan vals, net alsof we konden declare--
of we zouden kunnen wijzen veeleer eventuele Boolean variabel te zijn vals.
>> We kunnen het ook gebruiken bij aandoeningen.
if (truthtable 7 == true), dat wil zeggen,
Als het achtste element van Truthtable is waar,
Misschien willen we een boodschap af te drukken aan de gebruiker, printf ("WAAR! n") ;.
Dat doet ons Truthtable zeggen 10 gelijk waar, toch?
Nou, dat kan ik, maar het is vrij gevaarlijk, want vergeet niet,
hebben we een reeks van 10 Booleans.
Dus de hoogste index die de compiler heeft ons is 9.
>> Dit programma zal compileren, maar als er iets anders in het geheugen
bestaat waar we zouden verwachten Truthtable 10 te gaan,
we een segmentatie fout zou kunnen lijden. We misschien wegkomen met het, maar in het algemeen,
behoorlijk gevaarlijk.
Dus wat ik hier doe is legaal C, maar niet noodzakelijkerwijs de beste zet.
Nu, als je te verklaren en initialiseren een array gelijktijdig,
er is eigenlijk een vrij speciale syntax die u
kan gebruiken om vullen de array met beginwaarden.
Het kan omslachtig om verklaren een array van grootte 100,
en dan zeggen, element 0 gelijk aan dit; element 1 is gelijk aan dit;
element 2 is gelijk aan dat.
Wat is het punt, toch?
>> Als het een kleine array, u zou zoiets doen.
Bool truthtable 3 evenaart geopend accolade en dan komma
scheiden de lijst van de elementen die u in de array te zetten.
Sluit accolade puntkomma.
Dit creëert een scala aan grootte drie zogenaamde Truthtable,
met elementen vals, waar, en waar.
En inderdaad, het starten syntax Ik heb hier
precies hetzelfde als doen individueel element syntax hieronder.
Deze twee manieren codering zou produceren exact dezelfde array.
>> Ook konden we herhalen over alle elementen
van een array via een lus, die in Sterker nog, is een zeer sterk aanbevolen
thuis te oefenen.
Hoe maak je een array van 100 integers, waarbij
elk element van de array zijn index?
Dus bijvoorbeeld, hebben we een reeks van 100 integers, en in het eerste element,
we willen zetten 0.
In het tweede element, willen we zetten 1.
In het derde element, we willen 2 te dienen; enzovoort, enzovoort.
Dat is een heel goed at-home oefening om dat te doen.
>> Hier, ziet het er niet als te veel veranderd.
Maar merken dat tussen de vierkante haken, ditmaal,
Ik heb eigenlijk weggelaten het nummer.
Als je met behulp van deze zeer speciale instantiatie
syntax om een ​​te creëren array, je eigenlijk niet
moet de grootte duiden van de matrix vooraf.
De compiler is slim genoeg om daadwerkelijk te weten dat u
wil een array van grootte 3, omdat je drie elementen
rechts van het gelijkteken.
Als je vier had gezet, zou het krijgt u een waarheid tabel van grootte vier;
enzovoort, enzovoort.
>> Arrays zijn niet beperkt tot één dimensie, die is vrij cool.
Je kunt eigenlijk zo veel side voorschrijvers als u wilt.
Dus bijvoorbeeld, als je wilt maken een bord voor het spel Battleship, waarin,
Als je ooit gespeeld, is een spel dat is gespeeld met pinnen op de 10 bij 10 rooster,
kon je een array als deze te maken.
Je zou kunnen zeggen Bool slagschip vierkante beugel 10
gesloten vierkant vierkant haakje beugel 10 gesloten square bracket.
>> En dan kun je ervoor kiezen om interpreteren dit in je geest als een 10
van 10 raster van cellen.
Nu, in feite, in geheugen, het doet echt gewoon
blijft een element 100, eendimensionale matrix.
En dit in feite geldt voor als je hebben drie dimensies of vier of vijf.
Het is echt gewoon niet vermenigvuldigen alle indices--
of alle afmetingen specifiers-- samen,
en krijg je alleen maar een eendimensionale matrix van die grootte.
>> Maar in termen van organisatie en visualisatie en de menselijke waarneming,
het kan een stuk makkelijker werken met een rooster
als je werkt aan een spel zoals Boter-kaas-en-eieren of Battleship,
of zoiets.
Het is een grote abstractie, in plaats van
na te denken over een Boter-kaas-en-eieren board als een lijn van negen
vierkanten of een Battleship board als een lijn van 100 pleinen.
Een 10 bij 10 rooster of een drie- door drie raster is waarschijnlijk
veel gemakkelijker te zien.
>> Nu, iets echt belangrijks over arrays.
We kunnen elke individuele behandeling element van de array variabele.
We zagen dat eerder toen we het toewijzen
de waarde True bepaalde Booleans of te testen in conditionals.
Maar we kunnen volledige niet behandelen arrays zelf als variabelen.
We kunnen bijvoorbeeld wijzen ene array een andere matrix met de opdracht
operator.
Het is niet legaal C.
>> Als we willen, voor wat example-- we zouden moeten doen in dat voorbeeld
zou een matrix kopiëren naar een andere.
Als we dat willen, we eigenlijk doen zou een lus over te kopiëren
elk element één tegelijk.
Ik weet dat het een beetje tijd in beslag.
>> Dus bijvoorbeeld, als we deze paar regels code, zou dit werk?
Nou, nee, zou het niet, toch?
Omdat we proberen om voedsel toe te wijzen aan de bar.
Dat gaat niet werken, omdat het een array,
en we zojuist beschreven dat is niet legaal C.
>> In plaats daarvan, als we willen kopieert u de inhoud van het voedsel
in de bar, die is wat we proberen te doen hier,
we zouden een syntax als dit nodig hebben.
We hebben een lus die gaat van J is gelijk aan 0 tot 5,
en verhogen we J op elke iteratie van de lus en toewijzen elementen als dat.
Dit zou resulteren in de bar ook waarbij één, twee, drie, vier, vijf,
maar we moeten het op deze zeer doen slow element-voor-element weg,
in plaats van gewoon kopiëren van de gehele array.
In andere programmeertalen talen, meer moderne degenen,
kunt u, in feite, gewoon doen Zo simpel is gelijk aan de syntaxis.
Maar C, helaas, we zijn niet toegestaan ​​om dat te doen.
>> Nu, er is een andere wat ik wil noemen
over arrays die een beetje kan zijn beetje lastig de eerste keer dat u
werken met hen.
We bespraken in een video over variabele reikwijdte,
dat de meeste variabelen in C, wanneer u belt ze in functies, worden doorgegeven door de waarde.
Weet je nog wat het betekent om iets van waarde passeren?
Het betekent dat we het maken van een kopie van de variabele dat wordt doorgegeven.
De callee functie, de functie dat is het ontvangen van de variabele,
niet de variabele zelf te krijgen.
Het krijgt zijn eigen lokale kopie ervan mee te werken.
>> Arrays, natuurlijk doen niet aan deze regel.
Integendeel, wat wij noemen dit is het passeren door middel van verwijzing.
De callee eigenlijk ontvangt de array.
Het maakt niet ontvangen zijn eigen lokale kopie van het.
En als je erover nadenkt het, dit is logisch.
Als arrays zijn erg groot, het kost zoveel tijd en moeite
om een ​​kopie van een serie van te maken 100 of 1000 of 10.000 elementen,
dat het niet de moeite waard voor een functie om een ​​kopie ontvangen van het,
wat werk te doen, en dan alleen worden gedaan met copy;
het niet nodig te hebben Het opknoping rond meer.
>> Omdat sommige arrays omvangrijk en omslachtig,
we ze gewoon passeren door middel van verwijzing.
We vertrouwen erop dat de functie om, niets breken.
Het maakt dus eigenlijk de array.
Het heeft geen eigen lokale kopie van krijgen.
>> Dus wat betekent dit, Vervolgens, toen de callee
manipuleert elementen van de serie?
Wat gebeurt?
Voor nu, zullen we glans dan waarom juist dit
gebeurt, waarom arrays worden doorgegeven door middel van verwijzing
en al het andere wordt doorgegeven door de waarde.
Maar ik beloof je, zullen we terug en geven u het antwoord
om deze in een later video.
>> Hier is nog een oefening voor u voordat we wrap up dingen op arrays.
Het bos van de code hier, dat is niet bijzonder goede stijl,
alleen ik die waarschuwing te maken.
Er is geen commentaar hier, dat is vrij slechte vorm.
Maar dat is alleen omdat ik wilde zijn in staat om alles op het scherm past.
>> Op de top, kun je zien dat ik heb twee functie verklaringen voor set-array
en stel int.
Set-array neemt blijkbaar een array vier integers als invoer.
En set int neemt blijkbaar een integer als invoer.
Maar beiden hebben geen uitgang.
De uitvoer, de terugkeer typen, van een ieder is nietig.
In Main, hebben we een paar regels code.
Wij verklaren een integer variabele genaamd A en wijs de waarde 10.
Wij verklaren een array van vier getallen B genoemd en de elementen 0, 1 toewijzen
2 en 3 resp.
Dan hebben we een oproep om int en een oproep tot scala stellen.
De definities van de set-array en set int zijn beneden, aan de onderkant.
>> En dus, nogmaals, vraag ik u de vraag.
Wat wordt afgedrukt hier aan het einde van Main?
Er is een afdruk col. Ik m afdrukken van twee gehele getallen.
Ik ben het afdrukken van de inhoud van A en de inhoud van B square bracket 0.
Pauzeer de video hier en neem een ​​minuut.
Kun je uitzoeken wat dit functie wordt afgedrukt op het einde?
Hopelijk, als je herinneren aan de onderscheid tussen passerende waarde
en langs referentie, deze probleem was niet te lastig voor u.
En het antwoord dat je zou heb gevonden is dit.
Als je niet echt zeker als aan waarom dat het geval is, neem dan een tweede,
ga terug, bekijk wat ik was gewoon bespreking over het passeren van arrays
referentie, versus passeren andere variabelen van de waarde,
en hopelijk, zal het maken een beetje meer zin.
>> Ik ben Doug Lloyd, en dit is CS50.