[Powered by Google Translate] Laten we praten over arrays.
Dus waarom zouden we ooit willen arrays gebruiken?
Nou laten we zeggen dat je een programma dat moet op te slaan 5 student-ID's.
Het lijkt misschien redelijk om 5 afzonderlijke variabelen.
Om redenen die we zullen zien in een beetje, zullen we beginnen te tellen vanaf 0.
De variabelen we moeten zullen int ID0, int ID1, en ga zo maar door.
Elke logica willen we voeren op een studentenkaart moet worden gekopieerd en geplakt
Voor elk van deze student IDs.
Als we willen nagaan welke studenten toevallig in CS50,
zullen we eerst moeten controleren of ID0 vertegenwoordigt de student in de cursus.
Dan om hetzelfde te doen voor de volgende student, moeten we om te kopiëren en de code te plakken voor ID0
en vervangen alle voorkomens van ID0 met id1 en zo verder voor ID2, 3, en 4.
>> Zodra je hoort dat we nodig hebben om te kopiëren en te plakken,
moet je gaan denken dat er een betere oplossing.
Nu, wat als je je realiseert je niet liever 5 student-id's nodig hebben, maar 7?
Je moet om terug te gaan naar uw broncode en in een ID5 toe te voegen, een ID6,
en kopieer en plak de logica om te controleren of de ID's behoren tot de klasse van deze 2 nieuwe ID's.
Er is niets verbindend al deze IDs elkaar en dus is er geen manier om te vragen
het programma om dit te doen voor ID's 0 tot en met 6.
Nou nu je beseft dat je 100 studenten-ID's.
Het begint te lijken minder dan ideaal om te dienen apart te verklaren elk van deze ID's,
en kopieer en plak enige logica voor die nieuwe ID's.
Maar misschien zijn we vastbesloten, en we doen het voor alle 100 leerlingen.
Maar wat als je niet weet hoeveel studenten er eigenlijk?
Er zijn slechts enkele n leerlingen en uw programma moet de gebruiker vragen wat dat n.
Uh oh. Dit gaat niet goed te werken.
Het programma werkt alleen voor sommige constant aantal studenten.
>> Het oplossen van al deze problemen is de schoonheid van arrays.
Dus wat is een array?
In sommige programmeertalen een array-type zou in staat zijn om een ​​beetje meer te doen,
maar hier zullen we focussen op de basis-array data structuur net zoals u zult zien in C.
Een array is gewoon een groot blok van het geheugen. Dat is het.
Als we zeggen dat we een array van 10 getallen, dat betekent dat we een aantal blok
geheugen dat groot genoeg is om 10 afzonderlijke integers houden.
Ervan uitgaande dat een geheel getal is 4 bytes, betekent dit dat een array van 10 integers
is een continu blok van 40 bytes in het geheugen.
Zelfs bij het gebruik van multidimensionale arrays, die we niet gaan om hier,
het is nog steeds gewoon een groot blok van het geheugen.
De multidimensionale notatie is gewoon een gemak.
Als je een 3 bij 3 multidimensionale array van integers,
dan is uw programma eigenlijk gewoon behandelen dit als een groot blok van 36 bytes.
Het totale aantal getallen is 3 keer 3 en elke integer neemt 4 bytes.
>> Laten we eens een kijkje nemen op een eenvoudig voorbeeld.
We kunnen hier zien 2 verschillende manieren te verklaren arrays.
We moeten 1 van hen commentaar uit voor het programma samen te stellen
omdat we twee keer verklaren x.
We nemen een kijkje bij enkele van de verschillen tussen deze 2 soorten aangiften in een beetje.
Beide lijnen een array declareren van grootte N,
waar we # define N als 10.
We konden net zo goed kunnen vragen de gebruiker om een ​​positief geheel getal
en gebruikt dat als integer aantal elementen in onze array.
Vóór Net als onze studentenkaart voorbeeld, dit is een soort verklaren 10 volledig gescheiden
imaginaire variabelen x0, x1, x2, enz. tot xN-1.
Het negeren van de lijnen waar we verklaren de array, let op de vierkante haakjes intact
in de voor lussen.
Als we iets schrijven als x [3], die ik lees net als x beugel 3,
kunt u denken aan het als vragen voor de denkbeeldige x3.
Opmerking dan met een array van grootte N betekent dit dat het aantal in de beugels,
die we de index te bellen, kan van alles zijn van 0 tot N-1 zijn,
die in totaal N indices.
>> Om na te denken over hoe deze echt werkt
vergeet niet dat de array is een groot blok van het geheugen.
Ervan uitgaande dat een geheel getal is 4 bytes, de gehele array x een 40 byte blok geheugen.
Dus x0 verwijst naar de allereerste 4 bytes van het blok.
X [1] naar de volgende 4 bytes enzovoort.
Dit betekent dat het begin van x is alle programma ooit moet bijhouden.
Als u wilt x [400] te gebruiken, dan wordt ervan uitgegaan dat deze gelijkwaardig is
gewoon 1600 bytes na het begin van x.
Waar krijgen we 1.600 bytes vandaan? Het is gewoon 400 keer 4 bytes per getal.
>> Alvorens over te gaan, is het erg belangrijk te realiseren dat in C
is er geen handhaving van de index die we gebruiken in de array.
Onze grote blok is slechts 10 gehele getallen lang, maar niets zal schreeuwen tegen ons als we schrijven x [20]
of x [-5].
De index heeft niet eens om een ​​nummer te zijn.
Het kan elke willekeurige expressie.
In het programma gebruiken we de variabele i van de for-lus te indexeren in de array.
Dit is een veel voorkomende patroon lus van i = 0 tot de lengte van de array,
en vervolgens met behulp van i als de index voor de array.
Op deze manier effectief lus over de hele array,
en u kunt toewijzen aan elk plekje in de matrix of het gebruiken voor een aantal berekeningen.
>> In de eerste for-lus, i begint bij 0,
en zo zal aan de 0 in de array de waarde 0 keer 2.
Dan heb ik stappen, en wijzen we de eerste plek in de array de waarde 1 tijden 2.
Dan heb ik stappen opnieuw en ga zo maar door tot we aan N-1 positie in de array
de waarde N-1 tijden 2.
Dus we hebben gemaakt een array met de eerste 10 even nummers.
Misschien evens zou zijn geweest een beetje beter naam voor de variabele dan x,
maar dat zou hebben gegeven dingen weg.
De tweede lus dan gewoon drukt de waarden die we al hebben opgeslagen in de array.
>> Laten we proberen het uitvoeren van het programma met beide soorten van array verklaringen
en neem een ​​kijkje op de uitvoer van het programma.
Voor zover we kunnen zien, gedraagt ​​het programma zich op dezelfde manier voor beide soorten aangiften.
Laten we ook eens kijken naar wat er gebeurt te nemen als we de eerste lus om niet op bij N
maar zeggen 10.000.
Wijze voorbij het einde van de array.
Oeps. Misschien heb je dit eerder gezien.
Een segmentatie fout betekent dat uw programma is gecrasht.
Je begint het zien van deze bij het aanraken van delen van het geheugen moet je niet aanraken.
Hier zijn we het aanraken van 10.000 plaatsen buiten de start van x,
dat is duidelijk een plaats in het geheugen moeten we niet raken.
Dus de meesten van ons waarschijnlijk niet per ongeluk 10.000 in plaats van N,
maar wat als we iets doen wat subtieler als zeggen schrijf kleiner dan of gelijk aan N
in de lus staat tegenover minder dan N.
Bedenk dat een array slechts indices van 0 tot N-1 is,
waardoor index N is na het einde van de array.
Het programma is mogelijk niet crashen in dit geval, maar het is nog steeds een fout.
In feite is deze fout zo vaak voor dat het een eigen naam heeft,
een off met 1 fout.
>> Dat is het voor de basis.
Dus wat zijn de belangrijkste verschillen tussen de 2 soorten van array verklaringen?
Een verschil is waar het grote blok van het geheugen gaat.
In de eerste verklaring I, die bel de beugel-array type,
maar dit is geenszins een gebruikelijke naam
het zal gaan op de stapel.
Terwijl in het tweede, dat ik de pointer-array-type noemen, zal het gaan op de heap.
Dit betekent dat wanneer de functie terugkeert, de beugel array automatisch worden deallocated,
overwegende dat moet je explicitily gratis een beroep doen op de wijzer-array
of anders moet je een geheugenlek.
Bovendien, de beugel matrix is ​​eigenlijk een variabele.
Dit is belangrijk. Het is gewoon een symbool.
U kunt hierbij denken aan het als een constante die de compiler kiest voor jou.
Dit betekent dat we niet kunnen doen iets als x + + met de beugel type,
maar dit is perfect opgaan met de aanwijzer-type.
>> De pointer is een variabele soort.
Voor de aanwijzer type, hebben we 2 afzonderlijke blokken van het geheugen.
De variabele x zelf opgeslagen in de stapel en is slechts een pointer,
maar het grote blok geheugen wordt opgeslagen op de heap.
De variabele x op de stack slaat alleen het adres
van het grote blok van het geheugen op de heap.
Een implicatie hiervan is met de grootte van de exploitant.
Als u vragen naar de omvang van de beugel array, zal het u de grootte van het grote blok van het geheugen,
iets als 40 bytes,
maar als je vraagt ​​voor de grootte van de aanwijzer type array,
het geeft je de grootte van de variabele x zelf, die op het apparaat is waarschijnlijk slechts 4 bytes.
Met de pointer-array type, is het onmogelijk om rechtstreeks vragen
de grootte van de grote blok geheugen.
Dit is meestal niet veel van een beperking omdat we willen zelden de omvang
van het grote blok van het geheugen, en we kunnen meestal berekenen als we het nodig hebben.
>> Tot slot, de beugel serie gebeurt er met ons te voorzien van een snelkoppeling voor het initialiseren van een array.
Laten we eens kijken hoe we de eerste 10 zelfs gehele getallen met behulp van de snelkoppeling initilization schrijven.
Met de aanwijzer array, is er geen manier om een ​​snelkoppeling als dit te doen.
Dit is slechts een inleiding tot wat u kunt doen met arrays.
Ze verschijnen in bijna elk programma dat u schrijven.
Hopelijk kun je nu een betere manier om de student-ID's voorbeeld
vanaf het begin van de video.
>> Mijn naam is Rob Bowden, en dit is CS50.