>> [REPRODUCCIÓ DE MÚSICA]
>> ROB BODEN: Molt bé.
Així que, primer el primer, de vídeo a partir d'una cara coneguda.
>> [REPRODUCCIÓ DE VÍDEO]
>> -Molt bé.
Aquest és CS50, i això és l'inici de la tercera setmana.
Ho sento jo no podia ser-hi amb vosaltres avui, però permeteu-me presentar-
Propi Boden Rob CS50.
>> [VIDEO PLAYBACK FI]
>> [Aplaudiments i crits]
>> ROB BODEN: La filmografia de que el vídeo és fantàstic.
Està bé.
Així que primer, hi ha un altre dinar.
És demà a les 01:15.
No hi ha dinar aquest divendres.
És amb Quora.
I Tommy encara no és aquí, però un la gent d'allà és excap CF,
Tommy McWilliam.
Així que ell és un tipus divertit.
Vostè ha de venir.
>> Està bé.
Així que la setmana passada, vam començar trencar sobre el que una cadena és en realitat.
Hem sabut des del principi que que és una seqüència de caràcters.
Però la setmana passada, hem aprofundit en el fet que el que és en realitat una seqüència de
personatges, bé, ara tenim arranjaments de caràcters.
I sabem que una cadena, que és una matriu de personatges, al final,
tenim aquest byte nul especial, aquest barra invertida 0, que indica el final de
la cadena.
>> I així, una cadena és un arranjament de personatges, però podem tenir més de
només un conjunt de caràcters, podem tenir una matriu de qualsevol
tipus de coses que volem.
Per tant, si vostè recorda de la setmana passada, el Programa d'Edat que David va introduir
molt ràpid.
Així que el primer que farem és demanar a l'usuari un nombre sencer, el
nombre de persones a l'habitació.
Un cop tinguem aquest sencer, estem declarant una matriu.
Observi aquesta sintaxi suport.
Vostè va a acostumar-se a això.
>> Així que estem declarant una matriu d'enters diuen les edats, i hi ha n
sencers en aquesta matriu.
Així que aquest patró aquí, aquest abril int i és igual a 0, i és menor que n, i més
a més, que també serà un patró que vostè aconsegueix molt acostumat.
Perquè això és més o menys com ets sempre va a iterar sobre arrays.
Així que recorda que n és el longitud de la nostra matriu.
Així que aquí, estem demanant repetidament per l'edat de la persona i a l'habitació.
>> Després d'això, anem cap avall, i per qualsevol raó arbitrària, llavors
imprimir l'edat que van a ser un any a partir d'ara.
I executar aquest programa, anem a fer edats, punt edats slash.
Així que el nombre de persones a l'habitació, diguem que hi ha tres.
I dir, la primera persona és de 13, següent és 26, i l'últim és 30.
Així llavors va a iterar sobre els tres gent, imprimeixen 14, 27 i 31.
>> Així que recordi que quan declarem 1 matriu de grandària n, els índexs en què
matriu, la matriu té valors i índexs 0, 1, 2, tot el camí
fins an almenys 1.
Així que quan ens va dir que hi havia tres persones en el quart, i el posem aquí
la primera iteració a través d'aquest bucle, i serà 0.
Així que en l'índex 0.
Estem assignant la primera Edat L'usuari introdueix.
Després, en el següent, estem entrant en el segon n l'usuari entra, i en
al costat de dos, l'últim n.
>> Així adonar que una matriu de mida tres no té res
en l'índex de tres.
Això no és vàlida.
Està bé.
Així que, tornant aquí.
Així que ara que hem tractat amb matrius, tenim certa familiaritat.
Ara anem a passar a comandaments arguments de la línia, que seran
molt rellevants per a aquest conjunt de problemes.
>> Així que, fins ara, cada vegada que vostè té declarar que la seva funció principal, que hem
va dir void main int.
Així buit només significa que no estem passant qualsevol
arguments d'aquesta funció.
Ara anem a veure que la principal pot prendre alguns arguments.
Aquí els anomenem int argc i els suports argv cadena.
Els suports, un cop més, el que indica que estem tractant amb matrius.
Així que aquí, entre parèntesis argv cadena, estem es tracta d'una matriu de cadenes.
Així argc, això va a indicar quants arguments que hem
passat a aquest programa.
I per veure el que això significa, anem a tancar això.
>> D'acord.
Així que, fins ara, ens hem quedat tots programa com les edats de la ratlla vertical de punts.
Podem també, en la línia d'ordres, més enllà passar arguments, d'aquí el terme, la comanda
arguments de la línia.
Així que el primer argument, hola món.
Així que aquí, argc seria 3.
És el recompte dels arguments en la línia d'ordres.
Argc és sempre almenys 1, des del punt retallar les edats, en si, que compta com un
els arguments de la línia d'ordres.
>> Després hola és la primera.
Si edats slash dot és el zero, aleshores hola és la primera, i el món és la
segon argument de la línia d'ordres.
Així que la cadena argv, anem a veure, conté les cadenes, slash dot
edats, hola, i al món.
I, per la petició de David, anem per reproduir un vídeo d'introduir.
>> [REPRODUCCIÓ DE VÍDEO]
>> -Fins ara, en els programes que hem per escrit, hem declarem
principal void main com int.
I tot aquest temps, aquest buit té simplement s'especifica que el
programa no pren cap arguments de la línia d'ordres.
En altres paraules, quan un usuari executa una programa, ell o ella pot proporcionar comanda
arguments de la línia de l'escriptura addicional paraules o frases després del programa
nom en l'indicador.
>> Bé, si vostè no desitja que el seu programa per prendre arguments de línia d'ordres, un o
més d'aquestes paraules, hem de reemplaçar anul · lar amb un parell d'arguments.
Així que anem a fer això.
Inclogui CS50.h.
Inclogui io.h. estàndard
Int principal.
I ara, en lloc de buit, em vaig a especifiqueu un sencer anomenat argc i una
matriu de cadenes denominades argv.
Ara, argc i argv són simplement convencions.
>> Podríem haver cridat a aquests arguments més el que vulguem.
Però l'important és que argc és 01:00 int perquè, per definició, és
contindrà el nombre de l'argument, la nombre de paraules en total que l'
usuari ha escrit al seu sol · licitud.
argv, per la seva banda, l'argument de vectors, és serà en realitat una matriu d'emmagatzematge
totes les paraules que l'usuari té escrit en la sol · licitud.
>> Anem a procedir a fer alguna cosa ara amb un o més d'aquests
arguments de la línia d'ordres.
En particular, seguirem endavant i imprimir qualsevol paraula que l'usuari
després del nom del programa en l'indicador.
Suport Obre.
Tancar suport.
Cent Printf s barra invertida i coma.
I ara he de dir-te printf quin valor per connectar a aquest marcador de posició.
Vull que la primera paraula que l'usuari té escrit després del nom del programa,
i per això em vaig a especificar argv suport 1, prop
parèntesi, punt i coma.
>> Ara, per què el suport 1 i que no suporti 0?
Bé, resulta que, emmagatzemada automàticament en argv 0 serà el
nom real del programa.
Així que la primera paraula que l'usuari després del nom del programa és, per
convenció, serà emmagatzemat en argv 1.
Ara anem a compilar i executar aquest programa.
>> Fer argv 0, slash argv punt 0.
I ara una paraula com hola.
Intro.
I aquí el tenim, hola.
>> [VIDEO PLAYBACK FI]
>> ROB BODEN: Molt bé.
Tanca aquesta.
Així que fer una ullada a aquest programa que hem introduït per a nosaltres, bé,
per mostrar, si imprimim argv 0, marca, ara Què és, argv 0, slash argv punt 0.
Així que, com s'esperava, s'imprimeixi la el nom del programa, ja que és argv 0
sempre serà el el nom del programa.
Però farem alguna cosa una poc més interessant.
>> Així, en el conjunt de problemes, vostè serà introduït a aquesta funció, atoi.
Llavors, què és el que utilitzem per atoi?
Això va a convertir una cadena a un enter.
Així que si pas la cadena, un, dos, tres, a atoi, que ha de convertir en què
al sencer, un, dos, tres.
Així que anem a convertir la primera línia d'ordres argument en un enter,
i després simplement imprimir aquest sencer.
>> Així que, bàsicament, estem una mica reimplementar getint, només el
sencer s'introdueix en la comanda línia en lloc de en el programa
interactiva.
Així doncs, fent argv 0, farem que aquí, i tancar aquesta.
Llavors, executar argv 0, i entrarem en el nombre enter, un dos tres, quatre un dos.
Així que va a imprimir el nombre enter, un dos tres quatre un dos.
Hi ha algunes subtileses que atoi que que deixarà de preocupar de res
més enllà d'un caràcter numèric vàlid, però això no importa.
>> Llavors, què creus que passa si faig això?
Decisió de segmentació.
Llavors per què és això?
Si un mira cap enrere en el nostre programa, estem convertir argv 1, el primer argument
després que el nom del programa, a un enter.
Però no hi ha un argument que es passa després que el nom del programa.
Així que aquí, veiem que es tracta d'un buggy programa, ja que, si tractem d'executar
sense cap argument, simplement es penjarà.
>> Així que un altre patró comú veuràs és com, si argc és menys
de dos, el que indica que no hi havia almenys el nom del programa i una
primer argument, llavors farem alguna cosa com printf, no n'hi ha prou
arguments de la línia d'ordres.
Això probablement no és una bona per imprimir, és probable que sigui alguna cosa, com
haurà d'ingressar un nombre enter en la línia d'ordres.
Vaig a acabar allà.
I després tornar 1.
Així que recordi que al final de la nostra programa, si tornem 0, aquest tipus de
indica l'èxit.
I principal també automàticament retorna 0 si no ho fa.
>> Així que aquí, estem resintonitzar 1 per a indicar que aquest no és l'èxit.
I vostè pot tornar el que vulguis, simplement, 0 indica l'èxit, i
res indica fracàs.
Així que anem a executar aquesta versió de les coses.
Així que ara, si no entrem en una línia d'ordres argument, et dirà correctament
nosaltres, no la línia d'ordres suficient.
No va acabar la frase.
Si no, si realment vam passar una, pot completar el programa.
Així que això és com es pot utilitzar argc en tal de validar el nombre de
Arguments de línia de comandes que repercussió efectiva.
>> Així que farem d'aquest programa una mica més complicat, i mirar a la segona
iteració de les coses.
Així mateix, estem no només imprimir el primer argument de la línia d'ordres.
Aquí, estem iterant d'iguals i int 0, i és menor que argc, i més
més, i argv impressió, l'índex i.
Així que aquest patró, de nou, aquesta és la mateixa patró com abans, excepte que en lloc
de cridar a la variable n, estem usant argc.
>> Així que aquesta és la iteració a cada índex en la matriu, i la impressió de cada
element de la matriu.
I per això, quan ens trobem aquest programa, bé, No vaig entrar a qualsevol línia d'ordres
arguments, de manera que només imprimeix el nom del programa.
Si entro en un munt de coses, que va a imprimir un, cadascun en la seva pròpia línia.
>> D'acord.
Així que anem a fer un pas més enllà.
I en lloc d'imprimir cada argument en la seva pròpia línia, anem a imprimir cada
caràcter de cada argument en la seva pròpia línia.
Així que recordi que argv és una matriu de cadenes.
Llavors, què és una cadena, però una matriu de caràcters?
Així que això significa que argv és realment una conjunt d'una matriu de caràcters.
Així que aprofitant que, anem a ignorar això per ara.
Anem a considerar la cadena argv 0.
>> Així que si volem portar a cada caràcter de argv 0 en la seva pròpia línia, llavors vull
per fer el patró del que estem acostumats, i és menys de la longitud de la matriu,
que en aquest cas, és de strlen, això és no el que jo vull fer, cadena
s és igual a argv 0.
Així que i és menor que la longitud del nostre matriu, que en aquest cas és una matriu
de personatges, i més plus.
I així, com vam veure la setmana passada, és ideal si ens movem que strlen fora
de la condició, ja que n serà l'addició de el strlen de s cada vegada que anem
a través del bucle, i és No estarà canviant.
Així que anem a establir és igual a n per aquí.
>> D'acord.
Així mateix, estem interactuant sobre cada índex de la matriu.
I per això, si volem imprimir cada caràcter en aquesta matriu, per cent c és
la bandera que volem utilitzar per als caràcters.
I ara una i suport serà el cadena, caràcter d'índex i, pel que si el
cordes eren hola.
Llavors S 0 serà H, S suport 1 haurà de correu, i així successivament.
>> Així que ara volem combinar aquestes dues coses.
Volem imprimir cada caràcter de cada argument de la línia d'ordres.
Així que tindrem un bucle For niat.
I convencionalment, el primer comptador Sóc jo, el proper serà j, n
serà el strlen de argv i, i és menor que n, i més plus.
I ara en lloc d'imprimir argv i, pel que argv suport i va a la llista -
que serà la línia d'ordres-i th argument argv i, j es va a
ser el caràcter j-èsim de l'argument-i.
Em desfaré d'això aquí i ara ja que ens posem en aquest bucle.
Així que és equivalent als iguals de corda s argv i, i després s suport de j.
>> Bé, nosaltres no hem de declarar aquest s variable.
En lloc d'això, només haurem de combinar aquests 2 en el que teníem, argv i, j.
>> ALTAVEU 1: [inaudible].
>> ROB BODEN: Bé dit.
Així que això està trencat.
Si jo en realitat va córrer, ho faríem s'han adonat d'això.
Així que el comptador que m'importa en aquest particular per
bucle és j, l'iterador.
Així que caldria tingui problemes, probablement un bucle infinit, si ens
no havia fixat que.
És per això que també estem parlant sobre la depuració d'avui.
>> D'acord.
Així que anem a executar aquest programa.
I siguem realment afegir un printf separada aquí que s'acaba d'imprimir
altra línia, ja que això significa quan executar el programa, hi haurà un espai en blanc
línia entre cada caràcter de cada argument de la línia d'ordres.
Bé, anem a veure el que això significa.
Oop.
Tens algun error.
Error implícitament declarant funció de biblioteca strlen.
>> Tornant al nostre programa, que es va oblidar d'incloure el hash string.h.
Així string.h serà el arxiu de capçalera que declara
la funció strlen.
Bé, que compila.
Ara, anem a executar-lo.
Així que això.
Es va a imprimir el nostre nom del programa, hola món.
Es va a imprimir cada cosa, cada caràcter, en la seva pròpia línia.
D'acord.
>> Així que aprofitarem aquesta realitat un pas més enllà.
I en lloc d'utilitzar string.h, anem a pensar en com ens agradaria implementar la nostra pròpia
funció strlen.
Així que em vaig a donar immediatament una firma de funció.
Així que anem a trucar en my_strlen, i és Va a prendre una cadena com a argument,
i esperem tornar l' longitud d'aquesta cadena.
Així que, on és aquest tipus?
Sí
D'acord.
Així que recordi de la diapositiva anterior que També va ser de la setmana passada, que un
arranjament de caràcters, així, una cadena, així que diguem que aquesta és la nostra cadena s.
Així que si s és la cadena, hola, a continuació, H-I-L-L-O, a la memòria, que va a
ser, i tot seguit, aquesta barra invertida 0 caràcter.
>> Llavors, com fem perquè la longitud de s?
Bé, el truc està a la recerca d'aquest 0 contraatac caràcter, aquesta nul
terminador.
De manera que l'algorisme es va a ser alguna cosa així com uns pocs
suficients caràcters que -
anem a fer aquesta mà representen alguns taulell, anem a trucar a aquesta longitud int.
Així, a partir d'aquí, estem va a iterar sobre la nostra cadena.
>> Així que el primer caràcter, és H, i no és de nou slash 0, de manera que
la longitud és 1.
Iterar fins al següent caràcter, I, i no és la barra invertida 0.
La longitud és de 2.
L, 3.
L, 4.
O, 5.
I, finalment, arribem a la barra invertida 0, de manera que això significa, així,
aquesta cadena ha acabat.
Així que anem a tornar maig.
>> Així que en realitat l'aplicació que, en primer lloc, la meva longitud n és igual a 0, la mà dreta.
I repetirem -
>> ALTAVEU 1: [inaudible]
>> ROB BODEN: Oh, disparar.
Bona decisió.
Boom.
Així longitud n és igual a 0.
Així que ara, la durada, per s no igual i després, la barra invertida 0.
Així que recordi, aquesta barra invertida 0, es tracta d'una caràcter real, i indica
al final de la cadena.
Igual que, també, la barra invertida n és un personatge real.
Backslash 0 indicarà Al final de la nostra cadena.
No vull posar això aquí.
I mentre que s indexats per la longitud no és igual al terminador nul,
només anem a incrementar la longitud.
Així doncs, al final del nostre programa, longitud finalment es va a
ser 5 en aquest cas.
I acabem tornarem longitud.
>> D'acord.
Així que ara aquí, no ho sé fer my_strlen.
Anem a compilar per assegurar tot funciona sense problemes.
Estava fent en 2?
O era que 1?
Això hauria de ser suficient.
Està bé.
Així que això és argv 2.
Funciona com s'esperava, tot i era que el que jo feia a?
Sí
D'acord.
Aquesta versió del que no tenia la línia nova després de printf, però
no fa cap diferència.
D'acord.
Així va treballar com s'esperava.
>> Ara fins i tot podem combinar aquesta un pas A més, quan resulti avís aquí, bé,
primer, estem agafant el strlen de argv i, i llavors estem interactuant sobre
cada caràcter en la cadena.
Així que en comptes de fer això, i si ens simplement combinar aquesta lògica de l'espera
fins que arribem a la barra invertida 0 dret en aquest bucle?
Així iterar mentre argv i, j fa és igual a 0 barra invertida.
Així que anem a executar en primer lloc.
>> Està bé.
Així que aquí, aquesta condició està dient -
anem a aclarir això.
Així que ara, que això sigui la nostra argv.
Així que quan m'acaba d'executar aquest programa abans, argv és una matriu de cadenes.
I així, si ho executo amb argv slash dot 2, hola món, llavors el argv
si és la longitud 3, per argv zero, hola, i al món.
>> I dins de cada un d'aquests índexs, és a dir, en si una matriu, on això serà
punt, això serà slash, no sé si aquesta era la direcció correcta, em
no crec que era.
A-R-V tauler, necessita més espai.
Anem a tallar a la matriu.
Tauler 0, i després barra invertida 0 A-R-V.
I llavors en el caos serà hola.
Diguem, H-I barra invertida 0.
I, finalment, W-O barra invertida 0.
>> De manera que l'algorisme que només escrivim, el niu bucles, el que estan
fent és, en primer lloc tenim la comptador i i j a continuació.
Això seria més fàcil amb codi en el pantalla, Tornem a això.
D'acord.
Llavors noto que i és l'iterador que és iterar sobre cada comanda
argument de la línia.
I j és la iteració iterador sobre cada caràcter en què
argument de la línia d'ordres.
Així que el que això printf més interna està fent És a dir, tenim printf argv 0 0, printf
argv 0 1, printf argv 0 2 0 3 0 4, 0 5, 6 0, però ara, argv 0 7 va a
igualtat de barra invertida 0.
>> Així que vam sortir d'aquest bucle, i ara itera a 1.
I ara anem a imprimir argv 1 0, argv 1 1 -
bé, ara, des que em vaig tallar hola curta, argv febrer 1 El nou serà
barra invertida 0.
I així, s'incrementa i i continuar, i així successivament, fins que ens imprimim tots
món, i els tres són de línia d'ordres arguments, i anem a sortir del
el bucle més extern, i acabar el nostre programa.
D'acord.
>> Així que anem a arribar fins aquí.
Així obtindrà una certa familiaritat amb arguments de la línia de comandaments en aquest
conjunt determinat problema.
>> Ara, la depuració.
Així que és probable que ja hagi hagut de fer certa depuració amb el seu anterior
estableix problema.
I una manera molt fàcil de depuració, en primer lloc, donem una ullada a un programa de buggy.
Bé, caminar a través d'aquest programa, anem a demanar a l'usuari per a una
sencer, agafa aquest sencer, i després, arbitràriament, tenim un bucle while que
només va a disminuir i fins que sigui igual a 10.
Anem a suposar que estic introduint un nombre enter més gran que 10.
Així decrement i fins que sigui igual a 10.
>> I després tenim un altre bucle while que, si bé i no és igual a 0, estem
disminuirà en un 3 i.
Així que si veus la intenció de l'error aquí, és que això va a decrementar i per
ser 10, i llavors aquesta voluntat bucle while i decrement del 10, a 7, a 4, a 1,
a negatiu 2, 5 a negatiu, i així successivament, fins a l'infinit negatiu, ja que vaig a
En realitat mai de ser igual a 0.
I després, al final d'aquest programa, tenim la funció foo que és
passant impressió que jo.
>> Així que aquest és un programa curt i trivial, i l'error és obvi,
sobretot després que acabo de va dir quin era l'error.
No obstant això, la intenció aquí és, bé, això podria realment es veuen com a part de la seva
solucions de cobdiciosos de l'última conjunt de problemes, i que per tant no tingui
alguns bucle infinit en el seu programa, i no tens ni idea
Què està causant.
Així que una tècnica de depuració molt útil és afegir només printfs
tot el seu codi.
>> Així que aquí vull un printf fora primer bucle while.
I jo vull un printf, i jo només vaig a imprimir i.
Fins i tot em vaig a fer primer while, i.
A l'exterior, mentre que el segon bucle.
Un cop més, imprimiu l'interior d'aquí, el valor de i.
I anem a córrer això.
>> Debug slash Així punt.
Introduïu un nombre enter.
Farem 13.
I de cop.
Veiem que estem bucle infinit dins del segon bucle while.
Així que ara que sabem el que l'error és.
Però la depuració printf és perfectament bé, però una vegada que els seus programes obtenen
més llarg i complicat, hi ha solucions més sofisticades a
fer les coses de treball.
Així que anem a eliminar tots aquests printfs.
I anem a fer que no ho vaig fer trencar res.
D'acord.
>> Així que el programa que anem introduir s'anomena
GDB, per a GNU depurador.
Bé, en realitat, anem a eliminar de depuració per una segona, i fer de depuració de nou.
Bé, en realitat en primer lloc, una bona lliçó en els arguments de línia de comandes.
Tingueu en compte que aquesta comanda Clang és compilar tot s'està passant
en la línia d'ordres, aquests valors arguments de la línia d'ordres.
Llavors, com es va a utilitzar arguments de la línia d'ordres, com es
ho va fer abans, i el que vulguis en PSET 2, així és com Clang els està utilitzant.
>> Així que adonar-se que aquesta primera bandera, guió ggdb3, el que està dient és: Clang,
vostè ha compilar aquest arxiu amb el intenció que amb el temps es
necessari per depurar.
Així que, mentre vostè té aquesta bandera, llavors podem GDB depuració.
I va obrir el depurador de GNU.
>> Així que hi ha una gran quantitat d'ordres que ha de acostumar.
El primer que probablement immediatament necessitar està a Executar.
Llavors, què és Executar farà?
Això va a començar el nostre programa.
Correu de tal manera, en iniciar el programa, el programa ens demana un nombre enter de 13.
I llavors és un bucle infinit com era d'esperar, excepte Vaig treure el
printfs, de manera que ni tan sols veiem això.
Va sortir amb normalitat.
Oh.
És possible que envolta tot el revés, de nou a - ignorar això.
Suposem que no sortir normalment.
Hi ha una resposta complicada que això.
>> Així que ara, això no és molt útil.
Pel que només s'executa nostre programa a l'interior de Aquest depurador no ens ajuda en qualsevol
manera, ja que podríem haver fet dot slash depuració des de fora del BGF.
Així el comandament que probablement et -
i vaig a sortir d'aquesta.
-Control d o deixar de fumar, tant a la feina.
Així que anem a obrir de nou.
>> Una altra ordre que probablement immediatament voler
acostumar és Break.
Així que anem a trencar el principal, per ara, i després vaig a explicar això.
Bé, aquí veiem establim un punt d'interrupció en aquesta línia en debug.c.
Llavors, què significa ruptura és que quan escriure executar, el programa va a
continuarà funcionant fins que Em va colpejar un punt d'interrupció.
Així que quan vaig arribar a l'execució, el programa s'inicia, i tot seguit, es trenca tan aviat com es
entra en la funció principal.
Trencar principal serà una cosa vostè bastant comú fa.
>> I ara, per presentar- a alguns més ordres.
Noteu aquí, que està dient que es va trencar en la línia 11, que és
printf, introduïu un enter.
Llavors la comanda següent serà la forma en ens anem a la següent línia de codi.
Això permetrà que fem un pas a través de la nostra línia de programa per línia.
Així que la propera.
>> Ara la línia 12, que anem per obtenir el nombre enter.
Següent.
I si simplement premeu la tecla Enter de nou, que va a refer l'última cosa que va fer.
Així que no he d'escriure al costat cada vegada.
Així que entrar en un enter de 13.
Així que ara, la línia 14, mentre que i és més gran de 10, i faré tot seguit.
I veiem que anem a disminuir i.
Així que anem a disminuir i de nou.
>> Així que ara, una altra utilitat comanda és Imprimeix.
Així impressió es va a imprimir el valor de la variable.
Anem a posar de manifest el valor d'i variable.
Anem a imprimir i.
Es dirà i és 11.
Ara estem de nou en Següent, mentre i és més gran que 10.
Així que és encara més gran que 10, ja que és 11.
i minus minus.
Anem a imprimir i de nou.
Com era d'esperar, és 10.
>> Així que ara, al costat.
Es va de nou a la condició, i és major de 10, però i és ara 10, de manera que
no és més gran que 10, pel que esperem que caigui del bucle while.
I ara estem per sota de la línia de codi.
I un altre ordre, Llista, només va per mostrar l'anterior i següent
parell de línies de codi, en cas que va perdre a si mateix.
Així que només sortia d'aquest bucle while, i ara hem entrat en aquesta
while, línia 18.
Així, mentre que i no és igual a 0.
I, a continuació, i és igual a i menys 3, i anem a notar, això només seguirà endavant.
I podem imprimir i.
>> Cada comandament té una mena de dreceres.
Llavors p és l'abreviatura d'impressió.
Així que pot p i.
Hem de tenir la celebració de n, o seguir fent a Següent.
Imprimir i de nou.
Vostè veu ara és negatiu 167.
Així que això durarà per sempre, però no realment per sempre, ja que acaba de veure, és
acabarà en realitat en algun moment.
>> Així que comença GDB.
Però farem una cosa més a GDB.
Uh, de depuració.
Així, en aquest cas particular, la bucle infinit va passar a estar dins de
la funció principal.
I per ara, només acceptar que que sóc va a moure el bucle infinit en
la funció foo.
Només recordeu que, al final d'aquest programa, bé, això va ser originalment
trucar a foo, que era voleu imprimir i.
Però ara estem cridant foo, que és disminuirà i fins que sigui 0, i
a continuació, imprimir aquesta variable.
D'acord.
Deseu això.
Fer debug.
I ara, de depuració gdb.
D'acord.
>> Així que si només Corro llavors jo no vaig a poder donar un pas en realitat a través del meu
línia per línia de programa.
Així que anem a trencar en el principal, i escriviu termini.
Així de passar per això, printf, introduïu un enter, obtenir el nombre enter de 13.
Així que seguirem decrement fins que i és més gran que 10.
Llavors anem a caure a través de la while, i arribar a la línia -
obrirem cap amunt en una finestra separada.
Així que disminueix fins que jo no era més gran que 10, i després
crida a la funció, foo.
>> I què va passar tan aviat com em va colpejar function foo, bé, em crida foo, i
llavors ja no vaig tenir control sobre GDB.
Així que tan aviat com em va colpejar a Següent en aquesta línia, coses van continuar fins que va passar això,
on el programa va sortir al -
assumeixi que no existia el temps.
Vostè ho va veure fer una pausa per un moment però.
Llavors, per què he perdut el control sobre el programa en aquest moment?
Bé, quan escric a continuació, que es destina a la següent línia de codi literal que
s'executarà.
Així que després de la línia 21, la següent línia de codi que s'executarà és la línia 22,
que és, que surt de principal.
Així que no em vull anar a la següent línia de codi.
Jo vull entrar en la funció, foo, i després també pas a pas
aquestes línies de codi.
>> Així que per això, tenim una alternativa.
Deixem d'això una altra vegada.
Trencar principal.
Uh, 1, següent, següent, el 13, al costat, següent, següent, amb cura,
abans de tirar-nos a foo línia.
D'acord.
>> Així que ara, que estem en la línia 21, on anomenem foo.
No volem que escrigui al costat, ja que s'acaba de cridar a la funció foo, i
anar a la següent línia de codi.
El que volem utilitzar és el Pas.
Així que hi ha una diferència entre el Pas i Next, on el pas entra a la
funcionar, i Next va sobre la funció.
Simplement executa la totalitat de la funció i segueix pujant.
>> Així que pas ens portarà en la funció, foo.
I veiem aquí, ara, estem de tornada a aquest bucle while que és, en teoria,
continuarà per sempre.
I si es colpeja Pas, quan ni tan sols és una funció per cridar, llavors és
idèntica al següent.
Així que és només quan vostè està en una línia que està cridant a una funció que Step
va a diferir de Següent.
Així Pas ens portarà aquí.
Pas, pas, pas, pas, pas, pas, i Tindrem bucle infinit per sempre.
>> Així que és possible acostumar-se a que, com el seu forma d'identificar bucles infinits, és
només la celebració d'aquesta tecla Enter per veure on et quedes encallat.
Hi ha millors maneres de fer-ho, però per ara, això és perfectament suficient.
I estilísticament, per complir amb Estil 50, que hauria d'haver fet això.
D'acord.
>> Així que una última ordre a introduir.
Bé, anem a gdb depuració polz
Així que en lloc de trencar a principal, si conèixer la funció foo és també el
problema, llavors jo podria tenir només va dir, trencar a foo, al seu lloc.
Diguem que jo trenco en tant principal i foo.
Així que vostè pot configurar tants punts d'interrupció com vulguis.
Quan escric termini, que va per parar al -
ooh, anem a tornar a compilar, ja que He canviat les coses.
Vostè veurà aquesta línia, Notes, font arxiu és més recent que la executable.
Així que això significa que em vaig anar d'aquí i canviat aquests per ajustar-se Estil
50, però no a compilar el programa.
Així GDB em fa conscient d'això.
Deixaré, fer debug de nou, colpejar debug gdb.
D'acord.
>> Així que ara, de tornada al que estava fent.
Trencar principal foo, trencar.
Ara bé, si executo el programa, pel que és continuarà fins que fa un
punt d'interrupció.
Aquest punt d'interrupció passa a ser el primer a principal.
Ara, en comptes de fer les següent, següent, següent, següent, següent, fins que vaig arribar a foo, I
pot escriure continuar, que continuarà fins arribar a la següent punt d'interrupció.
He de introduir el nombre enter primer.
Continuar continuarà fins que vaig arribar a la següent punt d'interrupció, que és que
funció de foo.
>> Així Run s'executarà fins arribar a un punt de ruptura, però només s'escriu d'execució quan
vas a començar el programa i, a continuació, a partir de llavors, és continuar.
Si acabo de fer trencar principal i després va córrer, es trencarà en
principal, i després continuar.
Com jo no tinc un punt d'inflexió en foo, introduir el nombre enter, llavors ara estic
no trencarà a foo.
Només va a infinit bucle fins que.
D'acord.
>> Així que això és Introducció a GDB.
Vostè ha de començar a usar-lo en els seus butlletins de problemes.
Pot ser molt útil per identificar errors.
Si realment just, línia per línia, vagi a través del seu codi, i comparar el que és
succeint realment amb el que s'espera a succeir, llavors és bastant
difícil passar per alt els seus errors.
D'acord.
>> Així que la setmana passada David va fer pujar aquest coses secretes Criptografia de clau per a la
primera vegada, on no volem contrasenyes només poden emmagatzemar en el nostre
ordinador en algun arxiu de text sense format, on algú pot venir i simplement
obrir-lo i llegir-lo.
L'ideal és que es xifren d'alguna manera.
I en exercicis 2, se'l tracta amb un mètode de xifrat,
O, bé, dos mètodes, però que no són tan grans.
Si ho fa l'edició hacker, ets també estarà tractant amb
desxifrar algunes coses.
>> Així que la qüestió ara és, bé, encara que tenim el xifrat més potent
algoritme al món, si vostè escull un particularment pobre contrasenya, llavors
no l'ajudarà molt, ja que les persones encara serà capaç de entendre-ho.
Encara veient la cadena xifrada i sembla un embolic d'escombraries
que no significa res per a ells, si encara només ha de provar un parell de contrasenyes
per entendre-ho, llavors vostè no són molt segures.
Així que veure un vídeo que fa que aquest punt.
>> [REPRODUCCIÓ DE VÍDEO]
>> -Casc, vostè Dimoni.
Què està passant?
Què estàs fent amb la meva filla?
>> Me-Permeteu-me que introduir el brillant jove cirurgià plàstic, el Dr Phillip
Schlotkin, el més gran del nas home de treball a tot el
univers, i Beverly Hills.
>> -La seva Altesa.
>> -Nas treball?
No entenc.
Ella ja ha tingut una cirurgia de nas.
Va ser un dolç setze present.
>> -No.
No és el que penses.
És molt, molt pitjor.
Si no em dones la combinació de l'escut d'aire, el Dr Schlotkin es
donar a la seva filla de tornada a la seva antiga nas.
>> -No.
D'on vas treure això?
>> -Molt bé.
T'ho diré.
No, pare.
No, no ho has de fer.
>> -Tens raó, estimada.
Vaig a estranyar la seva nova nas.
Però jo no li vaig a dir la combinació, no importa què.
>> -Molt bé.
Dr Schlotkin, fes el que vulguis.
>> -És un plaer.
>> [TOOLS es va aguditzar]
>> -No.
Esperi.
T'ho diré.
>> -Jo sabia que anava a funcionar.
Està bé.
Dóna-m'ho.
>> -La combinació és un.
>> -Un.
>> -Dos.
>> -Tres.
>> -Quatre.
>> -Cinc.
>> -Així que la combinació és un, dos, tres, quatre, cinc.
Aquesta és la combinació més estúpida Que he sentit en la meva vida.
Aquest és el tipus de cosa que un idiota tindria en el seu equipatge.
>> -Gràcies, Altesa.
>> - Què vas fer?
>> -Vaig apagar la paret.
>> -No, no ho vas fer.
Va apagar la pel · lícula sencera.
>> -He d'haver premut el botó equivocat.
>> -Bé, el va posar de nou.
Col loqueu la pel · lícula de nou.
>> -Sí, senyor.
Sí, senyor.
>> -Anem, Arnold.
Va, Gretchen.
Per descomptat, vostè sap que jo seguiré haver de cobrar per això.
>> [VIDEO PLAYBACK FI]
>> ROB BODEN: Molt bé.
Així que ara que ja estem parlant de seguretat en algunes maneres, agradable
petit cartell de la pel · lícula, pel que en els últims anys dia, aquests temes amb la NSA
el seguiment de tot.
Pot ser difícil per sentir que tenir algun tipus d'intimitat al
món en línia, encara que no podria dir que la major part dels detalls de PRISM.
Així que anar més enllà de PRISM, no anem a parlar d'això, ara
pensar a l'ordinador portàtil.
Així que aquí, vull canviar al meu compte real,
amb el meu petit pingüí.
Així que tinc una contrasenya establerta, i que contrasenya és el que jo vull que sigui.
>> Però recordeu que el que estic tala amb, de manera que aquest inici de sessió
ràpida, és un programa.
És un programa que va ser escrit per alguna persona.
I així, aquesta persona, si són particularment maliciós, que van poder
han dit, està bé, així que si la contrasenya que entro és igual al meu
contrasenya real, o és igual en certa clau especial -
David és increïble o alguna cosa -
després deixar-los entrar
Així que un programador maliciós podria tenir l'accés a totes les seves Macs, o
Finestres, o qualsevol cosa.
>> Així que no és una gran preocupació, ja que, Vull dir, aquest és el programa d'inici de sessió
això s'envia amb OS X, centenars o milers de persones tenen
revisat aquest codi.
I així, si, en el codi en algun lloc, vostè dir si aquesta cadena és igual als iguals
David és impressionant, inici de sessió, llavors algú està serà, com, esperi.
Això no està bé.
Això no hauria d'estar aquí.
Així que aquesta és una manera de fer les coses a ser una mena d'assegurança.
>> Però pensa en programes fins i tot que escriviu.
Diguem que vostè va escriure el programa d'inici de sessió.
Així que aquest programa d'inici de sessió que vostè va escriure, de manera que, òbviament, vostè és un bon
programador.
No vas a posar qualsevol maliciós si x és igual a és igual a David és impressionant
en el codi.
Però aquest programa, el que es fa utilitzar per compilar aquest programa?
Una cosa així com Clang.
I què si la persona que li va passar a escriure Clang especial revestit en Clang
una mena, si estic recopilant la programa d'inici de sessió, introduïu el codi
en el programa d'inici de sessió que diu, si x és igual a és igual a David és impressionant?
Així que no és del tot encara, però tenim el mateix emetre aquí, on Clang, bé,
milers, si no desenes de milers de persones, han mirat Clang, tenen
mirat a les seves línies de codi, i va dir: bé, no passa res aquí.
Òbviament, ningú està fent una cosa tan malèvol.
>> Però, què es Clang si mateix, com, I si va compilar Clang?
Què passa si tinc algun compilador que compila Clang que s'insereix en Clang
aquest truc especial que diu, està bé, quan va compilar Clang, llavors el
executable es produeix especialment he mirar dins del programa d'usuari i la inserció
aquest senyal, és igual als iguals Dave és impressionant?
Així que recordi que el seu propi compilador necessita ser compilat en algun moment.
Així que si el que vostè triï per compilar Clang amb, sí que és nociu, llavors vostè
podria ser cargolat el conjunt camí per la línia.
>> Així que aquí tenim a Ken Thompson i Dennis Ritchie.
Així que aquesta és una foto icònica.
Dennis Ritchie està a la dreta.
Ell és un dels principals -
pràcticament va escriure C. Així que vostè pot donar-li les gràcies per aquesta classe.
Ken Thomson està a l'esquerra.
Els dos d'ells, bàsicament, va escriure UNIX.
Bé, eren els principals contribuents en UNIX.
Hi va haver alguns altres.
Així que Ken Thompson, en algun moment, guanya el Premi Turing.
I el premi Turing, sempre he escoltat es fa referència d'aquesta manera, és el
Premi Nobel de la informàtica.
>> Així que en el Premi Turing, que ha de donar el seu discurs d'acceptació.
I se li dóna a aquest molt famós discurs Ara, anomenat Reflexions sobre Confiant
Trust, que hem vinculat a al lloc web del curs.
I en aquest discurs, es diu, està bé, així que vaig escriure UNIX, i ara tots
que la gent està utilitzant UNIX.
Ara, recorda avui que Linux és un descendent directe de UNIX.
OS X utilitza directament UNIX.
Windows no fa molt, però molt d'idees van ser preses de UNIX.
>> Així que puja a l'escenari i diu, bé, vaig escriure UNIX.
I perquè el que vostès saben, jo sóc podrà iniciar sessió en cada
i cadascun dels equips.
Des que em vaig posar una d'elles especialment si x és igual a és igual a Ken Thomson és impressionant,
llavors jo estic autoritzat per iniciar sessió.
Així que les persones són com, bé, Com vas fer això?
Ens fixem en el programa d'inici de sessió i res està allà.
És com, bé, he modificat el compilador per ingressar en el programa d'inici de sessió
perquè el programa d'inici de sessió tindrà ara que x és igual a és igual a Ken Thompson
és impressionant.
>> I diuen, bé, això no és cert.
Estem pensant en el compilador i el compilador no té línies de
codi d'aquesta manera.
És com, OK, però quins són vostè compilar el compilador?
I pensen, i ell és, com, bé, Jo sóc el que et va donar el compilador
utilitzeu per compilar el compilador, per està compilant un compilador, que
sí que és maliciós, i la voluntat trencar el programa d'inici de sessió.
Així que, bàsicament, en aquell moment, no hi ha de cap manera es pot mirar la font
codi del programa d'inici de sessió per veure el que està malament.
Ni tan sols es podia mirar la codi font del compilador
per veure el que està malament.
>> Vostè hauria de mirar la màquina codi, el binari real de la
compilador compilat per veure, espera, aquests línies de codi no haurien d'estar aquí.
Però Ken Thompson va portar un pas més enllà i va dir, bé, hi ha
aquests programes especials que en realitat ajudarà a llegir el binari dels programes,
i pel que si algú utilitza aquest programa per llegir el binari, veurien aquests
línies de codi.
Va modificar els programes de dir, tot Està bé, si vostè està buscant en la
compilador, no mostren aquest particular, conjunt de binari.
>> Així llavors vostè necessita per prendre aquest pas més enllà i que, bàsicament, que podria tenir
múltiples nivells d'indirecció preses, i en algun moment, ningú en realitat
serà la comprovació.
Així que la moralitat de la història és, ets No vaig a estar escrivint
Clang en aquesta classe.
Vostè va a estar usant l'escalada Clang molt en aquesta classe.
Per a tots vostès saben, Clang és un maliciós programa que està sabotejant cada
sol programa alguna vegada has compilat.
I per sortir d'aquest mateix sinistre nota, ens veiem dimecres.
>> [Aplaudiments]
>> ALTAVEU 2: En la següent CS50.
>> ALTAVEU 3: No t'atreveixis a dir això.
Vostè pot fer això.
Vostè ha fet això abans, vostè pot fer això avui en dia, vostè pot fer això demà.
Has estat fent això durant anys.
Només has d'anar-hi i fer-ho.
Vostè pot fer això.
>> [REPRODUCCIÓ DE MÚSICA]