>> DAVID MALAN: Hallo, en welkom terug naar CS50.
Dus dit is het einde van de week vier.
Slechts een aankondiging eerste.
Dus de zogenaamde vijfde maandag is er deze komende maandag.
Dit is de mogelijkheid om te veranderen van SAT / unsat om een ​​letter of uit
brievenrang SAT / unsat.
Vervelend, dat proces vereist een handtekening, want u moet invullen
uit een van die roze add / drop vormen.
>> Omdat technisch gezien, de SAT / unsat versie en de brievenrang versie
hebben verschillende catalogusnummers.
Maar geen big deal.
Kom gewoon naar me toe of naar Rob of naar Lauren op elk punt.
Of mail ons als u niet het soort hebben papierwerk u vandaag nodig hebt, en wij
zal zeker helpen u zorg dat vóór maandag.
>> Oke, dus vandaag -
Eigenlijk is er een beetje een echo.
Kunnen we toon me een beetje?
OK.
Dus vandaag introduceren we een onderwerp bekend als pointers.
En ik geef toe dat dit een van de meer complexe onderwerpen die we geneigd zijn te
dekken in deze klasse, of eigenlijk elke inleidende cursus die C. gebruikt
>> Maar neem mijn woord te geloven, vooral als je geest voelt een beetje meer gebogen
vandaag en in de komende weken.
Het is niet representatief van u krijgen slechter bij deze het betekent alleen dat
het is een bijzonder verfijnde onderwerp dat beloof ik, een paar weken
dus zal lijken al te opvallend eenvoudig achteraf.
>> Ik herinner me nog aan deze dag.
Ik zat in Elliott Dining Hall, zat naast mijn TF Nishat Mehta,
die was een inwoner van Elliott huis.
En om wat voor reden dan ook, dit onderwerp gewoon klikt.
Dat wil zeggen dat ik ook worstelde met het voor een bepaalde hoeveelheid tijd, maar ik
zal mijn best doen om te helpen voorkomen dat een dergelijke worstelen met een onderwerp dat uiteindelijk
is vrij krachtig.
>> In feite, een van de onderwerpen die we zullen bespreken in de komende weken is dat
van veiligheid, en hoe kun je eigenlijk machines te exploiteren op een wijze
die niet bedoeld waren.
En die exploitaties zijn typisch het gevolg van bugs, fouten die we
mensen maken door niet te begrijpen van een aantal van de onderliggende implementatie
gegevens via welke programma's worden gemaakt.
>> Nu om dit te maken lijken des te meer gebruikersvriendelijk vriendelijk, ik dacht dat ik speel een 10
tweede voorbeeld van een kleine claymation figuur genaamd Binky die om werd gebracht
het leven door een vriend van ons in Stanford, professor Nick Parlante.
Dus laat ik u dit geven teaser van Binky hier.
>> [VIDEO AFSPELEN]
>> -He, Binky.
Wakker worden.
Het is tijd voor pointer lol.
>> -Wat is dat?
Meer informatie over pointers?
Oh, goodie.
>> [END VIDEO AFSPELEN]
>> DAVID Malan: Dat is Stanford computer science.
Dus meer op die te komen.
>> [Applaus]
>> DAVID MALAN: Sorry, Nick.
>> Zo herinneren dat vorige keer dat we eindigden op dit is echt spannende cliffhanger
waarbij deze functie gewoon niet werken.
Tenminste intuïtief, het voelde zoals het zou moeten werken.
Gewoon omwisselen van de waarden twee integers.
Maar herinneren dat toen we uitgeprint de oorspronkelijke waarden in de belangrijkste, een en
twee, waren ze nog een en twee en niet twee en een.
>> Dus laat me eigenlijk schakelen naar het apparaat.
En ik schreef een stukje van het skelet code in hier vooruit te gaan, waar ik beweren dat x
zal zijn 1, zal y zijn 2.
Ik vervolgens uitprinten allebei van hun waarden met print f.
>> Ik eis dan hier beneden die we gaan om ze te verwisselen.
Ik liet een lege plek hier voor ons om in vandaag invullen in slechts een moment.
Dan, ga ik om te beweren dat de twee variabelen zijn verwisseld.
Dan ga ik om af te drukken ze er weer.
En dus hopelijk, zou ik zie 1, 2.
2, 1.
Dat is het super simpel doel nu.
>> Dus hoe gaan we over het ruilen twee variabelen?
Nou als ik hier stel voor dat deze bekers misschien in een computer geheugen vertegenwoordigen.
Dit is een paar happen, dit is een ander paar happen.
Konden we een vrijwilliger zijn gekomen op en Meng ons wat te drinken, als je bekend voor?
Kom maar naar boven.
Wat is je naam?
>> JESS: Jess.
>> DAVID Malan: Jess?
Kom op, Jess.
Als je het niet erg, we moeten het zetten Google Glass on you so we can
onsterfelijk dit.
OK, glas.
Een video opnemen.
En OK, we zijn goed om te gaan met Jess hier.
Oke.
Leuk u te ontmoeten.
>> Dus wat ik zou willen dat je hier te doen - als je kon, vrij snel -
net giet ons een half glas jus sap en een half glas melk,
die effectief de nummers 1 in een beker en 2 in de andere beker.
>> Dit gaat goed beeldmateriaal te zijn.
>> JESS: Sorry.
>> DAVID MALAN: Nee, nee.
Het is OK.
Leuk.
Oke, dus we hebben vier bytes ter waarde van sinaasappelsap.
We zullen noemde het de waarde 1.
Nu nog eens vier bytes met melk.
Zal noemen het waarderen 2.
Zodat x en y, respectievelijk.
>> Oke, dus nu als de taak bij de hand - voor u, Jess, voor alle
van je klasgenoten -
is de waarden van x en y zodanig verwisselen dat we willen dat de jus d'orange in de
andere beker en de melk in de beker, hoe zou u - voordat u daadwerkelijk doen
het - dat doen?
>> OK, wijs besluit.
Dus je moet een beetje meer geheugen.
Dus laten we wijzen een tijdelijk cup, als je wil.
En nu verder met x-en y-swap.
>> Excellent.
Dus heel goed gedaan.
Dankuwel, Jess.
Alstublieft.
Een beetje souvenir.
>> OK, dus uiteraard, super simpel idee.
Volkomen intuïtief dat we een beetje nodig meer opslagruimte - in deze vorm,
een kop - als we eigenlijk willen swap deze twee variabelen.
Dus laten we doen precies dat.
Hier in tussen waar ik beweer ik ben gaat doen wat ruilen, ik zal
ga je gang en verklaren temp.
En ik stel deze gelijk is aan, zeg, x.
>> Dan ga ik de waarde van de te wijzigen x net als Jess deed hier met de
melk en jus d'orange zijn gelijk aan y.
En ik ga y te veranderen gelijk te zijn om niet x, omdat we nu zouden zijn
vast in een cirkel, maar temp.
Waar ik tijdelijk - of waar Jess het sinaasappelsap tijdelijk gezet
vóór beuken dat cup met de melk.
>> Dus laat me nu ga je gang en maken dit.
Het noswap.c heet.
En nu laat ik geen swap draaien.
En inderdaad zie ik, als ik het uitbreiden van de raam een ​​beetje, dat
x is 1, y is 2.
En dan x is 2, y is 1.
>> Maar herinneren dat op maandag we deden dingen een beetje anders, waarbij ik
plaats implementeerde een helper functie, als je wil, dat was eigenlijk nietig.
Ik noemde het ruilen.
Ik gaf het twee parameters, en ik riep ze een en ik riep hen b.
>> Eerlijk gezegd, ik kon ze x-en y noemen.
Er is niets te stoppen me uit dat te doen.
Maar ik zou zeggen dat het dan een beetje dubbelzinnig.
Omdat terugroepactie voor maandag dat we beweerde dat deze parameters waren
kopieën van de waarden doorgegeven inch
Dus het is alleen knoeit met uw gedachten, denk ik, als je gebruik maakt
dezelfde variabelen.
>> Dus ik zal hen een plaats te bellen en b, gewoon voor de duidelijkheid.
Maar we konden hen het meest bellen wat we willen.
En ik ga om te kopiëren en plakken effectief deze code van daarboven
beneden in hier.
Want ik zag gewoon dat het werkt.
Dus dat is in vrij goede vorm.
En ik zal mijn x veranderen in een, mijn x een, mijn y naar b en mijn y naar b.
>> Dus met andere woorden, precies dezelfde logica.
Precies hetzelfde dat Jess deed.
En dan is het enige wat ik moet doen omhoog hier natuurlijk nu dit beroep
functie, of bel deze functie.
Dus ik zal deze functie met twee bellen ingangen, x en y, en hit Opslaan.
>> Oke, zo fundamenteel hetzelfde.
In feite heb ik waarschijnlijk maakte het programma onnodig complex door
het schrijven van een functie die net is het nemen ongeveer zes regels code terwijl ik
eerder had uitgevoerd dit in slechts drie.
>> Dus laat me nu ga je gang en remake deze, maken geen swap.
Oke, ik geschroefd hier boven.
Dit moet een fout zijn dat je misschien zie steeds algemeen als uw
programma's steeds complexer.
Maar er is een makkelijke oplossing.
Laat me terugbladeren hier.
>> En wat is de eerste fout zie ik?
Impliciete verklaring.
Wat betekent dat er meestal op wijst?
Oh, ik vergat het prototype.
Ik vergat om de compiler te leren dat swap gaat bestaan, ook al is hij
bestaat niet in het prille begin van het programma.
Dus ik ga gewoon zeggen leegte, swap, int, een int b, puntkomma.
>> Dus ik ben niet van plan om het te herimplementeren.
Maar nu dit overeenkomt met wat is hier beneden.
En merk op, het ontbreken van een puntkomma hier, die niet noodzakelijk wanneer
uitvoering.
>> Dus laat ik deze remake, maken geen swap.
Een veel betere vorm.
Lopen geen swap.
En verdomme.
Nu zijn we terug waar we waren op maandag, waar het ding niet ruilen.
>> En wat is de intuïtieve verklaring voor waarom dit het geval is?
Yeah?
>> STUDENT: [onverstaanbaar].
>> DAVID Malan: Precies.
Dus a en b zijn kopieën van x en y.
En in feite, elke keer dat je geweest bent het aanroepen van een functie die tot nu toe
passeert variabelen zoals ints -
net als swap wordt hier verwacht -
jullie zijn passeren in kopieën.
>> Nu, dat betekent dat het duurt een beetje van de tijd, een fractie van een seconde, voor de
computer om de bits van de ene kopiëren variabele in de bits van een andere.
Maar dat is niet zo'n groot probleem.
Maar ze zijn toch een kopie.
>> En dus nu, in het kader van de swap, Ik ben in feite succes
veranderende a en b.
Sterker nog, we doen een snelle sanity check.
Print f een is% i, nieuwe lijn.
En plug laten we in een.
Laten we nu hetzelfde doen met b.
En laten we hetzelfde doen hier.
>> En nu, laat me diezelfde lijn kopiëren weer op de bodem van de functie
na mijn drie lijnen van interessante konden uitgevoerd, en
afdrukken a en b nog maar eens.
Dus nu laten we deze, maken geen swap.
Laat ik het terminalvenster een make beetje groter, zodat we kunnen zien
meer ervan tegelijk.
>> En lopen geen swap.
x is 1, y is 2. a 1, b 2.
En dan, een 2 is, b 1.
Dus het werkt, net als Jess hier deed binnenkant van swap.
Maar natuurlijk, het is die geen effect hebben de belangrijkste variabelen.
>> Zo zagen we een truc waarbij wij zou dit op te lossen, toch?
Wanneer je geconfronteerd wordt met deze scoping kwestie, kon je gewoon punter en maak x
en y wat voor soort variabelen in plaats daarvan?
>> Je kon ze wereldwijd te maken.
Leg ze op de top van het bestand zoals wij deden, zelfs in het spel van 15.
We gebruiken een globale variabele.
Maar in de context van de spelers 15, is het redelijk om een ​​globaal hebben
variabele die de raad van bestuur, omdat het geheel van 15.c is alles
over de uitvoering van dat spel.
Dat is wat het bestand bestaat te doen.
>> Maar in dit geval hier, ik ben aanroepen van een functie swap.
Ik wil twee variabelen verwisselen.
En het moet gaan om gewoon slordig voelen Als de oplossing voor al onze
problemen wanneer we tegenkomen scope kwesties is maken het mondiale.
Omdat heel snel ons programma is gaat nogal een puinhoop geworden.
En wij deden dat zeer spaarzaam als resultaat 15.c.
>> Maar het blijkt dat er een betere manier helemaal.
Laat me eigenlijk terug te gaan en verwijder de printen f's, alleen maar om deze code te vereenvoudigen.
En laat me voorstellen dat Dit is inderdaad slecht.
Maar als ik in plaats daarvan toe te voegen in een aantal sterretjes en sterren, ik kan in plaats van dit te zetten
functie in een, dat is daadwerkelijk operationeel.
>> Dus laat me terug te gaan hier en toegeven zeggen sterretjes is altijd moeilijk,
dus ik zal sterren zeggen.
Ik zal gewoon fess tot die ene.
Oke.
En nu, wat ga ik om in plaats daarvan doen?
>> Dus in de eerste plaats, ik ga om aan te geven dat in plaats van het passeren van een int in
de swap-functie, ik ben in plaats van gaan zeggen int ster.
Nu, wat doet de ster aan te geven?
Dit is dat idee van een pointer die Binky, de claymation karakter, was
verwijst naar een moment geleden.
>> Dus als we zeggen int ster, de betekenis van Dit nu is dat een is niet van plan te zijn
doorgegeven door de waarde ervan.
Het zal niet worden gekopieerd inch
Integendeel, het adres van a zal worden doorgegeven inch
>> Zo herinneren dat de binnenkant van uw computer is een hele hoop geheugen, anders
bekend als RAM.
En dat RAM is gewoon een heleboel bytes.
Dus als je Mac of pc heeft twee gigabyte, je hebt 2
miljard bytes van het geheugen.
>> Nu laten we veronderstellen dat alleen maar om houden alles mooi en ordelijk, we
toekennen van een adres -
een aantal -
om elke byte RAM-geheugen in uw computer.
De eerste byte van de 2 miljard is door het getal nul.
De volgende is byte nummer een, nummer twee, helemaal op maximaal, dot dot
stip, tot ongeveer 2 miljard.
>> Zo kunt u het nummer van de bytes van het geheugen in de computer.
Dus laten we aannemen dat dat is wat we bedoelen met een adres.
Dus als ik zie int ster een, wat is er worden doorgegeven aan swap nu is het
adres van een.
Niet zijn waarde, maar wat zijn post adres is, om zo te zeggen -
zijn ligging in het RAM.
>> En zo ook voor b, ik ga om hetzelfde zeggen.
Int, ster, b.
Even terzijde, technisch de ster zou kunnen gaan op andere locaties.
Maar we zullen op de ster die standaardiseren direct naast het datatype.
>> Dus swap handtekening betekent nu, geef mij het adres van een int, en de oproep
dat adres een.
En geef me nog een adres van een int en roepen dat adres b.
>> Maar nu is mijn code hier moet veranderen.
Want als ik verklaar int temp -
die nog steeds van het type int -
maar ik opslaan in het een, wat voor waarde?
Om duidelijk te zijn, zet ik een een met de code zoals nu geschreven?
>> Ik zet de locatie in een.
Maar ik geef niet om de locatie nu, toch?
Temp bestaat net Jess 'derde beker bestond, voor welk doel?
Om een ​​waarde op te slaan.
Melk of jus d'orange.
Niet om daadwerkelijk het adres van slaan een van die dingen, die voelt een
beetje onzinnig in deze real wereld context toch.
>> Dus echt, wat ik wilt zetten in temp is het adres van een, maar de
inhoud van een.
Als a een getal als 123, is de 123ste byte van het geheugen dat een rechtvaardige
gebeurt te zijn bezettingsmacht, dat de waarde in een toevallig bezettingsmacht.
>> Als ik wil naar dat adres, Ik moet zeggen een ster.
Evenzo, als ik was om te veranderen wat is op het adres van een, ik verander
dit om te beginnen een.
Als ik wil opslaan in wat er op het locatie een met wat er op de locatie
bij b, ster b ster.
>> Dus in het kort, ook al is dit niet helemaal zinken in toch - en ik zou niet verwachten
dat het zo snel zou doen -
beseffen dat alles wat ik doe is prefixing deze sterren naar mijn variabelen,
gezegde niet de waarden te grijpen.
Niet met de waarden niet wijzigen.
Maar eerder naar die adressen en krijgen de waarde.
Ga naar dat adres en verandering de waarde daar.
>> Dus nu laat ik terugbladeren naar de top, alleen maar om deze lijn vast hier, op
verandert het prototype aan te passen.
Maar ik moet nu een ding doen.
Intuïtief, als ik het typen ben veranderd van argumenten die swap wordt verwacht,
wat heb ik nodig om verandering in mijn code?
>> Als ik bel swap.
Want nu, wat ben Ik passeren om nog ruilen?
De waarde x en de waarde van y, of de melk en het sinaasappelsap.
Maar ik wil niet om dat te doen.
Ik plaats langs wilt op wat?
De locatie van x en de locatie van y.
Wat zijn hun postadressen, zo te zeggen.
>> Dus om dat te doen, er is een ampersand.
Ampersand soort klinkt als adres.
zo n, ampersand, het adres van x, en het adres van y.
Dus het is opzettelijke die we gebruiken ampersands bij het aanroepen van de functie,
en sterren bij het declareren en wanneer de uitvoering van de functie.
>> En denk maar aan ampersand als de adres van de exploitant, en de ster als de
ga er exploitant -
of, beter gezegd, de dereference operator.
Dus dat is een heleboel woorden gewoon om zeggen dat nu, hopelijk, swap gaat
juist te zijn.
>> Laat me ga je gang en maak -
laten we daadwerkelijk het bestand te hernoemen, opdat dit programma nog worden genoemd geen swap.
Ik beweer dat we het nu swap.c zullen noemen.
Dus zorg, swap.
Punt, slash, swap.
>> En nu inderdaad, x is 1, y is 2.
En dan, x is 2, y is een.
Nou laten we eens kijken of we niet kunnen doen dit een beetje anders wat is
hier aan de hand.
Ten eerste wil ik inzoomen op onze tekenen hier scherm.
En laat me voorstellen voor een moment - en wanneer ik trek hier wordt gespiegeld
daar nu - laat me voorstellen dat hier is een hele hoop van het geheugen, of
RAM, binnenkant van mijn computer.
>> En dit zal bijten getal, laten we zeggen, 1.
Dit getal 2 bytes zijn.
En ik zal een hele hoop meer doen, en dan is een bos van dot dot stippen aan
geven aan dat er 2 miljard van deze dingen.
4, 5, enzovoort.
>> Zo zijn er de eerste vijf bytes van het geheugen van mijn computer.
Oke?
Zeer weinig van 2 miljard euro.
Maar nu ga ik voorstellen de volgende.
Ik ga om te stellen dat x gaat Sla het nummer 1, en y gaat
het getal 2 slaan.
En laat me nu ga je gang en vertegenwoordigt deze waarden als volgt.
>> Laten we dit als volgt doen.
Geef mij maar een seconde.
Een seconde.
OK.
Ik wil dit een beetje te maken -
laten we dit opnieuw doen.
Anders ga ik naar en het gebruik van de dezelfde nummers, onbedoeld,
meerdere keren.
>> Dus gewoon dus we hebben verschillende nummers om te praten over, laten we noemen dit byte
nummer 123, 124, 125, 126, en dot dot dot.
En laat me beweren nu dat ik ga zet de waarde 1 hier, en de waarde 2
hier, ook wel bekend als x en y.
Dus is het gewoon zo gebeurt het dat is x, y is.
>> En alleen door enkele willekeurige toeval, de computer, het besturingssysteem,
toevallig x zetten op locatie nummer 123.
En y eindigde op plaats 124 -
damn it.
Ik zou dit hebben bevestigd.
Oh man, ik wil dit echt doen?
Ja, ik wil dit en lossen b goede over dit vandaag.
Sorry, is nieuw voor mij.
>> 127, 131, en ik wilde niet om dit te complex, maar waarom heb ik de
nummers er?
Want ik wil de ints naar eigenlijk vier bytes.
Dus laten we super anaal over dit.
Zodat als 1 gebeurt te worden aangepakt 123, wordt de 2 zal worden op adres
127 omdat het gewoon 4 byes afstand.
Dat is alles.
En we vergeten al het andere adressen in de wereld.
>> Dus x is op locatie 123, y is op locatie 127.
En nu, wat doe ik eigenlijk willen doen?
Als ik bel swap nu, wat is eigenlijk aan de hand?
Nou, als ik roep swap, ik ben passeren in het adres van x en het adres van y.
Dus bijvoorbeeld als deze twee stukken van papier vertegenwoordigen nu de twee
argumenten a en b te verwisselen, wat ben ik ga schrijven op de eerste van deze,
die ik ga bellen naar verwijzen als een?
>> Precies, 123.
Dus dit ik beweer is een.
Dit is een parameter.
Ik zet het adres van x in.
>> Wat is dat?
>> Nee, nee.
Dat is OK.
Nog steeds goed, nog steeds goed.
Dus dit is een.
En nu op het tweede stuk papier, dit gaat worden b, en wat ben ik
zal worden schrijven op dit stuk papier?
127.
>> Dus het enige dat is veranderd sinds onze vorige vertellen van dit verhaal is,
in plaats van letterlijk 1 en 2, ik ben gaat pas in 123 en 127.
En ik ga nu deze binnen zetten van dit vak, oke?
Zodat de zwarte doos vertegenwoordigt nu de swap-functie.
>> Ondertussen, laten we nu iemand uitvoering van de swap-functie.
Zou iemand hier als vrijwilliger?
Kom maar naar boven.
Wat is je naam?
Charlie.
Oke, Charlie.
Kom maar naar boven.
>> Dus Charlie gaat spelen de rol van onze zwarte doos.
En Charlie, wat ik zou willen dat je doet Nu wordt uitvoering swap zodanig
dat, gezien deze twee adressen, je daadwerkelijk gaat
om de waarden te veranderen.
En ik zal in je oor fluisteren hoe je de tv hier draaien.
>> Dus ga je gang, en jij bent de zwarte doos.
Bereiken daar.
Welke waarden zie je voor een, en welke waarden zie je voor b?
>> CHARLIE: een is 123 en b is 127.
>> DAVID MALAN: OK, precies.
Nu pauzeren er voor slechts een moment.
Het eerste wat je gaat nu doen, volgens de code - die
Ik trek nu op het scherm -
gaat worden om een ​​beetje toe te wijzen beetje geheugen genaamd temp.
Dus ik ga om verder te gaan en geef je dat geheugen.
>> Dus dit gaat om een ​​derde variabele u toegankelijk zijn
je temp genoemd.
En wat ga je schrijven op de temp stuk papier?
>> CHARLIE: Pointers, toch?
>> DAVID MALAN: OK, ook niet se pointers.
Dus de regel code die ik heb gemarkeerd op de rechterkant,
laten we daar beginnen.
Het zegt ster een.
Dus een wordt momenteel het opslaan het nummer 123.
En gewoon intuïtief, wat leverde ster 123 betekenen?
>> Maar specifiek, als a 123, ster een betekent wat?
De waarde van een.
Of meer terloops, ga daar.
Dus laat me voorstellen dat, met de een in je hand, ga je gang en te behandelen die
alsof het een map.
En loop je over aan de computer geheugen, en vind ons wat is
op plaats 123.
Precies.
>> Zo zien we op plaats 123 wat natuurlijk?
OK, dus wat waarde nu bent u in te gaan op temp te zetten?
Precies.
Dus ga je gang en dat doen.
En schrijf het nummer 1 op het stuk van papier dat momenteel is getiteld temp.
>> En nu is de volgende stap dat je gaat implementeren
gaat worden wat.
Nou, aan de rechterkant van de volgende regel code is ster b. b, van
Natuurlijk, slaat een adres.
Deze richt 127.
Star b betekent wat, terloops spreken?
>> Ga naar die locatie.
Dus ga je gang en vind ons wat er op plaats 127.
OK.
Natuurlijk, op locatie 127, blijft de waarde 2.
Dus wat ga je nu heen te slaan bij wat er ook in de locatie in een?
Dus ster een middel naar de locatie van een.
Wat is de locatie een?
>> Precies.
Dus nu, als je wilt veranderen wat er op die locatie -
Ik zal doorgaan en lopen de gum zijn hier.
En nu zet het terug op de borstel.
Welk nummer je gaat schrijven in die lege doos nu?
>> Precies.
Dus deze regel code, om duidelijk te zijn - laat me pauze wat Charlie's doet en
hier op te wijzen, wat hij net gedaan is schrijven in dat vak op locatie 123
de waarde die eerder was bij b.
En dus hebben we nu inderdaad geïmplementeerd deze tweede regel code.
>> Nu helaas, er is nog een regel overgebleven.
Wat is nu in temp, letterlijk?
Het is natuurlijk de nummer een.
Dat is niet een adres.
Het is gewoon een aantal, soort een variabele uit een week.
>> En nu als je zegt ster b, dat betekent naar dit adres b, die van
Natuurlijk hier.
Dus zodra je er bent -
Ik zal doorgaan en wist wat er eigenlijk daar - en wat zijn je
ga nu schrijven op locatie 127?
>> CHARLIE: Temp, dat is een.
>> DAVID MALAN: Temp, dat is een.
En wat gebeurt er met temp op het einde?
Nou, we weten niet echt.
We hebben niet echt schelen.
Elke keer dat we een functie geïmplementeerd tot nu toe, alle lokale variabelen je hebt
zijn inderdaad lokaal.
En ze gewoon verdwijnen.
Ze worden teruggewonnen door het besturingssysteem systeem uiteindelijk.
>> Het feit dat de temperatuur nog waarde 1 is een soort van fundamenteel
oninteressant voor ons.
Oke, dus een applaus als we konden voor Charlie.
Zeer goed gedaan.
>> Oke, dus wat meer doet Hiermee bedoelen we kunnen doen?
Dus het blijkt dat we geweest zijn vertellen van een paar witte leugens
al geruime tijd.
Sterker nog, het blijkt dat een string, al die tijd, is niet echt een
reeks tekens per se.
Het soort is die intuïtief.
>> Maar technisch gezien, string is een datatype dat we binnen van de gedeclareerde
de CS50 bibliotheek om de wereld te vereenvoudigen voor de eerste paar weken van de klas.
Wat een string is echt is het adres van een personage ergens in RAM.
Een string is echt een getal, zoals 123 of 127, dat gebeurt te bakenen
wanneer een tekenreeks begint geheugen van uw computer.
>> Maar het vertegenwoordigt niet de koord, per se, zelf.
En we kunnen dit als volgt zien.
Laat me ga je gang en open een code die is onder
vandaag broncode voorbeelden.
En ik ga om verder te gaan en open up, laten we zeggen, vergelijk-0.c.
Dit is een buggy programma dat gaat worden uitgevoerd als volgt.
>> Eerste.
Ik ga iets zeggen.
Dan ga ik verder te gaan en krijgen een string van de gebruiker
in die volgende regel.
Dan ga ik het nog eens zeggen.
Dan ga ik naar een andere krijgen koord van de gebruiker.
>> En merk op, Ik laat een van de strings in een variabele genaamd s, en
andere van deze strings in een variabele met de naam t.
En nu ga ik te beweren, zeer redelijk, dat als s gelijk evenaart t,
de snaren zijn hetzelfde.
U typt het zelfde ding.
Else, de snaren zijn niet hetzelfde.
>> Immers, als we ingang twee ints, twee chars, twee drijvers, twee doubles, een van
de soorten gegevens die we hebben gesproken over tot nu toe te vergelijken -
herinneren we heel duidelijk een tijdje geleden gemaakt dat je dit niet doet, omdat een
isgelijkteken is natuurlijk de opdracht operator.
Zodat een fout zou zijn.
>> Wij gebruiken het gelijke gelijk-teken, die inderdaad vergelijkt
dingen voor echte gelijkheid.
Maar ik beweren dit is buggy.
Als ik ga je gang en maak vergelijken nul, en dan denk dot slash vergelijken nul.
En ik typ in, laten we zeggen, hallo.
En dan laten we weer gedag zeggen.
Letterlijk het zelfde ding, de computer aanspraken Ik verschillende dingen getypt.
>> Nu misschien heb ik gewoon verkeerd getypt iets.
Ik zal mijn naam typen dit keer.
Ik bedoel, hallo.
Hallo.
Het is elke keer weer anders.
>> Nou, waarom is dat?
Wat is er werkelijk aan de hand onder de motorkap?
Nou, wat er werkelijk aan de hand eronder de kap is de string dan
Ik typte in die eerste keer bijvoorbeeld is het woord hello, natuurlijk.
Maar als wij vertegenwoordigen deze eronder de motorkap, herinneren dat een
string in een array.
En we hebben zo veel gezegd in het verleden.
>> Dus als ik trek die array als dit, ik ben ga iets heel vertegenwoordigen
vergelijkbaar met wat we zojuist deden.
En er is eigenlijk iets hier speciaal, ook.
Wat hebben we te bepalen werd bij het einde van elke snaar?
Ja, dit backslash nul, dat is alleen de manier vertegenwoordigen,
letterlijk, 00000000.
0 acht bits in een rij.
>> Ik weet het niet, eerlijk gezegd, wat er na deze.
Dat is gewoon een stelletje meer RAM binnenkant van mijn computer.
Maar dit is een array.
We spraken over arrays vóór.
En we meestal praten over arrays als locatie nul,
dan een, dan twee.
Maar dat is alleen voor het gemak.
En dat is heel relatief.
>> Wanneer u daadwerkelijk krijgt geheugen uit de computer, het is natuurlijk een
2 miljard een aantal vreemde bytes, potentieel.
Dus echt onder de motorkap, al die tijd, ja.
Dit zou heel goed beugel nul.
Maar als je graaft nog dieper eronder de motorkap, dat is echt
aanpakken nummer 123.
Dit is adres 124.
Dit is adres 125.
>> En ik heb niet verpest dit moment.
Deze zijn nu een bytes afgezien om welke reden?
Hoe groot is een char?
Een char is slechts een byte.
Een int is typisch vier bytes.
Dus dat is waarom ik maakte het 123, 127, 131 enzovoorts.
Nu kan ik de wiskunde eenvoudiger te houden en gewoon doen plus 1.
En dit is nu wat er werkelijk aan de hand op onder de motorkap.
>> Dus als je iets als dit te verklaren, tekenreeks s, dit is eigenlijk -
het blijkt -
char ster.
Star, betekent natuurlijk adres, aka wijzer.
Dus het is het adres van iets.
Wat is daarin het adres van?
>> Well -
Ik ben de enige die het kan zien belangrijk punt dat ik wil maken, of denken
Ik ben het maken.
Dus touwtje -
het trieste is ik heb een monitor precies daar waar ik
zou hebben gezien dat.
>> Oke, dus tekenreeks s is wat Ik verklaarde eerder.
Maar het blijkt, dankzij een beetje magie in de CS50 bibliotheek deze, alle
tijd snaar heeft letterlijk geweest char ster.
De ster betekent weer pointer of adres.
Het feit dat het aan weerszijden van de woord char betekent dat het de
adres van een personage.
>> Dus als krijg string wordt genoemd, en ik typ in H-E-L-L-O, stellen nu wat er te krijgen
tekenreeks letterlijk terug al deze tijd, ook al hebben we liever
ongenuanceerd de wereld?
Wat doet krijgt snaar daadwerkelijk terugkeren als de return waarde?
>> 123 in dit geval, bijvoorbeeld.
We hebben al eerder gezegd dat krijgen snaar simpelweg geeft een string, een opeenvolging van
tekens.
Maar dat is een beetje een leugentje om bestwil.
De weg snaar echt werkt onder de motorkap is het krijgt een
koord van de gebruiker.
Het ploft de tekens die hij of zij vormen in het geheugen.
Het zet een backslash nul aan het eind van die reeks tekens.
>> Maar wat is dan krijgt touwtje letterlijk terug?
Het geeft letterlijk het adres van de eerste bytes in de RAM
het gebruikt voor die kracht.
En het blijkt dat alleen door terug te keren een adres van de
eerste teken in de reeks, dat is voldoende voor het vinden van het geheel van
de string.
>> Met andere woorden, krijgt koord geen tot 123, 124 en 125 terug.
Het hoeft niet om me een lange lijst van alle van de bytes die
mijn string wordt gebruikt.
Want een, ze zijn allemaal terug naar terug.
En twee, gebaseerd op het eerste adres, I kunnen achterhalen waar de string eindigt.
Hoe?
>> De speciale null karakter, de backslash nul eind.
Dus met andere woorden, indien u passeert rond -
binnenkant van variabelen -
het adres van een char, en je ervan uitgaan dat aan het eind van elke snaar, elke
opeenvolging van karakters als wij mensen denken van strijkers, als je ervan uitgaat dat
aan het einde van een koord er een backslash nul, je bent goud.
Omdat je altijd kunt vinden het einde van een koord.
>> Nu wat er echt dan gaan in dit programma?
Waarom is dit programma, vergelijk-0.c, buggy?
Wat er daadwerkelijk wordt vergeleken?
Yeah?
>> STUDENT: [onverstaanbaar].
>> DAVID Malan: Precies.
Het vergelijken van de locaties van de snaren.
Dus als de gebruiker hello keer in heeft getypt, zoals ik deed, zou het geheugen eindigen
zoek als dit.
Als de gebruiker vervolgens typen in hallo weer, maar door te bellen krijg touwtje weer, c is
niet bijzonder slim, tenzij je leren het slim te zijn door het schrijven van code.
>> C -
en computers algemeen -
als je hello opnieuw intypen van het woord, je weet wat je gaat krijgen.
Je bent gewoon gaat om een ​​tweede reeks te krijgen van het geheugen dat, ja, gebeurt wel
opslaan H-E-L-L-O enzovoort.
>> Het gaat om het zelfde te kijken ons mensen, maar dit adres
misschien niet 123.
Het zou net zo toevallig dat de besturingssysteem heeft enkele beschikbaar
ruimte voor bijvoorbeeld op locatie -
laten we iets willekeurige zeggen, als deze is locatie 200.
En dit is locatie 201.
En dit is locatie 202.
We hebben geen idee waar dat is gaat worden in het geheugen.
>> Maar wat dit betekent is dat wat is zal uiteindelijk worden opgeslagen s?
Het nummer 123.
Wat er gaat worden opgeslagen in t, In dit voorbeeld willekeurige?
Het nummer 200.
En dat alles betekent dan is natuurlijk, 123 is niet gelijk aan 200.
En dus dit als voorwaarde nooit de waarde true.
Omdat get string wordt met behulp van verschillende delen van het geheugen elke keer.
>> Nu kunnen we dit weer zien in een ander voorbeeld.
Laat me ga je gang en open up copy-0.c.
Ik eis dat dit voorbeeld gaat proberen - maar niet in slagen - om twee strings kopiëren
als volgt.
>> Ik ga iets zeggen de gebruiker.
Ik ben dan zal het krijgen string en noemen het s.
En nu, ik doe deze controle hier.
We vermelden dit een tijdje terug.
Maar wanneer zou touwtje return null krijgen, een ander speciaal teken, of speciale
symbool laten we zeggen.
Als het uit het geheugen.
>> Bijvoorbeeld, als de gebruiker echt zijn moeilijk en types een gruwelijke
aantal tekens in de toetsenbord en klappen op Enter.
Als dat aantal tekens kan het gewoon niet in het RAM passen om wat voor gek
reden, word goed touwtje zou heel goed terug null.
>> Of als uw programma zelf doet veel van andere dingen en er is gewoon
niet genoeg geheugen voor get snaar om te slagen, zou het eindigen
up terug null.
Maar laten we preciezer wat dit is.
Wat is de s-speler datatype echt?
Char ster.
>> Dus het blijkt nu kunnen we schil terug de laag van nul.
Blijkt, null is - ja, uiteraard een speciaal symbool.
Maar wat is het eigenlijk?
Echt, null is gewoon een symbool dat we mensen gebruiken nulpositie, vertegenwoordigen.
>> Dus de auteurs van C, en computers meer algemeen, besloten jaren geleden
dat, weet je wat.
Waarom gaan we niet garanderen dat er geen gebruiker data is ooit, ooit, ooit
opgeslagen bij bye nul?
In feite, zelfs in mijn willekeurige voorbeeld voor, ik niet beginnen nummeren van de
bytes op nul.
Ik ben begonnen bij een.
Omdat ik wist dat de mensen in de wereld hebben besloten de nul te behouden
byte in ieders geheugen als iets bijzonders.
>> De reden hiervoor is, wanneer je maar wilt signaal dat er iets mis is gegaan
met betrekking tot adressen, keert u terug null - ook wel bekend als nul -
en omdat je weet dat er geen legit gegevens op adres nul, duidelijk
dat betekent een fout.
En dat is waarom we, volgens afspraak, controleer voor null en terugkeer iets
zoals men in die gevallen.
>> Dus als we nu naar beneden scrollen, dit is gewoon dan komen er foutcontrole, voor het geval
ging er iets mis met [? borgtocht?]
helemaal en sluit het programma door terug te keren vroeg.
Deze lijn kon nu worden herschreven als dit, wat betekent wat?
Aan de linkerkant, geef me nog een pointer naar een karakter, en noem het t.
Wat ben ik het opslaan binnenkant van t, gebaseerd op deze ene regel code?
>> Ik ben het opslaan van een locatie.
Specifiek de locatie dat in s.
Dus als de gebruiker in hello heeft getypt, en die eerste hello toevallig belanden
hier, dan is het getal 123 is gaan om terug te komen van krijgen
rijgen en worden opgeslagen -
zoals we al eerder zeiden -
in s.
>> Als ik nu verklaar andere pointer naar een char en noem het t, welk nummer is
letterlijk gaan om te eindigen in t volgens het verhaal?
So 123.
>> Dus technisch gezien nu zowel s en t Er wordt naar de exacte
dezelfde delen van het geheugen.
Dus let op wat ik nu ga doen om bewijzen dat dit programma is buggy.
>> Eerst ga ik te beweren, met een print f, kapitaliseren
de kopie van de string.
Dan ga ik een beetje te doen foutcontrole.
Ik ga er zeker.
Laten we ervoor zorgen dat de string t is op althans groter dan nul in lengte,
dus er is wat karakter er om daadwerkelijk te kapitaliseren.
>> En dan kun je misschien dit herinneren uit eerdere voorbeelden.
2 boven - en dat is in het ctype.h bestand.
T beugel nul geeft mij de nul karakter van de string t.
En 2 bovenste van diezelfde waarde, van Natuurlijk, zet deze om naar hoofdletters.
>> Zo intuïtief, deze gemarkeerde lijn van de code wordt kapitaliseren de eerste
brief in t.
Maar het is niet kapitaliseren, intuïtief, de eerste letter in s.
Maar als je vooruit te denken, wat ben ik over om te zien wanneer ik dit programma uit te voeren
en print zowel de oorspronkelijke, s, en de zogenaamde exemplaar, t?
>> Ze daadwerkelijk gaat hetzelfde te zijn.
En waarom gaan ze hetzelfde zijn?
Ze zijn beiden wijzen op precies hetzelfde.
Dus laten we dit doen.
>> Maak kopie nul.
Het compileert OK.
Laat me copy nul draaien.
Laat me iets als hallo intypen alle kleine letters vervolgens op Enter.
En het stelt dat zowel de oorspronkelijke s en de kopie inderdaad identiek.
>> Dus wat er werkelijk hier gebeurd?
Laat ik deze foto net hertekenen om het verhaal te vertellen in een
iets andere manier.
Wat er echt gaande is onder de kap als ik iets verklaren als
char start s, of touwtje s, Ik krijg een pointer -
die toevallig vier bytes in het CS50 apparaat
en in veel computers.
En ik ga dit s bellen.
En dit heeft momenteel een onbekende waarde.
>> Wanneer u een variabele declareert, tenzij u jezelf een waarde daar, die
weet wat er staat.
Het kan enkele willekeurige reeks zijn bits van de vorige uitvoering.
Dus toen ik, in mijn regel code krijg touwtje, en dan slaan de terugkeer
waarde in s krijgen touwtje of andere manier -
en we zullen uiteindelijk schil terug hoe krijgen snaar werken, of andere manier wijst een
array die waarschijnlijk lijkt een beetje als dit.
H-E-L-L-O, backslash nul.
>> Laten we veronderstellen dat dit adres 123 gewoon eerst consistentie.
Dus maak je touwtje rendement, in de gemarkeerde lijn daar, keert de
nummer zeiden we, 123.
Dus wat er werkelijk gaat binnenkant van s hier?
>> Nou, wat er echt gaat binnenkant van s 123.
Maar eerlijk gezegd, ik word een beetje verward door al deze adressen,
al deze willekeurige getallen.
123, 124, 127.
Dus laten we daadwerkelijk vereenvoudigen de wereld een klein beetje.
>> Als we praten over pointers, eerlijk gezegd, om ons mensen, die de heck cares waar
dingen zijn in het geheugen?
Dat is volkomen willekeurig.
Het zal afhangen van hoe hoeveel RAM-geheugen heeft de gebruiker.
Het gaat over afhangen wanneer zij op de dag u het programma uitvoert, misschien, en
wat de inbreng van de gebruiker geeft.
We zijn woning aan onbelangrijke details.
>> Dus laten we abstracte weg en zeggen dat, wanneer u een regel code uitvoeren als dit,
char ster s krijgt de terugkeer waarde van get string.
Waarom gaan we niet in plaats daarvan alleen tekenen wat we blijven roepen een pointer alsof het
wijst op iets?
Dus ik beweren nu dat s up Er is een pointer -
onder de motorkap is het een adres.
Maar het is gewoon te wijzen op de eerste byte in de
tekenreeks die is teruggekeerd.
>> Als ik hier nu terug naar de code, wat er gaande is op deze lijn?
Nou, in dit gemarkeerde lijn nu, Ik ben blijkbaar een ander verklarend
variabele genaamd t.
Maar het is ook een pointer, dus ik ga te tekenen als, in theorie, de exacte
hetzelfde formaat doos.
En ik ga het t bellen.
>> En nu als we terug gaan naar de code opnieuw, toen ik opslaan s binnenkant van t,
wat ben ik technisch waardoor de binnenkant van t?
Nou technisch gezien, dit was het nummer 123.
Dus echt ik moet schrijven het nummer 123 daar.
Maar laten we het hogere niveau.
t, als het is gewoon een pointer, intuïtief, is enkel dat.
Dat is alles wat het zijn opgeslagen in daar.
>> Dus nu in de laatste interessante lijnen van de code, toen ik eigenlijk gaan over
kapitaliseren de nulteken in t, wat er gaande is?
Nou ja, is t beugel nul nu wijzen wat karakter, vermoedelijk?
>> Het wijzend naar h.
Omdat t bracket nul -
herinneren, dit is oude syntax. t bracket nul betekent alleen als t is een string, t
beugel nul betekent dat je de nul karakter die kracht.
Dus wat dat werkelijk betekent wordt naar deze array -
en ja, dit zou kunnen zijn 123, dit misschien 124.
Maar het is allemaal relatief, herinneren.
Wanneer het over een serie, hebben we het voordeel van praten over
relevante indices.
>> En dus nu kunnen we gewoon aannemen dat t beugel nul is h.
Dus als ik bel 2 boven op het, wat dat is eigenlijk doet is kapitaliseren
de kleine letter h te hoofdletters H. Maar natuurlijk, wat is s?
Het is die naar dezelfde darn string.
>> Dus dit is alles wat er is gebeurd in deze code tot nu toe.
Dus wat is dan de implicatie?
Hoe gaan we deze twee problemen op te lossen?
Hoe gaan we vergelijken met de werkelijke touwtjes?
>> Nou intuïtief, hoe zou je gaat over het vergelijken van twee
snaren voor echte gelijkheid?
>> Wat betekent het als er twee strings zijn gelijk?
Duidelijk niet dat hun adressen zijn gelijk in het geheugen, want dat is een lage
level implementatie detail.
Alle letters zijn hetzelfde.
Dus laat me voorstellen, en laat me even in versie een van compare.c
hier, dus vergelijk-1.c.
>> Laat ik stel voor dat we krijgen nog een pointer genaamd s, en op te slaan in het de
retourneren waarde van get string.
Laten we hetzelfde doen met t.
Zodat geen van de code is anders.
Ik ga een beetje toe te voegen meer fout nu controleren.
Dus nu dat we soort peeling terug Deze lagen in CS50 van wat een string
eigenlijk is, moeten we meer anaal over het maken van zorgen dat we geen misbruik
ongeldige waarden als null.
>> Dus ik ga gewoon om te controleren.
Als s is niet gelijk aan nul en t werkt niet gelijke null, dat betekent dat we op OK.
Ontvang touwtje niet verknallen krijgen een van deze snaren.
En je kunt misschien wel raden nu, wat doet STR CMP vermoedelijk doen?
String vergelijken.
>> Dus als je het programma in java heb vóór, dit is als de methode gelijk aan de
klasse String.
Maar voor degenen onder u die niet hebt geprogrammeerd voor,
dit is gewoon een c-functie.
Het gebeurt te komen in een bestand genaamd string.h.
Dat is waar het wordt gedeclareerd.
>> En string vergelijken -
Ik heb eigenlijk vergeten het gebruik ervan, maar nooit erg.
Bedenk dat we kunnen doen man, roer vergelijken.
En dit gaat om het Linux programmeurs handleiding.
En het is, eerlijk gezegd, een beetje cryptisch.
Maar ik kan hier zien dat, yep.
Ik moet string.h omvatten.
>> En er staat hier onder omschrijving, "de string vergelijker functie vergelijkt
de twee snaren S1 en S2. "En S1 en S2 zijn blijkbaar de twee
argumenten doorgegeven inch
Ik heb niet echt herinneren wat const, maar nu merken -
en misschien heb je al gezien dit bij heb je gebruik maken van de man-pagina's als u
hebben het allemaal -
dat char ster is gewoon synoniem met een touwtje.
>> Dus het vergelijkt de twee snaren, S1 en S2 en een integer retourneert minder
dan of gelijk aan of groter dan nul als S1 wordt gevonden, respectievelijk te
minder dan, of de wedstrijd, of groter dan S2.
Dat is gewoon een zeer complexe manier om te zeggen die string rendementen vergelijken
nul als twee tekenreeksen zijn intuïtief identiek karakter voor
karakter voor karakter.
>> Het geeft een negatief getal als s, alfabetisch, wordt verondersteld
te komen voordat t.
Of geeft een positief getal als s verondersteld na t komen
alfabetisch.
Dus met deze eenvoudige functie, kon u, bijvoorbeeld, sorteren een
heleboel woorden?
>> Dus in deze nieuwe versie, ik ga om verder te gaan en maak compare1.
Dot slash vergelijken een.
Ik typ in hello in alle kleine letters.
Ik ga om te typen in hello in alle kleine letters weer.
En gelukkig nu realiseert Ik typte het zelfde ding.
>> Ondertussen, als ik typ in hello in lagere zaak en HELLO in hoofdletters en
vergelijk ze, ik typte verschillende dingen.
Omdat niet alleen de adressen verschillend, maar we vergelijken
verschillende karakters opnieuw en opnieuw.
>> Nou laten we gaan en vast te stellen een ander probleem nu.
Laat me open versie een van exemplaar, dat nu gericht
dit probleem als volgt.
En deze gaat kijken een beetje ingewikkelder.
Maar als je nadenkt over welk probleem we moeten oplossen, hopelijk zal dit worden
duidelijk in slechts een moment nu.
>> Dus deze eerste lijn, char start t, in lekentaal kan iemand voorstellen
Wat deze lijn hier betekent?
Char ster t, wat is dat nou?
>> Goed.
Maak een pointer naar een aantal plek in het geheugen.
En laat me verfijnen het een beetje.
Verklaren een variabele die zal slaan de adres van enkele char in het geheugen, net
om een ​​beetje meer gepast.
>> OK, dus nu aan de rechterkant, ik heb nooit een van deze functies gezien
vóór, malloc.
Maar wat zou dat betekenen?
Toewijzing van het geheugen.
Geheugen toewijzing.
>> Zo blijkt, tot nu toe, we nog niet echt had een krachtige manier van
vraagt ​​het besturingssysteem, geef me wat geheugen.
Integendeel, we hebben nu een functie genaamd malloc dat precies dat doet.
Ook al is dit een beetje een afleiding nu, merken dat in
tussen twee haakjes gewoon gaan om een ​​nummer te zijn.
Waar ik in kwestie hebt getypt markeringen kan een nummer zijn.
>> En dat nummer betekent, geef me 10 bytes.
Geef me 20 bytes.
Geef me 100 bytes.
En malloc zal haar best doen om vraagt ​​het besturingssysteem -
Linux, in dit geval -
hey, zijn hun 100 bytes RAM-geheugen beschikbaar is?
Als dat zo is, terug die bytes aan mij door terugkerende waarvan het adres van
die bytes, misschien?
De allereerste.
>> Dus hier ook - en dit is overheersend in C, elke keer dat je
omgaan met adressen?
Je bent bijna altijd te maken met de eerst zoals adres, ongeacht hoe groot
een stuk van het geheugen u wordt teruggegeven, zo te zeggen.
>> Dus laten we duiken in hier.
Ik probeer te wijzen hoe veel bytes, precies?
Well.
String lengte van s - laten we doe een concreet voorbeeld.
Als s hello, H-E-L-L-O, wat is het snaarlengte van s, natuurlijk?
Dus het is vijf.
Maar ik ben bezig met een plus 1 op dat, waarom?
Waarom wil ik zes bytes in plaats van vijf?
De nul-karakter.
>> Ik wil niet te vertrekken uit deze speciale null karakter.
Want als ik een kopie maken van Hallo en gewoon doen H-E-L-L-O, maar ik doe er niet
dat bijzondere karakter, de computer misschien niet, bij toeval, een backslash
nul er voor mij.
En dus als ik probeer te achterhalen van de lengte van de kopie, zou ik denk dat
het is 20 karakters lang zijn, of een miljoen tekens lang zijn als ik gewoon nooit gebeuren
een backslash nul geraakt.
>> Dus moeten we zes bytes op te slaan H-E-L-L-O, backslash nul.
En dan is dit gewoon tot super anaal te zijn.
Stel dat ik vergeten wat de grootte van een char.
We blijven zeggen het is een byte.
En is het meestal.
In theorie zou het iets zijn anders, op een andere Mac of
verschillende PC.
>> Zo blijkt er deze operator riep sizeof dat als je het het passeren
naam van een data type - zoals char of int of float -
het zal u vertellen, dynamisch, hoeveel bytes een char neemt op dit
specifieke computer.
>> Dus dit is in feite gewoon als zeggen tijden 1 of
keer helemaal niets.
Maar ik doe het alleen maar om super anaal te zijn, dat voor het geval dat een char verschilt
op uw computer versus mijne, op deze manier de wiskunde gaat altijd uit te checken.
>> Tot slot, hier beneden kijk ik voor null, dat is altijd een goede gewoonte - weer,
elke keer dat we met pointers.
Als malloc was niet in staat om te geven me zes byes - dat is
onwaarschijnlijk, maar voor het geval -
onmiddellijk terug een.
En nu, ga je gang en kopieer str als volgt.
En dit is bekend syntax, zij het in een andere rol.
>> Ik ga om te gaan en krijgen de string lengte van s en opslaan in n.
Ik ben dan ga herhalen van i gelijk nul tot en met n,
groter dan of gelijk aan.
Zodat op elke iteratie, zet ik de ide karakter van s in de i
karakter van de t.
>> Dus wat er werkelijk aan de hand eronder de kap hier?
Goed als dit bijvoorbeeld is s -
en ik heb in het woord H-E-L-L-O getypt en er is een backslash nul.
En nogmaals, dit is s hier wijzen.
En nu hier is t.
>> En dit is nu wijst naar een kopie van het geheugen, toch?
Malloc heeft me een hele gegeven stuk van het geheugen.
Ik weet niet in eerste instantie wat in een van deze locaties.
Dus ik ga denken van deze als een hele hoop vraagtekens.
>> Maar zodra ik begin looping van nul op omhoog door de lengte van s, t
beugel nul en t beugel 1 -
en ik zal dit nu gezet de overhead -
t beugel nul en s beugel nul betekenen dat ik ga te kopiëren
iteratief h in hier, E-L-L-O. Plus, want ik heb de plus
1, backslash nul.
>> Dus nu bij vergelijk-1.c, in het einde, als ik afdruk van de
kapitalisatie van t, we moeten zien dat s is ongewijzigd.
Laat me nu ga je gang en doe dit.
Dus zorg copy1.
Dot slash copy1.
Ik ga om te typen in hello, Enter.
En let nu op, alleen de kopie is geactiveerd.
Omdat ik echt heb twee delen van het geheugen.
>> Helaas, kunt u een aantal mooie doen slecht en behoorlijk gevaarlijk dingen hier.
Laat ik trek een voorbeeld hier nu, dat geeft ons een voorbeeld van een paar
verschillende lijnen.
Dus gewoon intuïtief hier, de eerste lijn van de code, int ster x, is te verklaren
een variabele genaamd x.
En wat is het datatype van die variabele?
Wat is het gegevenstype van de variabele?
Dat was niet de cliffhanger.
>> De data type is int ster.
Dus wat betekent dat? x zal slaan het adres van een int.
Zo simpel is dat.
Y gaat het slaan adres van een int.
Wat is de derde regel van code daar aan het doen?
Het toewijzen van hoeveel bytes, waarschijnlijk?
Four.
Vanwege de grootte van een int is meestal vier, malloc van vier geeft
me terug het adres van een brok van geheugen, de eerste waarvan bytes
nu opgeslagen in x.
>> Nu we gaan een beetje snel.
Star x betekent wat?
Het betekent naar dat adres en zet welk nummer er?
Zet het nummer 42 daar.
Star y betekent naar wat er op y en zet het nummer 13 daar.
>> Maar wacht eens even.
Wat is in y op dit moment?
Wat adres is y het opslaan?
We weten niet, toch?
We hebben nog nooit een keer gebruik maken van de opdracht operator waarbij y.
Dus y die zijn aangegeven op de tweede regel van code is slechts enkele vuilnis waarde, een grote
vraagteken zo te zeggen.
Het kan willekeurig wijzen iets geheugen die
het algemeen slecht.
>> Dus zodra we raken die lijn daar, ster y is gelijk aan 13, iets slechts,
iets wat heel slecht is over gebeuren om Binky.
Dus laten we eens kijken wat er gaat uiteindelijk gebeurt hier Binky in deze minuut
of zo kijken.
>> [VIDEO AFSPELEN]
>> -He, Binky.
Wakker worden.
Het is tijd voor pointer lol.
>> -Wat is dat?
Meer informatie over pointers?
Oh, goodie.
>> -Nou, om te beginnen, ik denk dat we ga een paar pointers nodig.
>> -OK.
Deze code kent twee wijzers die kunnen wijzen op gehele getallen.
>> -OK, nou, ik zie de twee pointers.
Maar ze lijken niet te zijn wijzend naar iets.
>> -Dat klopt.
Aanvankelijk pointers niet wijzen naar iets.
De dingen die ze wijzen op zijn geroepen pointees, en de inrichting daarvan is een
afzonderlijke stap.
>> -Oh, rechts, rechts.
Ik wist dat.
De pointees zijn gescheiden.
Dus hoe kan je een pointee toewijzen?
>> -OK.
Nou, deze code wijst een nieuwe integers pointee, en dit deel stelt x
om te wijzen op het.
>> -He, dat ziet er beter uit.
Dus maak er iets aan te doen.
>> -OK.
Ik zal dereferentie de aanwijzer x op te slaan het nummer 42 in zijn pointee.
Voor deze truc, zal ik mijn magic nodig toverstok van dereferentie.
>> -Uw toverstaf van dereferentie?
Uh, dat is geweldig.
>> -Dit is wat de code eruit ziet.
Ik zal gewoon het opzetten van het nummer, en -
>> -He, kijk.
Daar gaat.
Daarbij een dereferentie op x volgt de pijl voor toegang tot haar pointee.
In dat geval bewaart 42 in.
Hey, probeer dan om het nummer op te slaan 13 via een andere aanwijzer, y.
>> -OK.
Ik ga gewoon hier naar y en krijgt het nummer 13 ingesteld.
En neem vervolgens de staf van dereferentie en net -
whoa!
>> -Oh, hey.
Dat werkte niet.
Zeggen, Binky, ik denk niet dat de dereferentie y is een goed idee,
omdat het opzetten van de pointee is een afzonderlijke stap.
En ik denk niet dat we ooit deden.
>> -Hmm.
Goed punt.
>> -Ja, toegewezen we de aanwijzer y.
Maar we hebben nooit instellen op wijzen op een pointee.
>> -Hmm.
Zeer oplettend.
>> -Hey, u op zoek bent goed daar, Binky.
Je kunt het vast, zodat y punten op dezelfde pointee als x?
>> -Sure.
Ik zal mijn toverstaf van gebruik pointer opdracht.
>> -Is dat gaat worden een probleem als voorheen?
>> -Nee.
Dit is niet de pointees raken.
Het verandert slechts een pointer punt op hetzelfde neer als een ander.
>> -Oh, zie ik.
Nu y wijst naar dezelfde plaats als x.
Dus wacht.
Nu y is bevestigd.
Het heeft een pointee.
Dus u kunt de staf proberen van opnieuw dereferentie
om de 13 sturen over.
>> -OK.
Hier gaat.
>> -He, kijk daar eens.
Nu dereferentie werkt op y.
En omdat de wijzers zijn het delen van dat pointee zij
zowel zie de 13.
>> -Ja.
Delen.
Whatever.
Dus gaan we switch plaatsen nu?
>> -Oh, kijk.
We hebben geen tijd meer.
>> -Maar -
>> -Vergeet de drie pointer regels.
Nummer een, de basisstructuur is dat je een pointer.
En het wijst op een pointee.
Maar de aanwijzer en pointee zijn gescheiden.
En de veel voorkomende fout is te het opzetten van een pointer, maar om
vergeten om gegeven een pointee.
>> Nummer twee, wijzer dereferentie start op de aanwijzer en volgt haar
pijl om, zodat de pointee.
Zoals we allemaal weten, dit werkt alleen als er is een pointee, die terug komt naar
regel nummer een.
>> Nummer drie, wijzer opdracht neemt een wijzer en veranderingen die het te wijzen op
dezelfde pointee als een aanwijzer.
Dus na de opdracht, de twee wijzers zullen
naar dezelfde pointee.
Soms is dat heet delen.
En dat is alles wat er is, echt.
Bye bye nu.
>> [END VIDEO AFSPELEN]
>> DAVID Malan: Dus meer op pointers, meer op Binky volgende week.
We zien je op maandag.