>> [Muziek]
>> DAVID J Malan: Oke, welkom terug naar CS50.
Dit is het begin van de week twee.
Het woord van een van onze vrienden op de campus -
als je geïnteresseerd bent, eventueel, ofwel nu of in de toekomst termijn
nog, eenmaal comfortabeler, onderwijs middelbare scholieren een beetje
iets over informatica, doen hoofd naar die URL.
Ze zijn in het bijzonder behoefte op dit moment van leraren, vooral als u
had enkele blootstelling aan de informatica.
>> Zo herinneren dat vorige keer, we geïntroduceerd een aantal gegevenstypes C en
je kan zijn begonnen om uw handen vuil met deze tot nu toe
in probleem set een.
En we hadden een char.
Dus in ietwat technische termen, wat is een char zoals u weet het vandaag?
>> Dus het is een karakter, maar laten we zijn nu nauwkeuriger.
Wat bedoelen we met karakter of individuele char?
Een niet-numeriek karakter -
dus niet noodzakelijk.
Het blijkt dat zelfs nummers, zelfs leestekens en letters zijn
weergegeven met de gegevens Typ bekend als char.
Dus het is niet per se alfabetisch.
Yeah?
>> Dus het is een ASCII-teken.
Dus als je terugdenkt aan week nul, wanneer we hadden onze byte van vrijwilligers
komen en of houden hun handen omhoog of niet alle, vertegenwoordigde ze bits.
Maar gezamenlijk als een groep van acht, zij vertegenwoordigen een byte.
En we de notie van ASCII geïntroduceerd bij die lezing, dat is gewoon een
mapping tussen cijfers en letters.
En ASCII toepassingen, zoals die mensen impliciete, acht bits
om een ​​teken te vertegenwoordigen.
>> Dus daarom, als acht bits kan elk op een van twee waarden -
nul of een -
dat betekent dat er waren twee mogelijkheden voor deze persoon -
nul of een -
twee voor deze persoon, twee voor deze persoon, twee voor deze ene.
Dus in totaal twee keer tweemaal twee maal twee maal twee -
dus twee van de achtste in totaal.
Dus er is een aantal tekens 256 mogelijk dat u kunt
vertegenwoordigen met acht bits.
>> Nu, diegenen van jullie die Aziatische spreken talen zouden weten, dat er meer
tekens in de wereld dan Als en B's en C's en Ds.
En inderdaad, ASCII is niet voldoende voor veel talen van de wereld.
Maar meer daarover een andere keer.
Voor nu, weten dat in C als je wilt om een ​​brief, een stuk vertegenwoordigen
interpunctie, of gewoon iets karakter in de natuur, maken we gebruik van een char.
En het is een byte of acht bits.
>> Hoe zit het met een int?
Nou ja, een int is een geheel getal.
Hoeveel bits, als u herinneren, is een integer typisch?
Iedereen recall?
Dus het is meestal 32.
Het hangt eigenlijk op de computer dat u gebruikt.
Maar in het toestel, en in veel computers, het is 32 bits of vier
bytes - acht keer vier.
En ints worden alleen gebruikt voor het opslaan van aantallen, hetzij negatief,
positief of nul.
>> En als je hebt 32 bits en u alleen zorg over positieve getallen, kan
iedereen marge hoeveel mogelijk integers een computer kan vertegenwoordigen van
nul op maximaal?
Zo zou de 32 twee zijn, die is ongeveer vier miljard euro.
Dus deze machten van twee gaan worden terugkerende thema's in de informatica.
Zoals we zullen zien, ze zijn heel handig om mee te werken, zelfs als het is niet helemaal
makkelijk om de wiskunde te doen in je hoofd.
>> Dus we grofweg 4000000000 zeggen.
Nu, een lange lange -
je kan soort gok.
Het is langer dan een int.
Hoeveel bits?
Dus 64 bits of acht bytes.
Dit betekent gewoon dat je kunt zelfs vertegenwoordigen grotere aantallen, groter positief of
grotere negatieve getallen.
>> En hoe zit het drijven?
Dat is een floating point waarde van 32 bits.
Dit is slechts een reëel getal, iets met een decimale punt.
Maar als je in plaats daarvan moet meer plaatsen na de komma of u wilt
vertegenwoordigen een groter aantal met enkele fractie na, kunt u gebruik maken van een
dubbele, die 64 bits.
>> Maar er is een interessante afhaalmaaltijden hier.
Als ints worden beperkt door 32 bits en zelfs lang longs worden beperkt door 64
beetjes, dat soort roept de vraag, wat als je eigenlijk wilt tellen
hoger dan 4 miljard euro voor een int?
Nou, je gewoon gebruik maken van een lange lange.
Maar wat als je wilt een hogere tellen dan twee op de 64e, geven of nemen?
>> Nu, dat is een enorm aantal.
Maar uiteindelijk, zou je eigenlijk zorg over dit soort waarden,
vooral als u gebruik maakt van een database en beginnen te veel en veel te verzamelen
en tal van gegevens en toewijzen van unieke nummers om elk stukje van die gegevens.
Zo vriendelijk we van een probleem.
En evenzo met floating point waarden - vlotters of dubbelspel -
Als u alleen hebt een eindig aantal beetjes, hoeveel de totale aantallen kon je
eventueel vertegenwoordigen?
>> Nou, het is minder duidelijk wanneer je impliceren een decimale punt.
Maar het is toch eindig.
Als je een eindig aantal bits, een eindig aantal mensen, een eindige
aantal lampen, zeker je kunt slechts een eindig aantal vertegenwoordigen
floating point waarden.
Maar hoeveel reële getallen zijn hun in de wereld?
Er is een oneindige.
Dus dat is een beetje een probleem, omdat we niet over een oneindige hoeveelheid
geheugen of RAM binnenkant van onze computers.
Dus sommige uitdagende dingen kunnen gebeuren.
>> Dus laten we gaan je gang en probeer deze uitdrukking hier.
Laat me ga je gang en open gedit.
Ik ga om te gaan en opslaan van een bestand genaamd "floats0.c" gewoon te zijn
in overeenstemming met een voorbeeld dat is online beschikbaar, als je zou willen.
En ik ga om verder te gaan en definieert het als volgt -
Ik ga om te gaan en te zeggen, int belangrijkste leegte, zoals we vaak doen.
>> En dan in dit programma, ga ik verklaar mezelf een float, zodat een 32-bit
variabele genaamd f, willekeurig.
En dan ga ik op te slaan in het Ik weet het niet, een tiende, dus 0,1.
Dus ik ga om uit te drukken dat als een gedeeld door 10, dat perfect
legitiem in C.
>> En dan op de tweede regel, ik gewoon wilt afdrukken die waarde.
Zodat herinneren dat we kunnen gebruiken het bekende printf.
We willen niet ik gebruik% voor een int.
We willen% f gebruiken voor een float.
En dan ga ik doen backslash n, dicht citaat, komma, f, puntkomma.
>> Dus hier is mijn programma.
Er is al een bug.
Heeft iemand voor wie dit geklikt al willen wijzen op zijn minst
een bug die ik heb gemaakt?
Yeah?
Yeah.
Ik vergat "# include" op de top, ze symptoom van die, als ik probeer te
compileren dit gaat worden dat de compiler gaat schreeuwen tegen me,
zeggende: undefined symbol of iets in die zin.
Het hoeft niet iets te begrijpen zoals printf.
>> Dus ik ga doen "# include ", Sla het bestand op.
En nu is het beter in vorm.
Maar ik ga ook naar punt uit een nieuw detail vandaag.
Naast de vermelding van plaats houders zoals% f% i% s, kunt u
soms invloed op het gedrag van die placeholder.
Bijvoorbeeld in het geval van een zwevende puntenwaarde, als ik wil alleen maar
met een decimaal weergegeven nadat de periode, ik kan eigenlijk doen 0.1f.
Dus met andere woorden, I scheid de f en het procent teken met 0.1, net
vertellen printf, zou je een hele hebt stelletje getallen na de komma
punt voor mij.
Maar ik wil alleen maar een van hen te zien.
>> Dus ik ga nu verder te gaan en te besparen dit programma, ga in mijn terminal
raam, en ik ga om verder te gaan en typ make vlotter 0, in te voeren.
Ik zie dat enigszins cryptisch lijn die zal beginnen om meer zin te maken als we
plagen het uit elkaar deze week en volgende.
Nu ga ik om verder te gaan en lopen vlotter nul.
En, verdomd.
>> Dus er is nog een bug hier een of andere reden.
Ik ben er vrij zeker van dat een tiende, of een gedeeld door 10, is 0.0.
Misschien ben ik gewoon niet op zoek bij voldoende cijfers.
Dus waarom niet ik zeg twee 0,2 tot twee te zien decimalen plaats van slechts een.
Laat me terug naar mijn terminal venster Hier en sloeg een paar keer naar
zie mijn geschiedenis.
Doet zorg weer zweven nul, en dan weer omhoog.
En nu voeren.
>> En nu ben ik vrij zeker dat dit verkeerd is.
En ik kon drie en vier doen, en ik ben waarschijnlijk gaat blijven zien nullen.
Dus waar is het fout?
Een gedeeld door 10 moet 0.1.
Iemand wil een gooi op wat het fundamentele probleem is?
Yeah?
Ze zijn allebei gehele getallen.
So what?
Dus met een gedeeld door 10, dat is wat ik doe in de rekenkunde.
En ik krijg 0.1.
>> Yeah.
En zo is het inderdaad dat probleem.
Wanneer u een geheel getal in een computer over te nemen en je delen door een ander getal,
de computer standaard gaat gaan ervan uit dat u wilt een integer.
Het probleem, natuurlijk 0.1 dat geen geheel getal.
Het is een reëel getal.
En dus wat de computer doet door Standaard is het gewoon weggooit
alles na de komma.
Het maakt niet beneden af ​​te ronden of maximaal per se.
Het gooit gewoon alles weg na de komma.
En nu dat is logisch.
Want nu zijn we duidelijk verliet met nul.
>> Maar wacht eens even.
Ik ben niet het zien van een int nul.
Ik ben eigenlijk het zien van 0,00.
Dus hoe kan ik nu dit te rijmen?
Als men gedeeld door 10 is nul, maar ik ben zien van 0,00, waar wordt het steeds
geconverteerd naar een reëel getal?
Yeah.
Precies.
>> Dus hier in lijn vijf, toen ik eigenlijk slaan dat 0.1, die dan
afgekapt tot nul binnenkant van een vlotter, dat is effectief gelijkwaardig is aan
slaan niet als int maar inderdaad, als float.
Bovendien ben ik vervolgens met behulp van printf aan expliciet dat aantal afdrukken op twee
decimalen hoewel er misschien niet eigenlijk geen.
>> Dus dit soort zuigt, toch?
Blijkbaar kun je niet rekenen, althans in dit niveau
precisie in een computer.
Maar zeker is er een oplossing.
Wat is de eenvoudigste oplossing konden we misschien doen, zelfs gewoon intuïtief hier om
dit oplossen?
Yeah?
Draai de gehele getallen in -
ja.
Zelfs als ik ben niet helemaal zeker wat er echt aan de hand hier, als het
fundamenteel heeft te maken met beide zijnde ints, goed, waarom doe ik niet
maken dat 10,0, waardoor deze 1.0, het bestand opslaan.
Laat me gaan terug naar de bodem en hercompileren.
Laat me nu opnieuw uitvoeren.
En er -
nu, ik heb mijn tiende kreeg weergegeven als 0.10.
>> Oke.
Dus dat is niet slecht.
En wil ik erop wijzen een andere kant op We konden dit hebben opgelost.
Laat me eigenlijk terug te rollen in de tijd aan toen we dit als een
tiende een moment geleden.
En laat me gaan en opnieuw op te slaan dit bestand als een andere bestandsnaam, gewoon om te
hebben een kleine controlepost.
Dus dat was een versie.
En nu laat ik verder gaan en doe nog een versie.
We zullen deze versie noemen twee nul geïndexeerd.
>> En ik ga in plaats daarvan doen deze - weet je wat?
Het toevoegen dot zero werkt in dit geval.
Maar stel dat men een variabele.
Verondersteld 10 waren een variabele.
Met andere woorden, stel dat ik niet kon gewoon moeilijk-code 0,0 aan het eind
van deze rekenkundige expressie.
Nou, ik kan eigenlijk iets doen haakjes genoemd gieten.
Ik kan uitbrengen dat getal 10 een float, en ik kan dat integer men wierp een
zweven, als goed.
Dan is de wiskunde dat gaat gebeuren effectief 1,0 gedeeld door 10,0,
het resultaat daarvan gaat in f als voorheen.
Dus als ik opnieuw compileren dit als drijvers maken 2, en nu drijft 2, dezelfde krijg ik
beantwoorden, als goed.
>> Dit is dus een vrij gekunsteld voorbeeld, dit probleem oplossen
door de invoering gieten.
Maar in het algemeen, casting gaat worden een krachtig ding, met name voor
probleem set twee in een week tijd, toen U wilt een gegevenstype converteren naar
andere die aan het eind van de dag worden in dezelfde manier.
Aan het eind van de dag, elke wat we hebben gesproken over tot nu toe is
net ints onder de motorkap.
Of als dat te laag niveau voor je, ze zijn gewoon nummers
onder de motorkap.
Zelfs personages, nogmaals, herinneren van week nul zijn nummers
onder de motorkap.
>> Dat wil zeggen, we kunnen omzetten tussen verschillende soorten nummers als
ze zijn gewoon stukjes.
We kunnen zetten tussen nummers en brieven als ze gewoon
bits en vice versa.
En gieten op deze manier een mechanisme in de programmering waarmee je met geweld
wijzigen ene gegevenstype naar het andere.
Helaas is dit niet zo eenvoudig als ik zou hebben gewild.
>> Ik ga terug in praalwagens 1, die het eenvoudiger,
ongecompliceerd een met 0,0 toegevoegd aan elk.
En net als een snelle opfriscursus, laat me gaan en opnieuw compileren
deze, maken praalwagens 2 -
sorry, dit is te maken praalwagens 1.
En nu laten we lopen praalwagens 1.
En in de bodem, merkt dat ik inderdaad krijg 0.1.
Dus, probleem opgelost.
>> Maar nog niet.
Ik ga nu een beetje nieuwsgierig te krijgen, en ik ga terug naar mijn
printf statement en zeg, weet je wat?
Ik zou willen dat dit te bevestigen is echt een tiende.
En ik ga dit willen zien naar, zeg, vijf decimalen.
Het is geen probleem.
Ik verander de twee tot vijf, Ik compileren met make.
Ik start het opnieuw op als drijft 1.
Ziet er goed uit.
Mijn sanity checks er misschien een einde, maar Ik word een beetje meer avontuurlijk.
Ik ga naar 0.5 veranderen naar 0.10.
Ik wil 10 cijfers zien na het decimaal.
>> En ik ga om verder te gaan en opnieuw te compileren deze en voer drijft 1.
Ik soort van spijt te hebben dit getest verder, want mijn wiskunde is niet zo
corrigeren meer, lijkt het.
Maar wacht eens even, misschien dat is gewoon een toevalstreffer.
Misschien is de computer optreedt een beetje vreemd.
Laat me ga je gang en doe 20 decimalen en geruststellen mezelf dat ik weet
hoe wiskunde te doen.
Ik weet hoe te programmeren.
Maak praalwagens 1, compileren, en verdomme.
Dat is echt, echt krijgen ver van de mark.
>> Dus wat is hier aan de hand?
Intuïtief, op basis van onze aannames eerder over de grootte van data types,
wat moet hier gebeuren onder de motorkap?
Yeah?
Precies.
Als u wilt dat dit veel precisie, en dat is een deurklink van een veel precisie -
20 cijfers achter de komma.
Je kan onmogelijk vertegenwoordigen een willekeurig nummer, tenzij u een
willekeurig aantal bits.
Maar wij niet.
Voor een vlotter, we hebben maar 32 bits.
>> Als slechts 32 bits worden gepermuteerd op manier - net als onze mensen op, het podium
handen omhoog of omlaag - in een eindig aantal wegen, er is slechts een eindig aantal
van reële getallen je kan vertegenwoordigen met deze bits.
En zo de computer uiteindelijk zal moeten
beginnen snijden hoeken.
De computer kan die details verbergen van ons een beetje tijd.
Maar als we beginnen porren bij de cijfers en kijken verder en verder op de
achterstand getallen in het gehele getal, dan beginnen we te zien dat het
eigenlijk benadert de idee van een tiende.
>> En zo blijkt, tragisch genoeg, er is een oneindig aantal nummers
We kunnen niet precies in een vertegenwoordigen computer, tenminste het eindige
aantal bits, een eindige hoeveelheid RAM.
Nu helaas, dit soms heeft real-world gevolgen.
Als mensen niet helemaal waarderen of soort voor lief nemen het feit
dat hun computer precies zal doen wat ze zeggen dat het moet doen en niet doen
begrijpen deze onderliggende vertegenwoordiging gegevens -
die, eerlijk gezegd, in sommige talen zijn verborgen voor de gebruiker, in tegenstelling tot C -
een aantal slechte dingen kunnen gebeuren.
>> En wat ik dacht dat we doen is een stap terug.
En dit gaat over een acht minuten durende video.
Het luchtte een paar jaar geleden, en het geeft inzichten in eigenlijk wat kan gaan
mis als je onder-brengen van deze soorten gegevens in het al-te
echte wereld.
Als we konden de lichten dimmen voor een paar minuten.
>> LUIDSPREKER 1: We keren nu terug naar techniek
rampen op Modern Marvels.
>> Computers -
we zijn allemaal gekomen om de te accepteren vaak frustrerende problemen
die daarbij horen.
Bugs, virussen, en software glitches zijn kleine prijzen te betalen voor de
gemak.
Maar in high-tech en high-speed militaire en ruimtevaartprogramma
toepassingen, het kleinste probleem kan worden vergroot in ramp.
>> Op 4 juni 1996 wetenschappers bereid om lanceren van een onbemande Ariane 5 raket.
Het vervoerde wetenschappelijke satellieten ontworpen om precies hoe vast
magnetisch veld van de Aarde interactie met zonne-wind.
De raket werd gebouwd voor de Europese Ruimteagentschap en opgetild uit haar
faciliteit op de kust van Frans-Guyana.
>> JACK GANSSLE: Op ongeveer 37 seconden in de vlucht, zij eerst opgemerkt
er iets fout gaat.
De sproeiers zijn draaibaar in een manier waarop ze echt niet moeten doen.
Ongeveer 40 seconden in de vlucht, duidelijk het voertuig in de problemen zat.
En dat is wanneer ze een beslissing om het te vernietigen.
Het bereik veiligheidsfunctionaris, met enorme lef, drukte op de knop,
blies de raket voordat het kon uitgegroeid tot een gevaar voor de openbare veiligheid.
>> LUIDSPREKER 1: Dit was de eerste reis van de Ariane 5, en de vernietiging
vond plaats vanwege een fout ingebedde in de software van de raket.
>> JACK GANSSLE: Het probleem van de Ariane was dat er een aantal
dat de vereiste 64 bits uit te drukken.
En ze wilden bekeren een 16-bits getal.
Zij veronderstelden dat het nummer was nooit gaat zijn zeer groot, dat de meeste
deze cijfers in de 64-bit aantal nullen waren.
Ze hadden het mis.
>> LUIDSPREKER 1: Het onvermogen van een software programma om de soort te accepteren
nummer gegenereerd door een ander was aan de wortel van de mislukking.
Software ontwikkeling was een zeer geworden dure deel van de nieuwe technologie.
De Ariane 4 raket was erg geweest succesvol, zoveel van de software
gecreëerd was ook gebruikt in de Ariane 5.
>> PHILIP COYLE: Het fundamentele probleem was dat de Ariane 5 was sneller,
sneller versneld.
En de software niet had goed voor dat.
>> LUIDSPREKER 1: De vernietiging van de raket was een enorme financiële ramp,
allemaal te wijten aan een minuut softwarefout.
Maar dit was niet de eerste keer gegevens conversie problemen had moderne geplaagd
rakettechnologie.
>> JACK GANSSLE: In 1991, met de start van de eerste Golfoorlog, de Patriot
raket kende een zelfde soort een nummerconversie probleem.
Dientengevolge, 28 Amerikaanse soldaten gedood en ongeveer 100 anderen gewond
toen de Patriot, die verondersteld werd te beschermen tegen inkomende Scuds,
niet in geslaagd een raket afvuren.
>> LUIDSPREKER 1: Wanneer Irak Koeweit binnenviel en Amerika gelanceerd Desert Storm in
begin 1991, Patriot raketten batterijen werden ingezet om Saudi-Arabië te beschermen
en Israël van de Iraakse Scud raketaanvallen.
De Patriot is een Amerikaanse middellange afstand surface-to-air-systeem vervaardigd door
het bedrijf Raytheon.
>> THEODORE Postol: De grootte van de Patriot interceptor zelf is ruwweg
20-meter lang.
En hij weegt ongeveer 2000 kilo.
En het draagt ​​een kernkop van ongeveer -
Ik denk dat het ongeveer £ 150.
En de kernkop zelf een hoog explosief die heeft
fragmenten eromheen.
De behuizing van de kernkop ontworpen te handelen als hagel.
>> LUIDSPREKER 1: De raketten worden uitgevoerd vier per container en worden vervoerd
een oplegger.
>> PHILIP COYLE: De Patriot anti-raket systeem gaat terug naar
minstens 20 jaar nu.
Het werd oorspronkelijk ontworpen als een luchtverdediging raket
neer te schieten vijandelijke vliegtuigen.
In de eerste Golfoorlog, toen die oorlog kwam langs, het leger wilde gebruiken
om Scuds, niet vliegtuigen neer te schieten.
De Iraakse luchtmacht was niet zo veel van een probleem.
Maar het leger was bezorgd over Scuds.
En dus probeerde ze te upgraden de Patriot.
>> LUIDSPREKER 1: onderscheppen een vijandelijke raket reizen op mach vijf was
zal genoeg zijn uitdagend.
Maar toen de Patriot werd overhaast in dienst, het leger was niet op de hoogte van een
Iraakse wijziging die hun gesteld Scuds bijna onmogelijk om te slaan.
>> THEODORE Postol: Wat is er gebeurd is de Scuds die werden
komen waren instabiel.
Ze werden wiebelen.
De reden hiervoor was het Irakezen in Om 600 kilometer te halen uit een
300-kilometer-afstands raket, nam gewicht aan de voorkant kernkop.
Ze maakten de kernkop lichter.
Dus nu de Patriot probeert te komen op de Scud.
En meestal het overgrote meerderheid van de tijd, het zou gewoon
vliegen door de Scud.
>> LUIDSPREKER 1: Zodra het Patriot-systeem operatoren realiseerde de Patriot gemist
zijn doel, ze ontploft de Patriotten kernkop om mogelijk te vermijden
slachtoffers indien het werd toegestaan tot op de grond vallen.
>> THEODORE Postol: Dat was wat de meeste mensen zagen als grote vuurballen in de lucht
en onbegrepen zo slim van Scud kernkoppen.
>> LUIDSPREKER 1: Hoewel in de nachtelijke hemel Patriotten bleek succesvol te zijn
Scuds vernietigen, bij Dhahran er kon er geen misverstand over haar zijn
prestaties.
Er is de Patriot's radarsysteem verloren bijhouden van een inkomende Scud en nooit
gestart als gevolg van een software fout.
>> Het was de Israëli's die voor het eerst ontdekt hoe langer het systeem
was, hoe groter de tijd discrepantie geworden als gevolg van een klok
ingebed in de computer van het systeem.
>> JACK GANSSLE: Ongeveer twee weken voor de tragedie in Dhahran, de Israëli's
gemeld aan het ministerie van Defensie dat het systeem de tijd aan het verliezen was.
Na ongeveer acht uur lopen, ze merkten dat het systeem is
steeds merkbaar minder nauwkeurig.
Het ministerie van Defensie gereageerd door vertellen al van de Patriot batterijen
de systemen geen reactie voor een lange tijd.
Ze hebben nooit gezegd wat een lange tijd was.
Acht uur?
10 uur?
1000 uren?
Niemand wist.
>> LUIDSPREKER 1: The Patriot batterij gestationeerd bij de kazerne in Dhahran
en de gebrekkige interne klok was over meer dan 100 uur in de nacht van
25 februari.
>> JACK GANSSLE: Het bijgehouden tijd om een nauwkeurigheid van ongeveer een tiende van een seconde.
Nu, een tiende van een seconde is een interessant nummer omdat het niet kan worden
uitgedrukt in binaire precies, waardoor kan niet exact worden uitgedrukt
elke moderne digitale computer.
Het is moeilijk te geloven, maar gebruik dit als voorbeeld.
Laten we de nummer een derde.
Een derde kan niet worden uitgedrukt in decimalen nauwkeurig.
Een derde is 0.333 gaat voor oneindigheid.
Er is geen manier om dat te doen met absolute nauwkeurigheid in decimalen.
Dat is precies het zelfde soort probleem dat gebeurde in de Patriot.
Hoe langer het systeem liep, de slechtste tijd fout werd.
>> LUIDSPREKER 1: Na 100 bedrijfsuren, de fout in de tijd was slechts
ongeveer een derde van een seconde.
Maar in termen van targeting een raket reizen op mach vijf, het resulteerde in
een tracking error van meer dan 600 meter.
Het zou een fatale fout te zijn de soldaten aan Dhahran.
>> THEODORE Postol: Wat gebeurd is, is een Scud lancering werd ontdekt door vroege
waarschuwing satellieten.
En zij wisten dat de Scud kwam in hun algemene richting.
Ze wisten niet waar het vandaan kwam.
>> LUIDSPREKER 1: Het was nu aan de radar component van het Patriot-systeem
verdedigen Dhahran te vinden en te houden bijhouden van de inkomende vijandelijke raketten.
>> JACK GANSSLE: De radar was erg slim.
Het zou eigenlijk bijhouden van de positie van de Scud en vervolgens te voorspellen waar het
zou waarschijnlijk de volgende keer de radar stuurde een puls uit.
Dat heette de range gate.
>> THEODORE Postol: Dan zodra de Patriot beslist voldoende tijd is verstreken om te gaan
terug en controleer de volgende locatie voor Deze gedetecteerde object, gaat het terug.
Dus toen ging het terug naar de verkeerde plaats, het dan ziet geen object.
En hij beslist dat er geen object, was een valse detectie en
laat de baan.
>> LUIDSPREKER 1: De binnenkomende Scud verdwenen van het radarscherm, en
seconden later sloeg in de kazerne.
De Scud gedood 28 en was de laatste vuurde tijdens de eerste Golfoorlog.
Tragisch, de bijgewerkte software aangekomen bij Dhahran de volgende dag.
De software fout was vastgesteld, sluiten van een hoofdstuk in de onrustige
geschiedenis van de Patriot raket.
>> Patriot is eigenlijk een afkorting voor Phased Array Tracking
Intercept Of Target.
>> DAVID J Malan: Oke, dus een ontnuchterend voorbeeld, om zeker te zijn.
En gelukkig, deze lagere niveau bugs zijn niet iets dat we zullen
hebben meestal te waarderen, zeker niet met sommige van onze
vroegste programma.
Integendeel, het merendeel van de bugs zul je ontmoeting zal zijn logisch in de natuur,
syntactische aard waarbij de code gewoon niet goed werkt.
En je weet dat het behoorlijk snel.
>> Maar vooral als we in de einde van het semester, het gaat om
meer en meer een mogelijkheid echt hard na te denken over het ontwerp
van uw programma's en de onderliggende vertegenwoordiging
ook daar, van de gegevens.
Bijvoorbeeld, we zullen MySQL introduceren, dat is een populaire gegevensbestandmotor
die u kunt gebruiken met websites te gegevens op de achterkant.
En je zult moeten beginnen om te beslissen op het einde van het semester niet alleen wat
soorten gegevens in deze zin te gebruiken maar precies hoeveel bits te gebruiken,
of u wilt data opslaan als datums en tijden zoals tijden en ook
dingen als hoe groot wil je het unieke ID zijn voor bijvoorbeeld de gebruiker
in uw database.
>> In feite, als sommige van jullie hebben gehad Facebook goed voor geruime tijd,
en je weet hoe je toegang krijgen om uw gebruikers-ID -
die soms opduikt in uw URL tenzij je hebt gekozen voor een profiel
bijnaam voor de URL, of als je hebt gebruikte Facebook's Graph API, de
openbaar beschikbare API waarmee je kan vragen Facebook om ruwe data -
kunt u zien wat uw numerieke ID is.
En enkele jaren geleden, Facebook wezen moest te schakelen van
het equivalent van ints aan het gebruik van lange lang, want na verloop van tijd als gebruikers komen
en gaan en creëren veel rekeningen en fake accounts, zelfs zij heel gemakkelijk
waren in staat om iets te putten als een 4 miljard mogelijke waarde als een int.
>> Dus meer over dat soort zaken op de weg, als goed.
Oke, dus dat was gieten.
Dat was onnauwkeurigheid.
Een paar aankondigingen.
Dus secties formeel beginnen aanstaande Zondag, maandag, dinsdag.
U zult via e-mail te horen later deze week als uw afdeling opdracht.
En je zult ook hier op dat moment hoe om uw afdeling te veranderen als uw
schema is nu veranderd of uw comfortniveau is nu veranderd.
Ondertussen P-set een en hacker een zijn vanwege deze donderdag met de optie om
breiden die termijn per de specificaties tot en met vrijdag
op een typische manier.
>> Realiseer je dat meegeleverd met het probleem set specificaties zijn instructies op
hoe de CS50 apparaat gaat gebruiken, maken, evenals een aantal specifieke instrumenten CS50
achtige stijl 50, die kan u feedback dynamisch op de
kwaliteit van je code stijl en ook check 50, die u kunnen voorzien van
dynamische feedback als u uw correctheid code's.
Vergeef dat we nog steeds strijken enkele kinks met cheque 50.
Een paar van je klasgenoten die wel starten rond 04:00 op vrijdagavond wanneer
de spec ging hebben gemerkt sindsdien een paar bugs die we werken
door, en excuses voor iedereen die heeft ervaren onnodige frustraties.
Het is mijn schuld.
Maar we zullen volgen op de CS50 bespreken wanneer dat is opgelost.
>> Dus een woord op scores zichzelf.
Dus het zal een week of twee duren voordat u beginnen om feedback over probleem sets krijgen
omdat je nog niet over een leer collega.
En zelfs dan, zullen we beginnen te evalueren de C probleem stelt voordat we
ga terug en evalueren van nul, dus dat je meer betrokken te krijgen
feedback sneller.
Maar in het algemeen per de syllabus, CS50 probleem sets worden geëvalueerd aan de
na vier assen -
scope, correctheid, design en stijl.
>> Scope gaat een aantal typisch tussen nul en vijf die
vangt hoeveel van de stuk dat je beet.
Typisch, je wil dat dit vijf.
Je tenminste alles geprobeerd.
En merken dat het een vermenigvuldigingsfactor zodat doet slechts een deel van de
probleem set is niet de beste strategie.
>> Ondertussen duidelijker is belang van correctheid -
alleen is uw programma correct met respect voor de specificatie?
Dit is bewust meer gewogen zwaarder dan de andere twee assen door een
factor drie want we herkennen dat meestal je gaat naar een te brengen
veel meer tijd jagen een aantal bugs, het krijgen van uw code te werken, dan moet je
worden inspringen en te kiezen geschikte variabele namen en de
vinden, die op het andere uiteinde van het spectrum van stijl.
>> Dat wil niet zeggen dat stijl is niet belangrijk, en wij zullen het prediken dan
tijd zowel in lezingen en in gedeelten.
Stijl heeft betrekking op de esthetiek van je code.
Heeft u gekozen goed genoemd variabelen die zijn kort maar enigszins
beschrijvende?
Is uw code ingesprongen zoals je hebt gezien in lezing en op een wijze die in overeenstemming
met stijl 50?
>> Ten slotte is het modelrecht daar in het midden.
Design is het moeilijker een om een ​​put vinger op want het is veel meer
subjectief.
Maar het is misschien wel de belangrijkste van de drie assen in termen van pedagogische
waarde in de tijd en dat dit zal gelegenheid het onderwijs collega's om
u te voorzien van kwalitatieve feedback.
Inderdaad, in CS50 hoewel we doen hebben Deze formules en scores aan het einde
van de dag deze zijn zeer bewust zeer kleine emmers - kommawaarden
tussen nul en drie en nul en vijf.
We proberen niet te zeer grove lijnen te trekken tussen probleem sets of tussen
studenten maar richt zich zoveel we kunnen op kwalitatieve, handschrift
feedback, hetzij getypte of mondeling uit uw specifieke onderwijs-collega,
krijg je om heel goed te kennen.
>> Maar in het algemeen, dat zijn de gewichten dat de verschillende assen hebben.
Ondertussen, ook, het is de moeite waard om in erg dat je niet moet ervan uitgaan dat een
drie van de vijf is een 60% en dus ruwweg gebreke.
Drie is bewust bedoeld soort midden van de weg goed.
Als je krijgt drieën op de het begin van het semester, dat is
inderdaad bedoeld om een ​​goede plaats om te beginnen.
Als je krijgt twos, beurzen, is er zeker wat werk om een ​​beetje te betalen
meer aandacht, om te profiteren van secties en kantooruren.
>> Als je krijgt handen en voeten en vijven, geweldig.
Maar echt, hopen we trajecten zien onder studenten - zeer
geïndividualiseerd per leerling, maar vanaf het semester hier in soort
de twee naar de drie gamma maar eindigt hier in de 4-5 range.
Dat is wat we echt zoekt.
En dat doen we in gedachten houden dat de delta u vertonen tussen week nul en week
12 toen ik doe rangen.
Het maakt niet echt hoe belangrijk voor ons je eerlijk in het begin als je
traject is inderdaad boven en sterk.
>> Academische eerlijkheid - dus laat ik op mijn meer serieuze stem voor slechts een moment.
Dus deze cursus is het onderscheid van het sturen van meer studenten dan alle andere
in de geschiedenis om de advertentie boord, geloof ik.
We hebben een soort tel kwijt op dit punt van hoe vaak dit gebeurt.
En dat is niet omdat de studenten in 50 zijn niet meer oneerlijk dan hun
klasgenoten elders.
Maar beseffen ook dat we heel goed op het opsporen van dit soort dingen.
>> En dat is het voordeel dat een computer science class heeft in dat we
kunnen en wij vergelijken alle studenten probleem stelt paarsgewijze tegen elke
andere, niet alleen dit jaar maar alle voorgaande jaren.
We hebben het vermogen, zoals studenten in de klas, naar Google en code te vinden
op sites als GitHub en discussiefora.
Er zijn absoluut oplossingen voor CS50's p-sets rondzweven daar.
Maar als je ze kan vinden, kunnen we ze vinden.
En dit alles is zeer geautomatiseerd en gemakkelijk en verdrietig voor ons te vinden.
>> Maar ik wil benadrukken, ook, dat de academische eerlijkheid beleid cursus is
zeer bedoeld sterk worden het tegenovergestelde van die geest.
Inderdaad, dit jaar hebben we dingen anders geformuleerd in de syllabus om dit te zijn, dot
dot dot, met meer detail in de syllabus.
Maar het overkoepelende thema in de loop eigenlijk is redelijk te zijn.
We erkennen dat er een significant hoeveelheid pedagogische
waarde samenwerkende, tot op zekere hoogte, met klasgenoten, waarbij je
twee of u drie of meer je bent staande op een witte boord
whiteboarding, om zo te spreken, uw ideeën -
uitschrijven van pseudocode in foto's, diagrammen wat moet Mario zijn als
je was om het te schrijven eerst in pseudocode.
Wat moet de hebzuchtige algoritme -
hoe moet het gedragen per probleem stelt een?
>> En dus beseffen dat gedrag dat we moedigen is erg
veel in die richting.
En in de syllabus, zie je een heleboel kogels onder een
redelijke categorie en een niet redelijk categorie die ons helpt helpen
je je geest wrap rond waar we trekken die lijn.
En in het algemeen, een fatsoenlijke vuistregel is dat als je worstelt op te lossen
enkele bug en je vriend of klasgenoot wordt naast je zitten, het wordt
redelijk voor u om hem te laten zien of haar uw code en zeggen: hey, kan je helpen
me uitzoeken wat hier fout gaat?
>> We meestal niet omarmen de andere kant.
Het is geen correcte respons op uw vriend of klasgenoot hier te zeggen, oh,
kijk maar naar mij en figuur het uit van dat.
Dat is een soort van onredelijk.
Maar het hebben van iemand anders, een ander brein, een ander paar ogen kijken
uw scherm of kijken naar uw code en zeggen, bent u zeker dat u wilt
een lus hebben hier?
Of bent u zeker dat u wilt hier dat puntkomma?
Of oh, die foutmelding betekent dit.
Die zijn zeer redelijk en aangemoedigd gedrag.
>> De gevallen waarop ik werd gezinspeeld op eerder neer op als studenten
's avonds laat maken slecht beoordelingsvermogen beslissingen en e-mailen hun code aan
iemand anders of gewoon zeggen, hier, het is in Dropbox of
Googlen 's avonds laat.
En dus ik zou aanmoedigen en smeek u, als je het hebt die onvermijdelijke
momenten van stress, je bent stoten tegen de deadline, je hebt geen late
dag, omdat het is al vrijdag op dat punt, email hoofden van de cursus of
mezelf direct.
Zeg, luister, ik ben op mijn breekpunt hier.
Laten we een gesprek en figure it out.
Toevlucht te nemen tot het internet of een ander niet redelijke gedrag is nooit de
oplossing, en te veel van het klasgenoten zijn niet meer hier op
campus vanwege die slechte beslissing.
Maar het is heel gemakkelijk om die lijn rok.
>> En hier is een kleine afbeelding te juichen u op van Reddit, zodat nu
alles komt goed.
>> Dus een korte samenvatting, dan, van waar we gebleven waren.
Dus vorige week, zich herinneren dat we introduceren omstandigheden, niet in Scratch
C maar deze keer.
En er was een nieuwe syntax, maar echt geen nieuwe ideeën per se.
We hadden Booleaanse uitdrukkingen die we konden of samen met twee verticale
bars of en samen met twee ampersand, zegt dat zowel de linker
en het recht moet waar zijn dit uit te voeren.
Dan hadden we schakelaars, die we gekeken in het kort, maar ik stel zijn echt
gewoon anders syntax voor het bereiken van de zelfde soort doel als je weet in
vooraf wat uw zaken gaan worden.
>> We keken naar loops.
Een for-lus is misschien wel de meest voorkomende, of tenminste degene die mensen
typisch bereiken voor instinctief.
Ook al ziet het er een beetje cryptisch, je zult zien vele, vele voorbeelden van deze
het duurde niet lang, want je hebt al eind vorige week.
Terwijl de lussen kan eveneens bereiken van het zelfde ding.
Maar als je wilt een ophoging doen of bijstelling van
waarden variabele, moet u doe het meer handmatig dan de
voor lus maakt vóór.
En dan is er nog de do-while-lus, die ons in staat om iets te doen aan
minste terwijl iets anders is waar.
En dit is bijzonder goed voor programma's of voor games waar je wilt
om de gebruiker voor iets gevraagd tenminste eenmaal.
En dan, als hij of zij niet meewerken, je zou willen om het te doen
weer.
>> Met variabelen, ondertussen, hadden we lijnen van code zoals deze, die zou kunnen
zijn twee lijnen.
Je zou kunnen verklaren een int genaamd teller, puntkomma.
Of je kunt gewoon declareren en definiëren, om zo te zeggen.
Geef het een waarde tegelijk.
>> En dan tot slot, we praatten over functies.
En dit was een mooi voorbeeld in die zin dat illustreert
twee typen functies.
One is GetString (), die nogmaals wordt een reeks van de gebruiker.
Maar GetString () is een soort van interessant, Voor zover we hebben gebruikt,
want we hebben altijd gebruikt met iets aan de linkerkant van een
gelijk-teken.
Dat wil zeggen dat GetString () geeft een waarde terug.
Het geeft natuurlijk een tekenreeks.
En dan aan de linkerkant, zijn we gewoon opslaan die string binnenkant van een
variabele genaamd naam.
>> Dit is anders in zekere zin van printf printf omdat, althans in onze
gebruik hier, doet niets terug.
Even terzijde, het doet iets terug.
We gewoon niet schelen wat het is.
Maar het heeft wel wat genoemd bijwerking.
En wat is dat bijwerking bij iedere geval hebben we tot nu toe gezien?
Wat doet printf doen?
Hij drukt iets naar het scherm, displays tekst of getallen of iets
op het scherm.
En dat is net als een neveneffect omdat het niet echt overhandigen
het terug naar mij.
Het is niet een antwoord binnenkant van een zwarte doos die ik kan dan
bereiken in en pak.
Het is gewoon doet het op zijn eigen, veel zoals Colton werd aangesloten op dit
black box vorige week, en hij een of andere manier magische wijze werd het tekenen op het bord
zonder mij eigenlijk betrokken.
Dat zou een bijwerking zijn.
Maar als ik eigenlijk had om terug te komen in hier en zeggen: oh, hier is de string
van de gebruiker, dat zou wel een return waarde.
>> En tot nu toe hebben we alleen gebruikte functies die andere mensen hebben geschreven.
Maar we kunnen eigenlijk doen deze allerlei dingen onszelf.
Dus ik ga om te gaan in de CS50 apparaat weer.
Laat ik sluit het tabblad dat we had geopend een moment geleden.
En laat me gaan en maak een nieuw bestand.
En ik ga om verder te gaan en noemen dit een positive.c.
Dus ik wil iets doen met positieve getallen hier.
Dus ik ga om verder te gaan en te doen int -
sorry -
# Bevatten.
Laten we niet diezelfde maken fout als voorheen.
Int main (void), open krullend brace, gesloten accolade.
>> En nu wil ik het volgende doen.
Ik wil een programma te schrijven dat dringt erop aan dat de gebruiker geeft
me een positief geheel getal.
Er is dus geen GetPositiveInt functie in het CS50 bibliotheek.
Er is maar getInt ().
Maar dat is OK want ik heb de constructen waarmee ik kan opleggen een
weinig beperking van die waarde.
Ik zou zoiets als dit.
>> Dus int n -
en als je aan het typen bent langs, gewoon beseffen Ik ga om terug te gaan en
veranderen sommige dingen in een ogenblik -
dus int n gelijk getInt ().
En dat gaat zetten een int binnenkant van n.
En laat me een meer beschrijvend.
Laat ik iets zeggen als ik eis dat je geeft me een positief geheel getal.
>> Oke.
Dus gewoon een beetje van instructies.
En nu, wat kan ik doen?
Nou, ik weet al vanaf mijn eenvoudige voorwaarden of takken, net zoals ik
had in Scratch, zou ik iets zeggen zoals als n kleiner is dan of gelijk aan
nul, dan wil ik iets doen willen, dat is niet positief.
En toen ik kon doen -
OK, maar ik wil echt dat int krijgen.
Dus kon ik hier ga en ik kon soort van kopieer deze en streepje dit.
En dan, OK.
Als n kleiner is dan of nul doen.
>> Nu, wat als de gebruiker niet meewerkt?
Nou, dan ga ik lenen deze hier.
En dan ga ik in hier en hier en hier.
Dus dit is duidelijk niet de oplossing, toch?
Want er is geen einde in zicht.
Als ik wil om te eisen dat de gebruiker geeft me een positief geheel getal, ik kan
eigenlijk het int.
Ik kan dan controleren voor die int.
Maar dan wil ik het opnieuw controleren en check het opnieuw en opnieuw controleren.
Zo duidelijk, wat is de betere construct hier gebruiken?
Oke, dus een soort van lus.
>> Dus ik ga om zich te ontdoen van bijna alle van deze.
En ik wil dit krijgen int ten minste een keer.
Dus ik ga zeggen te doen -
en ik kom terug naar de come terwijl in slechts een moment -
Nu, wat doen?
Ik ga int n krijgt getInt () doen.
OK.
Dus dat is vrij goed.
En nu hoe vaak doen Ik wil dit doen?
>> Laat ik het printf binnenkant van de lus dus ik kan opnieuw en opnieuw te eisen,
mocht dat nodig zijn.
En wat wil ik dit terwijl de conditie te doen?
Ik wil dit blijven doen terwijl wat is het geval?
Yeah.
N kleiner is dan of gelijk aan nul.
Dus al aanzienlijk hebben we opgeruimd deze code.
We hebben geleend een zeer eenvoudig te construeren - de do-while-lus.
Ik heb gestolen net de belangrijke lijnen van de code die ik begon te kopiëren en
plakken, dat was niet verstandig.
En dus nu ga ik echt plakken het hier en doe het gewoon een keer.
>> En wat moet ik nu wil doen op het einde van dit programma?
Ik zeg gewoon dat iets simpels graag, bedankt voor de - en
Ik zal% i do voor int -
backslash n, komma, en dan plug in n, puntkomma.
>> Oke.
Dus laten we eens kijken wat er nu gebeurt wanneer ik dit programma.
Ik ga om te gaan en doen maken positief.
Verdomme.
Een paar fouten.
Dus laat me schuiven terug naar de eerste.
Werken niet via hen naar achteren.
Werken door ze van boven naar beneden opdat zij cascade en alleen
een ding verkeerd.
Impliciete verklaring van functie getInt ().
Yeah.
Dus het was niet genoeg.
Ik soort van dezelfde fout gemaakt, maar een beetje anders deze keer.
Ik moet niet alleen zijn stdio.h maar Ook cs50.h, die het bevat
zogenaamde verklaringen van krijgen int, die leren van het apparaat, of leert
C wat getInt () is.
>> Dus laat me opnieuw opslaan.
Ik ga naar de andere fouten negeren want ik ga hopen dat ze
een of andere manier verband houden met de fout Ik heb al vast.
Dus laat me gaan en opnieuw compileren met make positieve, Enter.
Verdomme.
Drie fouten, nog steeds.
Laat me schuiven tot aan de eerste.
Ongebruikte variabele n.
We hebben dit niet eerder gezien.
En ook dit is een beetje cryptisch.
Dit is de uitgang van de compiler.
En wat dat gemarkeerde lijn er - positive.c :9:13 -
zegt, het is te zeggen op lijn negen van positive.c op de 13e teken,
13e kolom, je maakte deze fout.
>> En in het bijzonder, is het vertellen me ongebruikte variabele n.
Dus laten we zien -
lijn negen.
Ik ben met behulp van n in de zin dat Ik geef het een waarde.
Maar wat de compiler niet leuk is dat ik niet schijnbaar gebruikt.
Maar wacht eens even, ik gebruik het.
In lijn 11, ik gebruik het hier.
Maar als ik naar beneden scrollen verder bij positive.c :11 -
dus op lijn 11, karakter 12, de compiler vertelt me, het gebruik van
gedeclareerde identifier n.
>> Dus zwartwerk betekent dat ik heb niet gespecificeerd als een
variabele met een gegevenstype.
Maar wacht eens even.
Ik deed precies dat in lijn negen.
Zo iemand wordt hier echt verward.
Het is of ik of de compiler omdat in lijn negen, nogmaals, Ik verklaar een
int n, en ik ben het toewijzen van de retourneren waarde van getInt ().
Dan gebruik ik die variabele n in lijn 11 en te controleren of de waarde lager is
dan of gelijk aan nul.
Maar dit is blijkbaar slecht en gebroken waarom?
Zeg het nog eens?
>> Ah, ik moet n verklaren voordat invoeren van de lus.
Maar waarom?
Ik bedoel, we voorgesteld een beetje geleden dat het is fijn om variabelen op te geven
allemaal op een lijn en dan toewijzen enkele waarde.
Een globale variabele - laten we terugkeren om dat idee in slechts een moment.
Waarom wil je dat ik te zetten Het buiten de lus?
Het is.
Precies.
>> Dus, hoewel, enigszins counterintuitive, laat me samenvatten.
Wanneer u verklaren n binnen van de do blok er -
bijzonder binnenin die accolades -
die variabele n heeft wat riep een scope -
niets ons puntensysteem de natuurlijk - maar heeft een bereik dat is
beperkt tot die accolades.
Met andere woorden, meestal als je verklaren een variabele in een reeks
accolades, die variabele bestaat alleen binnenkant van die accolades.
Zodat deze enkele logica, hoewel Ik heb n verklaarde in lijn negen, het
verdwijnt wezen van het toepassingsgebied, verdwijnt uit het geheugen, om zo te zeggen,
tegen de tijd dat ik raakte lijn 11.
Omdat lijn 11, helaas, is buiten deze accolades.
>> Dus ik helaas kan dit niet oplossen door ga terug naar wat ik deed het eerder.
Je zou in eerste instantie dit te doen.
Maar wat ben je nu niet cyclisch doen?
Je bent natuurlijk niet krijgen het int cyclisch.
Dus we kunnen de getInt () verlaten, en we moet de getInt () in de vertrekken
lus want dat is wat we willen pester de gebruiker voor opnieuw en opnieuw.
Maar het volstaat wel om te gaan tot lijn, zeg, zes.
Int n, puntkomma.
Geef het niet een waarde nog omdat je hoeft niet te gewoon nog niet.
>> Maar nu hier beneden, bericht - dit zou een zeer gemakkelijke vergissing zijn.
Ik wil niet mijn vorige schaduw verklaring van n.
Ik wil de n gebruiken die daadwerkelijk bestaat.
En dus nu in lijn 10, Ik wijs n een waarde.
Maar in lijn zes, verklaar ik n.
En zo kan ik of kan ik niet gebruik het in lijn 12 nu?
Ik kan, want tussen die krullend braces is n nu verklaard?
De ene hier op lijn vijf.
Om een ​​hier op lijn 14.
Dus als ik nu uitzoomen, sla dit bestand, ga terug in en start maken positief, het
gecompileerd deze tijd.
Dus dat is al vooruitgang.
Slash. . / Positief, Enter.
>> Ik eis dat je me een positief geheel getal.
Negatief 1.
Negatief 2.
Negatieve 3.
Nul.
Een.
En bedankt voor de een is wat er nu afgedrukt.
>> Laat ik iets anders proberen, uit nieuwsgierigheid.
Ik word verteld om input een integer.
Maar wat als ik in plaats intypen lam?
Dus zie je nu een andere prompt -
retry.
Maar nergens in mijn code schreef ik opnieuw proberen.
Dus waar, vermoedelijk, is dit opnieuw proberen prompt uit, zou je zeggen?
Ja, uit getInt () zelf.
Dus een van de dingen personeel CS50's doet voor u, althans in deze eerste paar
weken, wordt hebben we een aantal hoeveelheid geschreven van foutcontrole om ervoor te zorgen dat, indien
je getInt () noemen, zul je op zijn minst weer een int van de gebruiker.
Je krijgt niet een string.
Je krijgt niet een char.
Je zal niet iets te krijgen heel anders.
U zult een int te krijgen.
>> Nu, is het misschien niet positief.
Het is misschien niet negatief zijn.
Wij geven geen garanties rond dat.
Maar we zullen pester de gebruiker om opnieuw te proberen, retry, opnieuw proberen totdat hij of zij daadwerkelijk
samenwerkt.
Evenzo, als ik 1.23, dat geen int.
Maar als ik typ in, zeg, 50, dat geeft mij een waarde die ik wilde.
>> Oke.
Dus niet slecht.
Heeft u vragen over wat we net gedaan hebt?
De sleutel mee te nemen zijn, om duidelijk te zijn, niet zozeer de lus, die we hebben gezien
voordat ook al hebben we niet echt gebruikt, maar de kwestie van de reikwijdte, waar
variabelen alleen kan alleen worden gebruikt binnen enkele opgegeven bereik.
>> Oke, laat me het adres van de suggestie eerder hebt gemaakt, dat van een
globale variabele.
Even terzijde, het blijkt dat een andere oplossing voor dit probleem, maar
typisch een oplossing of onjuiste een slecht ontworpen oplossing is
verklaren uw variabele als wat zogenaamde globale variabele.
Nu ben ik soort van het schenden van mijn definitie van omvang omdat er
geen accolades aan de top en de onderkant van een bestand.
Maar de implicatie van die is dat nu in lijn vier,
n is een globale variabele.
En zoals de naam al aangeeft, is het gewoon overal toegankelijk.
>> Kras heeft eigenlijk deze.
Als u een variabele wordt gebruikt, zou je herinneren je moest kiezen als het voor
deze sprite of voor alle sprites.
Nou ja, alle sprites is gewoon het duidelijker manier om te zeggen globaal.
Yeah?
Ah, echt goede vraag.
>> Zo herinneren dat in de allereerste versie van mijn code, als ik verkeerd
gedeclareerd en gedefinieerd n in lijn negen -
Ik verklaarde het als een variabele en ik gaf het een waarde met
de opdracht operator -
Dit gaf me twee fouten.
One, dat n niet is gebruikt, en twee, die in de lijn 11
het was gewoon niet verklaard.
Dus de eerste die ik niet adres op het moment.
Het is niet strikt een fout te verklaren een variabele, maar niet gebruiken.
Maar een van de dingen die we hebben gedaan in de CS50 apparaat, doelbewust,
pedagogisch, is we hebben aangezwengeld het verwachtingen van de compiler te maken
ervoor dat je dingen doet niet alleen correct maar echt correct.
>> Want als je het declareren van een variabele als n en nooit gebruikt, of het gebruik ervan
correct, maar dan wat is het daar?
Het dient werkelijk geen enkel doel.
En het is heel makkelijk na verloop van tijd, als je niet je eigen computer niet configureren in
op deze manier, om alleen maar code die heeft weinig resten hier, resten er.
En dan maanden later je terugkijken en je bent zoals, waarom is deze lijn van
code daar?
En als er geen goede reden is heeft u of uw collega's niet ten goede
op de weg te moeten struikelen over het dan.
>> Even terzijde, waar is dat vandaan?
Nou, herinneren dat elke keer als we compileren programma, allemaal van dit spul is
wordt gedrukt.
Dus we zullen terugkomen naar dit.
Maar nogmaals, maak is een hulpprogramma dat automatiseert het proces van het samenstellen van
uitvoeren van de eigenlijke compiler genaamd Clang.
Dit ding, zullen we uiteindelijk zien, heeft te maken met het debuggen met een speciale
programma genaamd de debugger.
Dit heeft te maken met het optimaliseren van de code - meer op dat in de toekomst.
Std = c99 -
Dit betekent gewoon gebruik maken van de versie van 1999 van C. C is zelfs langer dan rond geweest
dat, maar ze maakten een aantal leuke veranderingen 10 plus jaar geleden.
>> En hier is het relevant zijn.
Wij zeggen maken iets dat eerder zou een waarschuwing zijn geweest
een fout te voorkomen dat de student van compileren.
En wand betekent dat voor een heleboel dingen, niet
alleen gerelateerd aan variabelen.
En dan laat ik ga naar het einde van deze lijn.
En ook dit, we zullen uiteindelijk terug te komen op.
Dit is uiteraard de naam van het bestand dat ik compileren.
Dit herinnert aan de naam van het bestand Ik ben uitvoeren als de naam
van mijn uitvoerbare programma.
Dit-lcs50 betekent gewoon gebruik maken van de CS50 bibliotheek, en alle nullen en enen dat
het personeel schreef en eerder gecompileerde dit jaar, te integreren
ze in mijn programma.
>> En iedereen weet wat-lm is?
Het is de wiskunde bibliotheek, dat is gewoon daar zelfs als je
niet te doen geen wiskunde.
Het is gewoon automatisch verstrekt aan ons door te maken.
>> Nou, laat me u een ander voorbeeld hier door het openen van een nieuw bestand.
En laat me dit opslaan als string.c.
Het blijkt dat als we praten over de gegevens types van vandaag, er is nog meer
gaande onder de motorkap dan we tot nu toe heb gezien.
Dus laat me snel doen een snelle programma.
Omvatten stdio.h.
En ik zal redden dat.
En weet je, laat me niet de dezelfde fout opnieuw en opnieuw.
Omvatten cs50.h.
En laat me nu ga je gang en doe int main (void).
>> En nu wil ik gewoon een programma doen die dit doet - verklaren een string
riep s en krijg een string van de gebruiker.
En laat me een beetje doen instructies hier -
geef me een string - zo de gebruiker weet wat te doen.
En dan hier beneden onder dit, Ik wil het volgende doen -
voor int i krijgt nul.
Nogmaals, informatici doorgaans beginnen te tellen bij nul, maar we konden
maken dat men als we echt wilden.
Nu ik ga doen, ik minder dan de string lengte van s.
Dus strlen -
S-T-R-L-E-N -
nogmaals, het is beknopt omdat het makkelijker te typen, ook al is het een
beetje cryptisch.
>> Dat is een functie die we niet gebruikt vóór maar letterlijk betekent dat -
terug naar mij een nummer dat staat voor de lengte van de tekenreeks
dat de gebruiker heeft ingevoerd.
Als ze ingetypt hallo, zou het terug vijf omdat er vijf
brieven in hello.
Dan, op elke iteratie van deze lus, i plus plus.
Dus nogmaals, een standaard te bouwen, zelfs als je bent niet helemaal te comfortabel of
vertrouwd met het nog niet.
>> Maar nu op elke iteratie van deze lus, merken wat ik ga doen.
Ik wil om vooruit te gaan en af ​​te drukken uit een enkel karakter -
dus% c backslash n op een nieuwe regel.
En dan, weet je wat ik wil doen?
Wat ook het woord is dat soorten van de gebruiker in, zoals hallo, ik wil afdrukken
H-E-L-L-O, een teken per regel.
Met andere woorden, ik wil krijgen op de afzonderlijke tekens in een string,
waarbij tot nu toe een string heeft net is een reeks tekens.
>> En het blijkt dat ik kan doen s, beugel, i, haakje sluiten, sluit
haakjes, puntkomma.
En Ik moet nog een ding doen.
Het is in een bestand met de naam string.h dat strlen wordt verklaard.
Dus als ik wil die functie te gebruiken, Ik moet de compiler te vertellen,
verwacht te gebruiken.
Laat me nu ga je gang en maak het programma genaamd string.
Punt, slash, string.
>> Geef me een string.
Ik zal doorgaan en typen.
Hallo, in hoofdletters, Enter.
En nu merk ik heb dit geprint een teken na de andere.
Dus de nieuwe detail hierbij is dat een string, aan het eind van de dag, kan
toegankelijk door middel van de individuele tekens door de invoering van het plein
haakjesnotering.
En dat komt omdat een string eronder de kap is inderdaad een opeenvolging van
tekens.
Maar wat is er netjes over hen is in het RAM-geheugen van uw computer -
Mac, pc, wat het ook is - ze zijn letterlijk rug aan rug aan rug -
H-E-L-L-O -
bij afzonderlijke, aangrenzende bytes in het geheugen.
>> Dus als je wilt krijgen op de achtste dergelijke byte, die deze lus zou
beugel nul, een beugel, de beugel twee, beugel drie, vier beugel -
die nul is geïndexeerd tot vijf -
dat zal uitprinten H-E-L-L-O op zijn eigen lijn.
>> Nu, als een teaser, laat ik je de allerlei dingen die je zult uiteindelijk
kunnen begrijpen, althans met enkele nauwe kijken.
Voor een, wat we in het huidige voorbeelden, als je wilt, is eigenlijk
een van de allereerste ontsnappingen voor de iPhone.
Jailbreaking betekent dat het kraken van de telefoon zodat je daadwerkelijk kunt gebruiken op een
andere vervoerder of install uw eigen software.
En je zult merken dit ziet er heel cryptisch, waarschijnlijk.
Maar kijk eens naar dit.
De iPhone was blijkbaar gebarsten met een lus, een als voorwaarde, een anders
conditie, een bos van functies we hebben niet gezien.
>> En nogmaals, dat doe je niet bij het eerste gezicht waarschijnlijk
begrijpen hoe dit werkt.
Maar alles wat we soort nemen vanzelfsprekend in ons moderne leven
eigenlijk meestal zelfs beperken tot sommige van deze fundamenten waar we zijn geweest
kijken naar.
Laat me ga je gang en open een andere programma, holloway.c.
Dus ook dit is iets wat je moet niet echt weten.
Zelfs niemand van het personeel of ik kon waarschijnlijk dit uit door te kijken naar
omdat dit was iemands code dat tot wat werd ingediend
van oudsher bekend als een obscure C wedstrijd, waar je een programma te schrijven
dat compileert en draait, maar is zo verdomd cryptische geen mens kan begrijpen wat
het gaat doen tot ze eigenlijk draaien.
>> Dus inderdaad, als je kijkt naar deze code, zie ik een switch.
Ik zie hoofd.
Ik zie deze vierkante haakjes impliceren een soort van een array.
Heeft iemand willen raden wat dit programma eigenlijk
doet als ik zonder Holloway?
Ja.
OK.
Goed gedaan.
Dus alleen het personeel en ik kan niet achterhalen wat deze dingen doen.
>> En nu tot slot, laat me ga je gang en de openstelling van een ander programma.
Deze -
weer, zullen we de broncode te maken online beschikbaar - dit is gewoon
soort van mooi om te zien.
Alles wat ze deden is geraakt de spatiebalk nogal wat.
Maar dit is echte code.
Dus als je denkt dat is vrij, als we daadwerkelijk gereden dit op de prompt,
uiteindelijk zult u zien hoe wij misschien dingen doen als dit.
>> Dus laten we u laten op die nota en zie je op woensdag.
>> [Muziek]
>> SPEAKER 2: Bij de volgende CS50, de TFs stadium een ​​muiterij.
>> SPEAKER 3: Daar is hij.
Grijp hem!
>> [Muziek]