[Powered by Google Translate] Kom ons praat oor skikkings.
So hoekom sou ons ooit wil skikkings te gebruik?
Wel, laat ons sê jy het 'n program wat moet 5 student ID's op te slaan.
Dit lyk dalk redelik 5 aparte veranderlikes te hê.
Vir redes wat ons sien in 'n bietjie, sal ons begin met die tel van 0.
Die veranderlikes wat ons sal hê, sal int id0, int ID1, en so aan.
Enige logika wat ons wil uit te voer op 'n student ID moet word gekopieer en geplak
vir elk van hierdie student ID's.
As ons wil hê om te kyk wat gebeur te wees in CS50,
sal ons eers moet kyk of id0 stel die student in die kursus.
Dan om dieselfde te doen vir die volgende student, sal ons nodig het om te kopieer en plak die kode vir id0
en vervang alle voorkomste van id0 met ID1 en so aan vir id2, 3 en 4.
>> So gou as jy hoor dat ons nodig het om te kopieer en plak,
moet jy begin dink dat daar 'n beter oplossing.
Nou wat as jy besef dat jy nie nodig het 5 student ID's, maar eerder 7?
Wat jy nodig het om terug te gaan in jou bronkode en voeg in 'n id5, 'n id6,
en kopieer en plak die logika vir die beheer van die ID's behoort tot die klas vir hierdie 2 nuwe ID's.
Daar is niks wat die koppeling van al hierdie IDs saam, en so daar is geen manier om te vra
die program om dit te doen vir ID's 0 tot 6.
Goed nou het jy besef jy het 100 student ID's.
Dit begin lyk minder as ideaal moet apart elkeen van hierdie IDs verklaar,
en kopieer en plak enige logika vir die nuwe ID's.
Maar miskien kan ons bepaal, en ons doen dit vir al 100 studente.
Maar wat as jy nie weet hoeveel studente daar eintlik?
Daar is net 'n paar N-studente en jou program om die gebruiker te vra wat dit n.
Uh oh. Dit gaan nie baie goed werk.
Jou program werk slegs vir 'n paar konstante aantal studente.
>> Oplos van al hierdie probleme is die skoonheid van skikkings.
So, wat is 'n skikking?
In sommige programmeertale 'n verskeidenheid tipe dalk in staat wees om 'n bietjie meer te doen,
maar hier sal ons fokus op die basiese verskeidenheid data struktuur net soos u sal sien dit in C.
'N skikking is net 'n groot blok van die geheue. Dit is dit.
Wanneer ons sê dat ons 'n skikking van 10 heelgetalle, wat net beteken dat ons het 'n paar blok
geheue wat groot genoeg is 10 afsonderlike heelgetalle te hou.
Die veronderstelling dat 'n heelgetal is 4 grepe, beteken dit dat 'n skikking van 10 heelgetalle
is 'n deurlopende blok van 40 grepe in die geheue.
Selfs wanneer jy gebruik van multidimensionele skikkings, wat ons sal nie gaan nie in hier,
dit is nog steeds net 'n groot blok van die geheue.
Die multidimensionele notasie is net 'n gerief.
As jy 'n 3 deur 3 multi-dimensionele skikking van heelgetalle,
dan jou program sal net regtig behandel dit as 'n groot blok van 36 grepe.
Die totale aantal heelgetalle is 3 keer 3, en elke heelgetal 4 bytes.
>> Kom ons neem 'n blik op 'n basiese voorbeeld.
Ons kan hier sien 2 verskillende maniere verklaar skikkings.
Ons sal moet 1 van hulle uit om kommentaar te lewer vir die program saamstel
aangesien ons verklaar x twee keer.
Ons neem 'n blik op sommige van die verskille tussen hierdie 2 vorme van verklarings in 'n bietjie.
Beide van hierdie lyne verklaar 'n verskeidenheid van grootte N,
waar ons definieer # N as 10.
Ons kon net so maklik gevra het die gebruiker vir 'n positiewe heelgetal
en gebruik word dat die heelgetal as 'n aantal van die elemente in ons verskeidenheid.
Graag ons student ID voorbeeld voor, dit is soort van soos verklaar 10 heeltemal aparte
denkbeeldige veranderlikes; x0, x1, x2, en so aan tot xn-1.
Ignoreer die lyne waar ons die skikking verklaar, let op die vierkantige hakies ongeskonde
binne die loops is.
Wanneer ons skryf iets soos x [3], wat ek sal net lees as x bracket 3,
jy kan dink dit soos om te vra vir die denkbeeldige x3.
Kennisgewing as met 'n verskeidenheid van grootte N, dit beteken dat die binnekant van die hakies,
wat ons sal noem die indeks, kan enigiets van 0 tot N-1,
wat is 'n totaal van N-indekse.
>> Na te dink oor hoe dit eintlik werk
onthou dat die skikking is 'n groot blok van die geheue.
Die veronderstelling dat 'n heelgetal is 4 grepe, die hele verskeidenheid x is 'n 40-byte blok geheue.
So x0 verwys na die heel eerste 4 grepe van die blok.
X [1] verwys na die volgende 4 bytes en so aan.
Dit beteken dat die begin van x is al die program ooit nodig het om tred te hou van.
As jy wil x [400] te gebruik, dan is die program weet dat dit is gelykstaande
tot net 1600 bytes na die begin van x.
Waar kom ons kry 1600 bytes uit? Dit is net 400 keer 4 grepe per heelgetal.
>> Voordat beweeg op, dit is baie belangrik om te besef dat in C
daar is geen toepassing van die indeks wat ons gebruik in die skikking.
Ons groot blok is slegs 10 heelgetalle lank, maar niks sal skreeu op ons as ons skryf x [20]
of selfs x [-5].
Die indeks het nie eens aan 'n getal wees.
Dit kan enige arbitrêre uitdrukking wees.
In die program wat ons gebruik die veranderlike i van die lus om die indeks in die skikking.
Dit is 'n baie algemene patroon, herhaling van i = 0 aan die lengte van die skikking,
en dan met behulp van i as die indeks vir die skikking.
In hierdie manier waarop jy effektief loop oor die hele verskeidenheid,
en jy kan óf toewys aan elke plek in die skikking of gebruik dit vir 'n paar berekening.
>> In die eerste vir die lus, ek begin by 0,
en so sal dit toewys aan die 0 plek in die skikking, die waarde 0 keer 2.
Toe het ek inkremente, en ons ken die eerste plek in die skikking die waarde 1 keer 2.
Toe het ek inkremente weer en so aan tot totdat ons toewys N-1 in die skikking te posisioneer
die waarde N-1 keer 2.
Dus het ons 'n skikking met die eerste 10 ewe getalle.
Miskien Langs hom sou gewees het om 'n bietjie beter naam vir die veranderlike as x,
maar dit sou gegee het om dinge weg.
Die tweede vir loop dan druk net die waardes wat ons reeds binnekant van die skikking gestoor.
>> Kom ons probeer om die program met beide tipes van skikking verklarings
en neem 'n blik op die afvoer van die program.
So ver as wat ons kan sien, die program tree op dieselfde manier vir beide tipes van verklarings.
Kom ons neem ook 'n blik op wat gebeur as ons die eerste lus verander om nie te stop by N
maar eerder sê 10.000.
Ver verby die einde van die skikking.
Oeps. Miskien het jy gesien voor.
'N segmentering skuld beteken jou program neergestort.
Jy begin sien wanneer jy raak gebiede van die geheue wat jy moet raak nie.
Hier is ons raak 10.000 plekke buite die begin van x,
wat klaarblyklik 'n plek in die geheue, ons moet raak nie.
So die meeste van ons sal waarskynlik nie per ongeluk sit 10.000 in plaas van N,
maar wat as ons doen iets meer subtiel soos sê skryf minder as of gelyk aan N
in die loop toestand, in teenstelling met minder as N.
Onthou dat slegs 'n skikking het die indekse van 0 tot N-1,
wat beteken dat indeks N is verby die einde van die skikking.
Die program kan nie crash in hierdie geval, maar dit is nog steeds 'n fout.
In werklikheid, hierdie fout is so algemeen dat dit het sy eie naam,
'n af met 1 fout.
>> Dit is dit vir die basiese beginsels.
So, wat is die belangrikste verskille tussen die 2 tipes van skikking verklarings?
Een verskil is waar die groot blok van die geheue gaan.
In die eerste verklaring, wat ek sal noem die bracket-skikking tipe,
al is dit nie beteken dat 'n konvensionele naam,
dit gaan op die stapel.
AANGESIEN dit in die tweede, wat ek sal noem die pointer-skikking tipe, dit gaan op die wal.
Dit beteken dat wanneer die funksie opbrengste, die bracket skikking sal outomaties deallocated word,
terwyl as jy moet explicitily noem vry op die wyser skikking
of anders jy het 'n geheue lek.
Daarbenewens het die bracket skikking is nie eintlik 'n veranderlike.
Dit is belangrik. Dit is net 'n simbool.
Jy kan dink aan dit as 'n konstante wat die vertaler kies vir jou.
Dit beteken dat ons nie kan doen nie iets soos x + + met die bracket tipe,
maar dit is volkome geldig met die tipe wyser.
>> Die pointer tipe is 'n veranderlike.
Vir die tipe wyser, ons het 2 afsonderlike blokke van geheue.
Die veranderlike x self is in die stapel gestoor en is net 'n enkele wyser,
maar die groot blok van die geheue gestoor word op die hoop.
Die veranderlike x op die stapel winkels net die adres
van die groot blok van die geheue op die hoop.
Een implikasie hiervan is met die grootte van die operateur.
As jy vra vir die grootte van die bracket skikking, sal dit gee jou die grootte van die groot blok van die geheue,
iets soos 40 bytes,
maar as jy vra vir die grootte van die wyser soort van verskeidenheid,
sal dit gee jou die grootte van die veranderlike x self, wat op die toestel is waarskynlik net 4 grepe.
Gebruik die wyser-skikking tipe, is dit onmoontlik om direk vra vir
die grootte van die groot blok van die geheue.
Dit is gewoonlik nie veel van 'n beperking aangesien ons baie selde wil die grootte
van die groot blok van die geheue, en ons kan bereken, is dit gewoonlik as ons dit nodig het.
>> Ten slotte, die bracket array gebeur om ons te voorsien met 'n kortpad vir die initialiseren van 'n skikking.
Kom ons kyk hoe ons die eerste 10 ewe heelgetalle kan skryf deur gebruik te maak van die shortcut initilization.
Met die wyser verskeidenheid, is daar nie 'n manier om 'n kortpad soos hierdie te doen.
Dit is net 'n inleiding tot wat jy kan doen met skikkings.
Hulle wys in byna elke program wat jy skryf.
Hopelik sal jy nou kan sien 'n beter manier van doen die student IDs voorbeeld
van die begin van die video.
>> My naam is Rob Bowden, en dit is CS50.