>> [Muziek]
>> ROB BODEN: Oke.
Dus, het eerste wat eerst, video van een bekend gezicht.
>> [VIDEO AFSPELEN]
>> -Oke.
Dit is CS50, en dit is het begin van de week drie.
Het spijt me dat ik kon er niet bij je vandaag, maar laat mij in te voeren
CS50 eigen Rob Boden.
>> [END VIDEO AFSPELEN]
>> [Applaus en gejuich]
>> ROB BODEN: De filmografie in die video is fantastisch.
Oke.
Dus eerst, er is nog een lunch.
Het is morgen om 01:15.
Er is geen lunch deze vrijdag.
Het is met Quora.
En Tommy is er nog niet, maar een van de mensen daar is voormalig hoofd CF,
Tommy McWilliam.
Dus hij is een leuke vent.
Je moet komen.
>> Oke.
Dus vorige week zijn we begonnen met het breken van elkaar over wat een string werkelijk is.
We weten al sinds het begin dat het is een reeks tekens.
Maar vorige week, we dook in het feit dat wat is eigenlijk een opeenvolging van
personages, goed, hebben we nu arrays van karakters.
En we weten dat een string, het is een array karakters, aan het einde,
we hebben deze speciale null byte, dit backslash 0, die aangeeft eind
de string.
>> En dus een string is een array van karakters, maar we kunnen meer dan
onder reeks karakters, kunnen we een verzameling volgens hebben
type wat we willen.
Dus, als u zich herinneren van vorige week, de Leeftijden programma dat David geïntroduceerd
heel snel.
Dus eerste wat we gaan doen is vraagt ​​de gebruiker om een ​​geheel getal, de
aantal mensen in de kamer.
Zodra we dat integer, we verklaren een array.
Let op deze syntaxis beugel.
Je gaat wennen.
>> Dus we verklaren een array van integers genoemd leeftijden en er n
getallen in deze array.
Dus dit patroon hier, dit 4 int i gelijk is aan 0, i kleiner dan n, i plus
plus, dat gaat ook om een ​​patroon te zijn dat je erg wennen.
Want dat is vrij veel hoe je bent altijd gaat om itereren over arrays.
Dus onthoud dat n de lengte van onze array.
En dus even, we voortdurend aan voor de leeftijd van de persoon die ik in de kamer.
>> Hierna gaan we naar beneden, en om welke arbitraire reden, dan kunnen we
uitprinten hoe oud ze gaan een jaar vanaf nu.
En lopen dat programma, laten we maken leeftijden, dot slash leeftijden.
Dus het aantal mensen in de kamer, laten we zeggen dat er drie.
En zeg, de eerste persoon is 13, volgende is 26, en de laatste is 30.
Dus dan is het wel over die drie herhalen mensen een afdruk van 14, 27, en 31.
>> Dus vergeet niet dat wanneer we verklaren een matrix van grootte n, de indices in die
array, de array waarden en indices 0, 1, 2, de hele weg
tot n minus 1.
Dus toen we zeiden dat er drie mensen in de kamer, en we zetten hier
de eerste iteratie via deze lus, ik zal worden 0.
Dus in index 0.
We zijn het toewijzen van de eerste de leeftijd van de gebruiker invoert.
Dan in de volgende, we zijn het invoeren van de tweede n de gebruiker invoert, en in
naast twee, de laatste n.
>> Zo merken dat een array van grootte drie niets hebben
in de index drie.
Dit is niet geldig.
Oke.
Dus, terug te gaan hier.
Dus nu dat we hebben behandeld met arrays, we hebben enige vertrouwdheid.
Nu gaan we om verder te gaan naar command line argumenten, die zullen worden
vrij relevant voor dit probleem set.
>> Dus tot nu toe, wanneer je hebt uw belangrijkste functie verklaard, we hebben
zei int main nietig.
Dus leegte betekent gewoon dat we lopen niet elke
argumenten voor deze functie.
Nu gaan we om de hoofdklasse zien kunnen enkele argumenten nemen.
Ze hier noemen we int argc en strijkorkest argv beugels.
De beugels opnieuw aangeeft dat we te maken hebben met arrays.
Dus hier, touwtje argv haakjes, we zijn te maken met een array van strings.
Dus argc, dat gaat geven hoeveel argumenten we hebben
doorgegeven aan het programma.
En om te zien wat dat betekent, laten we sluiten dit.
>> OK.
Dus tot nu toe hebben we elke run programma zoals dot slash leeftijden.
We kunnen ook op de opdrachtregel, verleden gaat worden, vandaar de term, commando
line argumenten.
Dus het eerste argument, hello wereld.
Dus hier, zou argc drie.
Het is de telling van de argumenten op de opdrachtregel.
Argc is altijd minimaal 1, omdat dot slash leeftijden, zelf, geldt als een van
de commandoregel argumenten.
>> Dan is hello de eerste.
Als dot slash leeftijden is de nulde, dan hallo is de eerste, en de wereld is de
tweede command line argument.
Dus de string argv, we zullen gaan zien, bevat de snaren, dot slash
leeftijden, hello, en de wereld.
En, op verzoek van David, we gaan om een ​​video te introduceren die spelen.
>> [VIDEO AFSPELEN]
>> -Tot nu toe in de programma's die we hebben geschreven, hebben we verklaren
hoofd als int main nietig.
En al die tijd, die leegte heeft gewoon is bepaald dat de
programma geen rekening command line argumenten.
Met andere woorden, wanneer een gebruiker loopt een programma, kan hij of zij opdracht te verstrekken
line argumenten door het schrijven van extra woorden of zinnen na het programma
naam op de prompt.
>> Nou, als je je je programma te willen neem command line argumenten, een of
meer van dergelijke woorden, we moeten vervangen vervalt met een paar argumenten.
Dus laten we dat doen.
Omvatten CS50.h.
Zijn standaard io.h.
Int main.
En nu, in plaats van leegte, ik ga specificeren een int argc genaamd, en een
array van strings genaamd argv.
Nu, argc en argv zijn gewoon verdragen.
>> We konden deze argumenten hebben genoemd meeste wat we willen.
Maar wat belangrijk is, is dat argc een int omdat, per definitie, is
gaat de telling argument bevatten, de aantal woorden dat de totale
gebruiker heeft getypt op zijn of haar prompt.
argv, ondertussen, argument vector, is naar een array opslaan eigenlijk
alle woorden die de gebruiker heeft getypt op zijn of haar prompt.
>> Laten we gaan nu iets doen met een of meer van deze
command line argumenten.
In het bijzonder, laten we verder gaan en druk welk woord de gebruiker typt
achter de naam van het programma bij de prompt.
Open beugel.
Haakje sluiten.
Printf procent s backslash en komma.
En nu moet ik printf welke waarde vertellen aan te sluiten op die placeholder.
Ik wil het eerste woord dat de gebruiker heeft getypt achter de naam van het programma,
en dus ik ga om aan te geven argv beugel 1, dicht
haakjes, puntkomma.
>> Nu, waarom beugel 1 en niet beugel 0?
Nou, het blijkt, automatisch opgeslagen in argv 0 gaat worden de
werkelijke naam van het programma's.
Dus het eerste woord dat de gebruiker typt achter de naam van het programma is, door
conventie, zal worden opgeslagen in argv 1.
Laten we nu samen te stellen en Dit programma starten.
>> Maak argv 0, dot slash argv 0.
En nu een woord als hallo.
Enter.
En daar hebben we het, hallo.
>> [END VIDEO AFSPELEN]
>> ROB BODEN: Oke.
Sluiten dat.
Zodat het nemen van een kijkje op dat programma dat we gewoon aan ons voorgesteld, nou ja, gewoon
om te laten zien, als we argv 0 drukken, maken, nu wat is het, argv 0, dot slash argv 0.
Dus, zoals verwacht, het afdrukken van de de naam van het programma, aangezien argv 0 is
altijd zal zijn de de naam van het programma.
Maar laten we iets doen een beetje interessanter.
>> Dus het probleem set, zult u geïntroduceerd om deze functie atoi.
Dus wat doen we gebruiken atoi voor?
Dat gaat zetten een string naar een integer.
Dus als ik langs de string, een twee drie, te atoi, dat zal zetten dat
aan integer, een twee drie.
Dus we gaan om te zetten de eerste command line argument om een ​​geheel getal,
en dan gewoon af te drukken dat integer.
>> Dus eigenlijk, we zijn soort herimplementeren getint, alleen de
integer is op het commando ingevoerd lijn in plaats van in het programma
interactief.
Zo dan, waardoor argv 0, laten we het doen het in hier, en sluit die.
Dus lopen argv 0, en laten we voer de integer, een twee drie vier een twee.
Dus het zal de integer te drukken, een twee drie vier een twee.
Er zijn een aantal subtiliteiten te atoi dat het zal stoppen met zorgen te maken over iets
dan geldig numeriek teken, maar dat maakt niet uit.
>> Dus wat denk je dat er gebeurt als ik dit doe?
Segmentation fault.
Dus waarom is dat?
Als je terugkijkt naar ons programma, we zijn omzetten argv 1, het eerste argument
na de naam van het programma, tot een geheel getal.
Maar er is geen argument dat wordt doorgegeven na de naam van het programma.
Dus hier zien we dat dit een buggy programma, omdat, als we proberen om het uit te voeren
zonder argumenten, het zal alleen maar crashen.
>> Dus een ander gemeenschappelijk patroon zie je is zoiets als, als argc minder
dan twee, wat aangeeft dat er geen ten minste de naam en een programma
eerste argument, dan gaan we iets doen zoals printf, niet genoeg
command line argumenten.
Dat is waarschijnlijk niet een goede om af te drukken, het is waarschijnlijk iets, zoals
moet u een geheel getal invoeren op de opdrachtregel.
Ik zal gewoon uiteindelijk het daar.
En dan terug 1.
Dus denk eraan dat aan het einde van onze programma, als we 0 terug, dat soort
geeft aan succes.
En main ook automatisch geeft 0 als je dat niet.
>> Dus hier zijn we opnieuw afstemmen 1 om aan te geven dat dat niet succes.
En je kunt terugkeren wat je wilt, net, 0 geeft succes, en
iets anders aangeeft mislukking.
Dus laten we lopen deze versie van de dingen.
Dus nu, als we niet een opdrachtregel in te voeren argument, zal het juist vertellen
ons, niet genoeg command line.
Heeft de zin niet af.
Anders, als we eigenlijk pas het een, kan het programma compleet.
Dus dit is hoe je argc zou gebruiken in Om het aantal valideren
command line argumenten die ook worden doorberekend.
>> Dus laten we dit programma een beetje meer ingewikkeld, en kijk naar de tweede
iteratie van de dingen.
Dus nu zijn we niet alleen het afdrukken van de eerste command line argument.
Hier zijn we itereren van int i gelijken 0, i minder dan argc, i plus
plus, en afdrukken argv, index i.
Dus dit patroon nogmaals, dit is hetzelfde patroon als hiervoor, behalve in plaats
van het aanroepen van de variabele n, gebruiken we argc.
>> Dus dit is itereren over elke index in de array, en afdrukken van elk
element in die array.
En ja, wanneer we dit programma uitvoert, goed, Ik heb geen command line niet betreden
argumenten, zodat het net prints de naam van het programma.
Als ik een hoop dingen, het zal U kunt een, elk op zijn eigen lijn.
>> OK.
Dus laten we nog een stap verder.
En in plaats van het afdrukken van elk argument op zijn eigen lijn, laten we elkaar drukken
karakter van elk argument op zijn eigen lijn.
Dus onthoud dat argv een array van strings.
Dus wat is een string, maar een array van karakters?
Dus dat betekent dat argv is echt een matrix van een array van karakters.
Dus het voordeel dat, laten we negeren dit voor nu.
Laten we maar eens kijken naar de string argv 0.
>> Dus als we willen om elk teken voor brengen argv 0 op zijn eigen lijn, dan wil ik
om het patroon dat we gewend zijn te doen, i minder dan de lengte van de array,
die hier wordt strlen van, dat is niet wat ik wil doen, touwtje
s gelijk argv 0.
Dus i kleiner is dan de lengte van ons matrix, die in dit geval een matrix
karakters, i plus plus.
En dus, zoals we zagen vorige week, is het ideaal als we gaan die buiten strlen
van de voorwaarde, aangezien n het toevoegen de strlen van s elke keer dat we gaan
door de lus, en het is niet van plan te veranderen.
Dus zullen we het gelijk aan n hier stellen.
>> OK.
Dus nu zijn we itereren over elke index in de array.
En dus, als we willen elke afdrukken tekens in die matrix, percenten c
de vlag die we willen gebruiken voor karakters.
En nu een beugel i gaat worden de snaar, index karakter i, dus als de
koord waren hello.
dan is 0 gaat h bedragen, s beugel 1 zal e, enzovoort.
>> Dus nu willen we combineren deze twee dingen.
We willen elk personage afdrukken van elke command line argument.
Dus we zullen moeten een geneste lus.
En conventioneel, de eerste teller i is, de volgende zal zijn j, n
zal de strlen van argv i zijn, i is kleiner dan n, i plus plus.
En nu in plaats van druk argv i, dus argv beugel i gaat index -
dat gaat om het i-de command line worden argument, argv i, j gaat
als jde karakter het i-de argument.
Ik zal zich te ontdoen van dit hier nu omdat we het in die lus.
Dus is gelijk aan tekenreeks s gelijken argv i, en dan j s beugel.
>> Nou, we hoeven niet te verklaren deze variabele s.
In plaats daarvan, zullen we gewoon deze combineren twee in wat we hadden, argv i, j.
>> LUIDSPREKER 1: [onverstaanbaar].
>> ROB BODEN: Goed gesprek.
Dus dit is gebroken.
Als ik eigenlijk liep, zouden we hebben gerealiseerd.
Dus de balie waar ik om geef in dit voor
lus is j, de iterator.
Dus u zou hebben problemen optreden, waarschijnlijk een oneindige lus, als we
had niet vast dat.
Dat is waarom we ook praten over het debuggen van vandaag.
>> OK.
Dus laten we lopen dit programma.
En laten we daadwerkelijk toe te voegen een aparte printf hier die maar af te drukken
een andere lijn, aangezien dit betekent dat wanneer we start het programma, zal er een leeg
lijn tussen elk teken van elke command line argument.
Nou, we zullen zien wat dat betekent.
Oop.
Ik kreeg een aantal bug.
Fout impliciet verklaren bibliotheekfunctie strlen.
>> Dus terug in ons programma, ik vergat om hash bevatten string.h.
Dus string.h gaat worden de header-bestand dat verklaart
de functie strlen.
OK, het compileert.
Nu, laten we lopen het.
Dus gewoon dat.
Het gaat om afdrukken onze programmanaam, hello wereld.
Het gaat om elk ding te printen, elk karakter, op een afzonderlijke regel.
OK.
>> Dus laten we eigenlijk dit nemen een stap verder.
En in plaats van het gebruik van string.h, laten we nadenken over hoe we onze eigen zouden implementeren
strlen functie.
Dus ik zal onmiddellijk geven een functie handtekening.
Dus laten we noemen in my_strlen, en het is gaat om een ​​string te nemen als argument,
en we verwachten dat de terugkeer van de lengte van die string.
Dus, waar is die vent?
Ja.
OK.
Dus onthoud van de eerdere dia die was ook van vorige week, dat een
scala aan personages, nou ja, een string, dus laten we zeggen dat dit onze tekenreeks s.
Dus als s is de string, hello, dan, H-E-L-L-O, in het geheugen, dat gaat
zijn, en dan dit backslash 0 karakter.
>> Dus hoe krijgen we de lengte van s?
Nou, de truc is op zoek naar deze terugslag 0 karakter, deze null
terminator.
Dus het algoritme Gaat iets als weinigen
genoeg tekens die -
laten we deze hand vertegenwoordigen ongeveer teller, laten we noemen dit int lengte.
Dus, vanaf hier zijn we gaan itereren over onze string.
>> Dus het eerste teken, het is H, en het is niet terug slash 0, dus
de lengte 1.
Herhalen om het volgende teken, E, en het is niet backslash 0.
Lengte is 2.
L, 3.
L, 4.
O, 5.
En tenslotte, backslash bereiken we 0, en dus dat betekent, goed,
deze string is voorbij.
Dus laten we terugkeren 5.
>> Dus eigenlijk uitvoering van dat, ten eerste, mijn n lengte gelijk is aan 0, mijn rechterhand.
En we gaan herhalen -
>> LUIDSPREKER 1: [onverstaanbaar]
>> ROB BODEN: Oh, schieten.
Goed gesprek.
Boom.
Zo n lengte gelijk is aan 0.
Dus nu, terwijl s lengte niet gelijk en dan, backslash 0.
Dus denk eraan, dit backslash 0, het is een werkelijke karakter, en het geeft
het einde van de string.
Net als, ook, backslash n is een echte karakter.
Backslash 0 gaat om aan te geven het einde van onze string.
Ik wil niet daar we deze.
En terwijl s geïndexeerd lengte niet gelijk aan de null-terminator, dan
we gaan gewoon op lengte te verhogen.
Zo dan, aan het einde van ons programma, lengte uiteindelijk zal
5 zijn in dit geval.
En we gaan gewoon terug lengte.
>> OK.
Dus nu hier beneden, ik niet doen my_strlen.
Laten we compileren om ervoor te zorgen alles op rolletjes loopt.
Deed ik in 2?
Of was dat 1?
Dat zou moeten doen.
Oke.
Dus dit is argv 2.
Werkt zoals verwacht, hoewel was dat degene die ik deed het in?
Ja.
OK.
Deze versie van de dingen niet hoefde de printf nieuwe regel na, maar het
maakt geen verschil maken.
OK.
Dus werkte zoals verwacht.
>> Nu kunnen we zelfs nog een stap te combineren verder, indien een aankondiging hier, goed,
eerste, we grijpen de strlen van argv i, en dan zijn we itereren over
elk teken in die string.
Dus in plaats van dat te doen, wat als we gewoon combineren deze logica van het wachten
totdat wij slaan backslash 0 rechts in deze for-lus?
Dus herhalen terwijl argv i, j doet niet gelijk backslash 0.
Dus laten we eerst voer het uit.
>> Oke.
Dus hier, wordt deze voorwaarde te zeggen -
Laten we duidelijk zijn dat.
Dus nu, laat dit onze argv.
Dus toen liep ik net dat programma voor, argv is een array van strings.
En dus, als ik zonder het met dot slash argv 2, hallo wereld, dan de argv
zelf is de lengte 3, voor argv nul, hello, en de wereld.
>> En de binnenkant van elk van deze indices, zelf een array, waar dit zal zijn
stip, dit zal slash zijn, weet ik niet als dat de goede richting, ik
denk niet dat het was.
A-R-V dash, meer ruimte nodig.
Laten we gesneden in deze array.
A-R-V dash 0, en vervolgens backslash 0.
En dan in de war zal zijn hello.
Laten we zeggen, H-E backslash 0.
En tenslotte, W-O backslash 0.
>> Zodat het algoritme dat we net schreef, de geneste for-lussen, wat ze
doen is, moeten we eerst de i en j tegen te gaan.
Dit zou makkelijker met code op het s scherm, laten we terug naar deze te gaan.
OK.
Zo merken dat i de iterator dat is itereren over elke opdracht
lijn argument.
En j is de iterator iteratie over elk personage in dat
command line argument.
Dus wat dit binnenste printf doet is, hebben we argv 0 0, printf printf
argv 0 1, printf argv 0 2 0 3 0 4 0 5, 0 6, maar nu, argv 0 7 gaat
gelijke backslash 0.
>> Dus dan dat verlaten we voor loop, en nu heb ik herhaalt tot 1.
En nu gaan we om af te drukken argv 1 0, argv 1 1 -
goed, nu, want ik snijd hello kort, argv 1 2 weer gaat worden
backslash 0.
En dus, in stappen i en voort te zetten, en zo verder, totdat we printen alle
wereld, en dat zijn drie opdrachtregel argumenten, en we zullen verlaten van
de buitenste lus, en eindigen onze programma.
OK.
>> Dus laten we hier terug te komen.
Dus je zult enige vertrouwdheid met winnen command line argumenten op deze
bijzonder probleem stellen.
>> Nu, debuggen.
Dus heb je waarschijnlijk al moest doen sommige debuggen met uw vorige
probleem stellen.
En een zeer eenvoudige manier van debuggen, laten we eerst eens kijken naar een buggy programma.
Nou, wandelen door dit programma, we gaan naar de gebruiker voor een vraag
integer, pak dat integer, en dan, willekeurig, we hebben een tijdje lus die
is gewoon te verlagen i totdat het is gelijk aan 10.
Laten we aannemen dat ik het invoeren een geheel getal groter dan 10.
Dus verlagen i totdat het gelijk is aan 10.
>> En dan hebben we nog een tijdje lus dat, terwijl ik niet gelijk 0, we zijn
ga i verlagen door 3.
Dus als je de intentie van de bug hier, het is dat dit zal verlagen i te
zijn 10, en dan is deze while loop wil decrement i van 10, 7, 4, 1,
negatieve 2, negatieve 5, enzovoort, naar negatief oneindig, want ik zal
eigenlijk nooit gelijk 0.
En vervolgens aan het eind van dit programma, we hebben de foo functie die
gaande uitdraai die ik.
>> Dus dit is een korte en triviale programma, en de bug is duidelijk,
vooral nadat ik net gezegd wat de bug was.
Maar de bedoeling hier is, nou ja, dit zou eigenlijk uit een aantal van uw
oplossingen van hebzuchtige uit de laatste probleem stellen, en misschien moet je wel
sommige oneindige lus in uw programma, en je hebt geen idee
wat de oorzaak is.
Dus een zeer nuttige debugging techniek is om gewoon printfs voegen
over je code.
>> Dus hier wil ik een printf buiten eerste while lus.
En hier wil ik een printf, en ik zal gewoon uitprinten i.
Ik zal zelfs eerst doen terwijl lus, i.
Buiten, tweede while lus.
Nogmaals, afdrukken binnen van hier, de waarde i.
En laten we dit uitvoeren.
>> Dus dot slash debug.
Voer een geheel getal.
Laten we het doen 13.
En giek.
We zien dat we oneindig looping binnenkant van de tweede while lus.
Dus nu weten we wat de bug is.
Maar printf debugging is perfect geweldig, maar zodra je programma's te krijgen
langer en ingewikkelder, er meer geavanceerde oplossingen
getting things werken.
Dus laten verwijderen al deze printfs.
En laten we ervoor zorgen dat ik niet breken iets.
OK.
>> Zodat het programma gaan we invoeren heet
GDB, voor GNU Debugger.
Nou, laten we verwijderen debug voor een tweede, en opnieuw maken debug.
Nou, eigenlijk voor het eerst, een goede les in de command line argumenten.
Merk op dat deze Clang opdracht die compileren alles wordt doorgegeven
op de opdrachtregel, deze command line argumenten.
Dus precies hoe je gaat worden met behulp van command line argumenten, zoals we
eerder deed, en zoals u zult in PSET 2, dat is hoe Clang is het gebruik ervan.
>> Zo merken dat deze eerste vlag, dash ggdb3, wat dat is te zeggen, Clang,
U moet dit bestand met het compileren bedoeling dat wij uiteindelijk zullen
nodig om het te debuggen.
Dus zolang je die vlag, dan kunnen we GDB debuggen.
En het zal het openstellen van de GNU Debugger.
>> Dus er zijn een heleboel opdrachten die je nodig hebt om te wennen aan.
Eerste dat je waarschijnlijk direct nodig is Run.
Dus wat is Run gaat doen?
Het gaat om ons programma te starten.
Dus ren, te beginnen, het programma vraagt ​​ons voor een geheel getal van 13.
En dan is het oneindig looping als verwacht, behalve dat ik verwijderde de
printfs, zodat we niet eens zien.
Normaal verlaten.
Oh.
Het is mogelijk dat het verpakt alle weg, terug naar - negeren dat.
Neem aan dat het niet normaal af te sluiten.
Er is een ingewikkeld antwoord.
>> Dus nu, dat is niet erg handig.
Dus gewoon het runnen van onze programma binnenkant van deze debugger helpt ons niet in een
manier, omdat we net hadden kunnen doen dot slash debug van buiten GDB.
Dus de ene opdracht die U zult waarschijnlijk -
en Ik zal dit stoppen.
Controle-d of stoppen, zowel werk.
Dus laten we openen weer op.
>> Een andere opdracht die u zult waarschijnlijk onmiddellijk wilt
wennen is Break.
Dus we zullen op de belangrijkste breken voor nu, en dan zal ik uitleggen.
Nou, hier zien we we een breekpunt op deze lijn in debug.c.
Dus wat breuk betekent is dat wanneer ik Typ run, is het programma gaat
blijven draaien totdat Ik raakte een breekpunt.
Dus toen ik raakte run, het programma begint, en dan breekt zodra
komt in de belangrijkste functie.
Break belangrijkste gaat iets worden je behoorlijk vaak doen.
>> En nu, om u kennis om wat meer commando's.
Let hier op, dat het is te zeggen dat we brak op lijn 11, die is
printf, voer een geheel getal.
Dus het commando Volgende gaat worden hoe gaan we naar de volgende regel code.
Dit zal ons toelaten om stap door middel van ons programma regel voor regel.
Dus de volgende.
>> Nu lijn 12, we gaan de integer krijgen.
Volgende.
En als je gewoon op weer invoeren, het zal opnieuw het laatste wat je hebt gedaan.
Dus ik hoef niet te typen volgende elke keer.
Dus vul een geheel getal van 13.
Dus nu, lijn 14, terwijl ik groter dan 10, en ik zal doen.
En we zien we gaan i verlagen.
Dus we gaan ik opnieuw verlagen.
>> Dus nu, een andere nuttige opdracht Afdrukken.
Dus Print gaat om uit te printen de waarde van de variabele.
Laten we brengen de waarde van variabele i.
Laten we drukken i.
Het zal zeggen dat ik is 11.
Nu opnieuw op Volgende we tijdens i groter is dan 10.
Dus ik is nog steeds groter dan 10, aangezien het 11.
i minus minus.
Laten we opnieuw af i.
Zoals verwacht, is het 10.
>> Dus nu, naast.
Het is terug naar de staat gaan, i groter dan 10, maar ik is nu 10, dus
het is niet meer dan 10, dus we verwachten het uit de while-lus te vallen.
En nu zijn we onder die regel code.
En een andere opdracht, List, wordt gewoon naar de vorige en volgende weer te geven
paar regels code, in geval je jezelf verloren.
Dus we verlieten deze while lus, en nu hebben we dit ingevoerd
terwijl lus, lijn 18.
Dus terwijl ik niet gelijk is aan 0.
En, volgende, ik gelijk i min 3, en we zullen opmerken, zullen dit gewoon doorgaan.
En we kunnen i drukken.
>> Elke opdracht heeft een soort van snelkoppelingen.
Dus p is een afkorting voor Print.
Dus we kunnen p i.
Gewoon blijven vasthouden n, of blijven doen Volgende.
Print ik opnieuw.
Je ziet nu dat het negatieve 167.
Dus dit zal eeuwig doorgaan, maar niet echt altijd, omdat je net zag, het
daadwerkelijk zal eindigen op een bepaald punt.
>> Dus dat is Beginning GDB.
Maar laten we een ding in GDB.
Uh, debuggen.
Dus, in dit geval, de oneindige lus toevallig binnenkant van
de belangrijkste functie.
En voor nu, gewoon accepteren dat ik ben gaan naar de oneindige lus te verplaatsen naar
de foo functie.
Vergeet niet dat, aan het einde van deze programma, goed, dit was oorspronkelijk
bellen foo, die net was gaat i te drukken.
Maar nu zijn we bellen foo, dat is ga ik verlagen tot het 0, en
vervolgens afdrukken die variabele.
OK.
Behalve dat.
Maken debug.
En nu, gdb debuggen.
OK.
>> Dus als ik gewoon lopen, dan ga ik niet naar in staat zijn om daadwerkelijk stappen door mijn
programma lijn per lijn.
Dus laten we breken op hoofd, en typ run.
Dus door deze, printf, voer een geheel getal, krijgen de integer, 13.
Dus we gaan verlagingsfuncties houden tot i groter is dan 10.
Dan gaan we vallen door de while loop, en maak kennis met de lijn -
laten openen in een apart venster.
Dus we verlaagd tot ik niet meer groter dan 10, en dan hebben we
genaamd de functie foo.
>> Dus wat is er gebeurd zodra ik hit function foo, goed, ik belde foo, en
dan had ik niet langer controle over GDB.
Dus zodra ik hit Volgende op deze lijn, dingen voortgezet tot dit gebeurde,
waar het programma verlaten wanneer -
neem aan dat het niet uiteindelijk bestaan.
Je zag het pauzeren voor een beetje maar.
Dus waarom heb ik de controle over verliezen het programma op dat punt?
Nou, als ik typ de volgende, dat gaat naar de letterlijke volgende regel code die
zal uitvoeren.
Dus na lijn 21, de volgende regel code dat zal uitvoeren is lijn 22,
dat is, het verlaten van de belangrijkste.
Dus ik wil niet alleen gaan naar de volgende regel code.
Ik wil in de functie, foo te gaan, en dan ook nog te doorlopen
die regels code.
>> Dus voor dat, hebben we een alternatief.
Laten we stoppen met dat weer.
Breken belangrijkste.
Uh, 1, volgende, volgende, 13, volgende, next, next, voorzichtig,
voordat we op lijn foo.
OK.
>> Dus nu zijn we op lijn 21, waar we foo noemen.
We willen niet de volgende typen, want dat gewoon bellen met de functie foo, en
ga naar de volgende regel code.
Wat we willen gebruiken is Step.
Dus er is een verschil tussen Step en Next, waar Step stapt in de
functioneren, en Next gaat over de functie.
Het voert alleen het geheel van de functie en blijft gaan.
>> Dus stap gaat ons brengen in de functie, foo.
En wij zien hier, nu, zijn we terug bij dit terwijl lus die, in theorie,
voor altijd blijven.
En als je stap, wanneer het niet eens raken een functie om te bellen, dan is
identiek aan Next.
Dus het is alleen als je op een lijn die roept een functie die stap
gaat afwijken van Next.
Dus stap zal ons hier te brengen.
Stap, stap, stap, stap, stap, stap, en We zullen gewoon oneindige lus altijd.
>> Dus je zou kunnen wennen aan dat als je manier van identificeren oneindige loops, is
alleen het houden van deze Enter om zien waar je vastloopt.
Er zijn betere manieren om dat te doen, maar voor nu, dat is volkomen voldoende.
En stilistisch, om te voldoen aan Style 50, moet ik dit heb gedaan.
OK.
>> Dus een laatste commando in te voeren.
Nou, laten we gdb debug inch
Dus in plaats van breken op hoofd, als ik weet de foo functie is ook de
probleem is, dan zou ik gewoon zei, breken op foo, plaats.
Laten we zeggen dat ik te breken op zowel het hoofd-foo.
Dus je kunt zoveel breekpunten als je wilt.
Wanneer ik run, het gaat te stoppen bij de -
ooh, laten we opnieuw compileren, aangezien Ik dingen veranderd.
Je zult deze lijn, Warning, bron zien bestand recenter is dan uitvoerbaar.
Dus dat betekent dat ik ging gewoon hier en veranderde deze te voldoen aan Style
50, maar ik heb niet opnieuw compileren het programma.
Dus GDB maakt me van bewust.
Ik zal stoppen, opnieuw te maken debug, hit gdb debug.
OK.
>> Dus nu, terug naar wat ik aan het doen was.
Breek belangrijkste, pauze foo.
Nu als ik zonder het programma, dus het is zullen blijven totdat raakt een
breekpunt.
Dat breekpunt overkomt als eerste aan de Main.
Nu, in plaats van het doen next, next, next, next, next, totdat ik raakte foo, ik
typen kunnen blijven, die zal blijven tot je het volgende breekpunt.
Ik moet het eerst een integer te voeren.
Ga verder zal blijven totdat ik raakte de volgende breekpunt, namelijk dat
functie van foo.
>> Dus Run zal lopen tot je een breekpunt, maar je alleen type termijn bij
je begint het programma, en dan, vanaf dat moment, het is voort te zetten.
Als ik net deed breken hoofd-en Vervolgens liep, zal het op te breken
belangrijkste, en ga dan verder.
Aangezien ik heb geen breekpunt bij foo, voer de integer, dan nu ben ik
niet gaat breken op foo.
Het zal alleen maar tot oneindig lus tot dat.
OK.
>> Dus dat is Inleiding tot GDB.
Je moet beginnen met het in uw probleem sets.
Het kan zeer nuttig zijn om bugs te identificeren.
Als je eigenlijk alleen maar, regel voor regel, go door je code, en vergelijk wat is
eigenlijk gebeurt met wat je verwacht te gebeuren, dan is het vrij
moeilijk om je fouten te missen.
OK.
>> Dus vorige week David bracht dit secret-key cryptografie spullen voor de
eerste keer, waar we niet willen wachtwoorden gewoon worden opgeslagen op onze
computer in sommige tekstbestand, waar iemand kan over en kom gewoon
open het en lees ze.
Idealiter zouden ze gecodeerd op een bepaalde manier.
En in Probleem Set 2, zult u te maken met een coderingsmethode,
of, nou ja, twee methoden, maar ze zijn niet zo groot.
Als je dat doet de hacker editie, je bent Ook zal te maken hebben met
decoderen van sommige dingen.
>> Dus de vraag is nu, goed, zelfs als wij hebben de sterkste encryptie
algoritme in de wereld, als u kiest voor een bijzonder slecht wachtwoord, dan is het
zal je niet veel helpen, omdat mensen nog steeds in staat om het te achterhalen.
Hoewel het zien van de gecodeerde string en het ziet eruit als een puinhoop van vuilnis
dat betekent niets voor hen, als ze nog hoeft alleen maar een paar wachtwoorden proberen
om het te achterhalen, dan moet je zijn niet erg veilig.
Dus kijken naar een video, die een maakt dat punt.
>> [VIDEO AFSPELEN]
>> -Helm, u Fiend.
Wat gebeurt er?
Wat doe je met mijn dochter?
>> -Sta mij toe te introduceren de briljante jonge plastisch chirurg, dr. Phillip
Schlotkin, de grootste neus werk man in het gehele
heelal, en Beverly Hills.
>> -Uwe Hoogheid.
>> -Nose job?
Ik begrijp het niet.
Ze heeft al een neuscorrectie.
Het was een zoete zestien aanwezig.
>> -Nee.
Het is niet wat je denkt.
Het is veel, veel erger.
Als je niet geef me de combinatie aan het luchtscherm, Dr Schlotkin zal
geef uw dochter terug haar oude neus.
>> -Nee.
Waar heb je dat vandaan?
>> -Oke.
Ik zal vertellen.
Nee, papa.
Nee, je moet niet.
>> Je hebt gelijk, mijn beste.
Ik mis je nieuwe neus.
Maar ik zal hem niet vertellen de combinatie, wat er ook gebeurt.
>> -Heel goed.
Dr Schlotkin, doe je ergste.
>> -Mijn plezier.
>> [TOOLS WORDT GESCHERPT]
>> -Nee.
Wacht.
Ik zal vertellen.
>> -Ik wist dat het zou werken.
Oke.
Geef het aan mij.
>> -De combinatie is een.
>> -One.
>> -Twee.
>> -Drie.
>> -Vier.
>> -Vijf.
>> -Dus de combinatie is een, twee, drie, vier, vijf.
Dat is het stomste combinatie Ik ooit in mijn leven gehoord.
Dat is het soort ding een idioot zou hebben op zijn bagage.
>> -Dank u, uw Hoogheid.
>> -Wat heb je gedaan?
>> -Ik zette de muur.
>> -Nee dat heb je niet.
Je zette de hele film.
>> -Ik moet de verkeerde knop heeft ingedrukt.
>> -Nou, zet hem weer aan.
Zet de film weer op.
>> -Ja, meneer.
Ja, meneer.
>> -Laten we gaan, Arnold.
Kom, Gretchen.
Natuurlijk, je weet dat ik je nog steeds moet u een factuur voor.
>> [END VIDEO AFSPELEN]
>> ROB BODEN: Oke.
Dus nu dat we al hebben het over veiligheid in sommige opzichten, mooie
weinig filmposter, dus in de afgelopen dagen, deze onderwerpen met de NSA
alles te monitoren.
Het kan moeilijk zijn om het gevoel dat je hebben een soort van de persoonlijke levenssfeer in de
online wereld, maar ik kon niet vertellen je de meeste van de gegevens van PRISM.
Dus die verder gaat dan PRISM, we gaan niet te praten over dat, nu
denk aan uw laptop.
Dus hier, ik wil overschakelen mijn echte rekening,
met mijn kleine pinguïn.
Dus ik heb een wachtwoord ingesteld, en dat wachtwoord is wat ik wil dat het is.
>> Maar vergeet niet dat wat ik in te loggen in met, dus dit login
prompt, is een programma.
Het is een programma dat was geschreven door een persoon.
En ja, die persoon, als ze bijzonder kwaadaardig, ze konden
hebben gezegd, oke, dus als het wachtwoord dat ik binnenkom is gelijk aan mijn
werkelijke wachtwoord, of het gelijk een aantal speciale wachtwoord -
David is geweldig of iets -
laat ze dan binnen
Dus een kwaadwillende programmeur zou kunnen hebben toegang tot al je Macs, of
Windows, of wat dan ook.
>> Dus dat is niet veel van een zorg, omdat, Ik bedoel, dit is login programma
dat is geleverd met OS X, honderden of duizenden mensen
beoordeeld deze code.
En dus, als, in je code ergens, je zeggen als deze string gelijk gelijken
David is geweldig, inloggen, dan iemand is gaat worden, zoals, wacht.
Dit klopt niet.
Dit moet hier niet zijn.
Dus dat is een manier krijgen we dingen van de soort veilig te zijn.
>> Maar denk eens zelfs programma die je schrijft.
Laten we zeggen dat je het programma login schreef.
Dus deze login programma dat je hebt geschreven, zo duidelijk, je bent een goede
programmeur.
Je gaat niet een kwaadaardige zetten als x gelijk gelijk David is geweldig
in je code.
Maar dit programma, wat je doet gebruiken om dit programma te compileren?
Zoiets als Clang.
Dus wat als de persoon die naar gebeurd schrijf Clang speciale gevat in Clang
zoiets, als ik het samenstellen van de inloggen programma, voer dan deze code
in het login programma dat zegt, als x gelijk is gelijk aan David is awesome?
Dus nog niet helemaal, maar we hebben dezelfde geven hier, waar Clang, goed,
duizenden of zelfs tienduizenden mensen, hebben gekeken naar Clang, hebben
keek naar haar regels code en zei: oke, er is niets slecht hier.
Uiteraard is niemand doet alles wat deze kwaadaardige.
>> Maar wat is zelf Clang, zoals, wat als ik compileren Clang?
Wat als ik een aantal compiler die compileert Clang dat voegt in Clang
deze speciale hack die zegt, oke, toen ik compileren Clang, dan is de
uitvoerbare Ik krijg moeten speciaal kijken binnenkant van het programma login en insert
Dit wachtwoord is gelijk aan gelijken Dave is geweldig?
Dus vergeet niet dat je compiler zelf moet op een gegeven moment worden opgesteld.
Dus als wat je kiest om Clang compileren met, zelf kwaadaardig is, dan heb je
kan worden geschroefd heel weg langs de lijn.
>> Dus hier hebben we Ken Thompson en Dennis Ritchie.
Dus dit is een iconische foto.
Dennis Ritchie is aan de rechterkant.
Hij is een belangrijke -
vrij veel schreef C. Zo kunt u danken hem voor deze klasse.
Ken Thomson is aan de linkerkant.
De twee van hen in principe schreef UNIX.
Nou, ze waren een belangrijke bijdrage leverden in UNIX.
Er waren enkele anderen.
Dus Ken Thompson, op een bepaald punt, hij wint de Turing Award.
En de Turing award, ik heb altijd gehoord zij verwezen op deze manier, het is de
Nobelprijs van de informatica.
>> Dus op de Turing Award, hij moet geven zijn dankwoord.
En hij geeft deze zeer beroemde toespraak nu, genaamd Reflections on Vertrouwen
Trust, die we hebben gekoppeld Om op de cursus website.
En in deze toespraak, zegt hij, oke, dus schreef ik UNIX, en nu al
je mensen gebruiken UNIX.
Nu, bedenk vandaag dat Linux een directe afstammeling van UNIX.
OS X rechtstreeks gebruik maakt van UNIX.
Windows doet niet zo veel, maar veel ideeën werden genomen van UNIX.
>> Dus hij gaat tot het podium en zegt: oke, schreef ik UNIX.
En zodat jullie weten, ben ik kunnen zich aanmelden bij elke
enkel een van uw computers.
Aangezien ik een van deze speciale als x gelijk gelijk Ken Thomson is geweldig,
dan ben ik in mag loggen.
Dus mensen zijn als, nou ja, Hoe doe je dat?
We keken naar het programma login en niets is er.
Hij is net als, nou ja, ik wijzigde de compiler om in te loggen in het programma login
zodat het programma login nu zal hebben dat x gelijk gelijk Ken Thompson
is geweldig.
>> En zij zeggen: nou, dat is niet waar.
We kijken naar de compiler en de compiler heeft geen regels hebben
code als dat.
Hij is net als, OK, maar wat zijn je het opstellen van de compiler met?
En ze denken, en hij is, als, nou ja, Ik ben degene die u de compiler gaf
u gebruikt om de compiler te compileren, zodat u het samenstellen van een compiler, die
zelf is kwaadaardig, en zal breek het programma login.
Dus eigenlijk, op dat punt, is er geen manier waarop je zou kunnen kijken naar de bron
code van het programma login om te zien wat er mis is.
Je kon niet eens in de broncode van de compiler
om te zien wat er mis is.
>> Je zou moeten kijken naar de machine code, de feitelijke binaire van de
samengesteld compiler te zien, wacht, deze regels code zou hier niet moeten.
Maar Ken Thompson nam het een stap verder en zei, nou ja, er zijn
deze speciale programma's die eigenlijk helpen het binaire programma's te lezen,
en dus als iemand gebruikt dat programma lees de binaire, zouden ze deze zien
regels code.
Hij bewerkt deze programma's om te zeggen, alle klopt, als je kijkt naar de
compiler, niet dit specifieke tonen set van binaire.
>> Dus dan moet je nemen dat een stap verder en eigenlijk, dat kan zijn
die meerdere niveaus van indirectie en op een gegeven moment, niemand is eigenlijk
gaat het controleren.
Dus de moraal van het verhaal is, je bent niet van plan om te schrijven
Clang in deze klasse.
Je gaat gebruiken klimmen Clang veel in deze klasse.
Voor alles wat je weet, Clang is een kwaadaardige programma dat saboteert elke
enkel programma die je ooit hebt gecompileerd.
En om u te verlaten op die zeer onheilspellende mee, zie je op woensdag.
>> [Applaus]
>> SPEAKER 2: Bij de volgende CS50.
>> SPEAKER 3: Waag het niet zeggen.
U kunt dit doen.
Je hebt dit al eerder gedaan, kunt u dit doen vandaag de dag, kunt u dit doen morgen.
Je hebt dit al jaren doen.
Ga gewoon daar en doen dit.
U kunt dit doen.
>> [Muziek]