[Powered by Google Translate] [Setmana 2, continuació]
[David J. Malan, Harvard University]
[Aquesta és CS50. - CS50.TV]
Està bé. Això és CS50, i aquest és el cap de setmana 2.
Si vostè espera a tenir gana voltant d'aquesta hora matí,
Sabem que celebrarem com un petit grup de matí, dijous, 1:15 pm.
Hi ha un URL aquí si voleu confirmar la seva assistència.
L'espai és limitat, així que si us plau, perdoneu si el formulari s'omple en el moment d'omplir això.
Una altra URL, però, que podria ser d'interès és la següent.
En gairebé un mes, el curs es posarà a disposició
tant més àmpliament a través de EDX, a través del qual la gent a l'Internet serà capaç de seguir endavant,
participar en el curs molt activament, de fet.
Es va a utilitzar l'aparell CS50 CS50 i Comenta
i la majoria de les eines de programari diferents que ja han estat usant aquest semestre.
I una de les iniciatives que ens agradaria prendre com un experiment d'aquest any
és veure fins a quin punt podem traduir el contingut
a altres llengües parlades i escrites.
Així que si vostè podria tenir interès a participar en aquest projecte
pel que oferirem transcripcions en anglès i subtítols per a les conferències del curs
i els pantalons curts i seminaris i seccions i similars,
si vostè parla amb fluïdesa i escriure amb fluïdesa un altre idioma,
ens encantaria participar en aquest projecte mitjançant el qual es pren en un o més dels vídeos,
traduir a un llenguatge que conec bastant bé.
>> Perquè us feu una idea de la interfície, hi ha una interfície d'usuari basada en web
que utilitzarem, que crearà essencialment una interfície d'usuari d'aquesta manera.
Això m'estava ensenyant alguns Halloween fa,
i en la part dreta hi ha en negre al costat d'aquestes marques de temps,
podràs veure les diverses coses que van sortir de la meva boca aquest dia,
i després per sota de la mateixa serà capaç de traduir a un altre idioma
exactament el que la cartografia és el mitjà, en aquest cas, Anglès i, per exemple, l'espanyol.
Així que en realitat és un molt fàcil d'utilitzar eina.
Pot rebobinar i avançar ràpidament molt fàcilment amb el teclat.
Així que si vol participar en aquest experiment i que les seves paraules vist i llegit
per milers de potencials persones per aquí, si us plau, no dubti a participar.
Una paraula sobre el gatet de dilluns.
Perquè no ens han enviat un missatge massa por, s'adonen que, com indiquen les hores d'oficina
i com suggereixen les seccions, el disseny del recorregut és molt
perquè els estudiants col · laborant i parlant de treballar a través dels butlletins de problemes
i els problemes junts, i realment la línia només es redueix a,
una vegada més, el treball que en última instància ha de ser presentar el seu propi.
I així, amb tota sinceritat, en horari d'oficina és totalment normal,
està totalment d'esperar, fins i tot, a estar xatejant amb algun amic al teu costat.
>> Si ell o ella està lluitant amb alguns temes i vostè és com,
"Oh, bé, et vaig a donar una idea d'alguna línia de codi que vaig escriure," això està bé,
que passa, i això és molt favorable, crec que, amb el procés d'aprenentatge.
Quan la línia es creua quan el cap és una espècie d'inclinació cap aquí durant uns segons massa
o minuts perquè realment haver estat només una oportunitat de desbloqueig per al seu amic,
i, certament, quan les coses s'intercanvien a través de correu electrònic i Dropbox i similars,
allà també és la línia.
Així que per tots els mitjans se sentin còmodes i se senten animats a xerrar amb els amics
i companys sobre conjunts de processadors i més i només s'adonen que el que en última instància, presentar
realment ha de ser el producte de la seva creació i no una altra persona.
I així un dels problemes específics de domini per pset2,
que sortirà demà a la nit tarda, és submergir-se en el món de la criptografia,
que és l'art de xifrar o codificar la informació,
i això en última instància es relaciona amb el món de la seguretat.
Ara, la seguretat per a la majoria de nosaltres es presenta en forma de mecanismes bastant mundanes.
Tots nosaltres tenim noms d'usuari i contrasenyes,
i tots tenim noms d'usuari i contrasenyes molt dolents, molt probablement.
>> Si la contrasenya és la mateixa en diversos llocs web, que probablement no és la millor idea,
com veurem cap al final del semestre.
Si la contrasenya s'escriu en una nota adhesiva - no és broma - al monitor,
que tampoc és necessàriament el millor disseny, sinó un fenomen bastant comú.
I si vostè no està utilitzant la criptografia per xifrar les contrasenyes,
són particularment vulnerables.
Així que si vostè pensa que està sent súper intel · ligent per tenir un document de Word ocult
en algun lloc del seu disc dur que té totes les seves contrasenyes
però està en una carpeta que ningú mirarà, això també no és un mecanisme molt segur.
I així ho pset2 presentaré és aquest art de la criptografia
informació i lluitant perquè coses com contrasenyes són tant més segur.
El context aquí és que amb les dades insegurs
arriba una oportunitat per xifrar i per enfilar.
I pel que aquest, per exemple, és un exemple d'un missatge xifrat.
En realitat, això diu alguna cosa en anglès, però és evident que no és totalment obvi.
I anem a arribar al punt de partida avui a esmicolar el que aquest missatge secret aquí és.
Però en el món real de les computadores, les coses no semblen que fins i tot podrien ser frases en anglès.
Per exemple, això és el que pots trobar en un estàndard de Linux o Mac o UNIX
en un arxiu que va ser en un altre temps anomenat l'arxiu de contrasenyes.
>> Avui dia s'han traslladat a altres llocs.
Però si ens fixem en el lloc correcte en un sistema, podràs veure no només el seu nom d'usuari
o la d'altres persones en el sistema, però vostè veurà una versió encriptada de la seva contrasenya.
En efecte, la cripta hi ha paraula suggereix que les coses es xifra,
i aquesta sèrie de lletres aparentment a l'atzar i caràcters i nombres, i així successivament
només es pot desxifrar en general per conèixer algun secret -
una paraula secreta, un número secret -
I de fet, l'art de la criptografia en última instància es redueix a confiar d'algun tipus
i saber alguna cosa que ningú més ho fa.
Així que anem a explorar en detall una mica més avui i en el conjunt de processadors per venir.
I ara una paraula sobrepassa / falla.
Sobretot perquè alguns de vosaltres heu bussejat en pset1, l'aparell,
i un món molt nou per a vostè, s'adonen que les frustracions i confusions
i només dificultats tècniques són bastant d'esperar,
especialment amb el conjunt de processadors en primer lloc, on hi ha tantes coses noves,
només a familiaritzar-se amb ls i cd i tots aquests comandaments arcans
i un nou ambient, i això és independent del material real i la programació en si.
Així compte també que hi ha certament hores d'oficina que hi ha com una estructura de suport.
>> Seccions començarà diumenge que ve.
Però el més important, si et sents sol que aquest no és el món per a tu,
adonar-se que en realitat es limita a prendre temps.
I si no fos per aquesta oportunitat fa anys per a mi de prendre una classe de pas / falla,
Honestament, mai m'hauria posat un peu a l'aula.
I vostè pot canviar això per amunt fins, diguem, el cinquè dilluns del curs,
així que si vostè està a la vora ara, adonar-se que en lloc de cap a algunes altres aigües del tot,
Quin dubte considerar simplement canviar per passar / fallar.
Un cop més, no hi ha realment aquesta cultura aquí a Harvard de prendre les coses d'passa / falla
ja que tothom vol aconseguir o superar,
però, francament, això és una meravellosa manera de provar alguna cosa
que pot no ser familiar per a vostè, i vostè va a acabar fent, en la majoria dels casos, bastant bé,
potser molt a la seva sorpresa.
I en termes més concrets, el que crec que passa / no passa generalment ho fa,
especialment en el que podria haver experimentat amb pset0,
si es posa en 10 hores, 15 hores, 25 hores en algun conjunt de processadors
i estàs colpejant el seu cap contra la paret i s'està posant súper altes hores de la nit
però que ha pres el conjunt de processadors 90% del camí i simplement no puc entendre una cosa,
passa / no passa realment pren la vora d'una classe com aquesta,
on es pot ordenar feliçment de dir: "Bé, jo sé que no és perfecte,
però vaig treballar el cul en això, estic bastant content amb el lloc on va acabar "
i que compleixi amb les expectatives de passa / no passa.
Així que tingues-ho en compte. Està bé.
>> Així que aquells de vostès que han tingut dificultats per utilitzar la Universitat de Harvard Wi-Fi,
Sabem que hi ha un SSID CS50, una connexió Wi-Fi, surant
que podria tenir millor sort per.
És una mica irònic que la contrasenya per això, si vol provar la connexió a aquest
per obtenir millors velocitats - i faci'ns saber si no és millor - és 12345, tot el camí fins al 8
8 perquè és més segur que 5.
Així que si vostè necessita la contrasenya de Wi-Fi, Wi-CS50 aquí, 12345678,
i incloure en CS50 Parli si vostè encara té problemes de connectivitat intermitent,
i deixarem que els poders que es coneixen per aquest espai. Està bé.
Així que un reclam ràpid, especialment per a aquells de vostès que són nois o noies fans de totes les coses d'Apple.
El que desenterrat de fa uns anys era aquest arxiu aquí, iUnlock.c,
només per a tipus de concret més i més complexos
alguns dels programes en C més bàsiques que hem estat escrivint.
Així que vaig obrir aquest arxiu, iUnlock.c. Està disponible a la pàgina de Lectures per avui.
Al costat esquerre es veu una llarga llista de funcions.
Així que el tipus que va escriure això va escriure una gran quantitat de funcions, més que principal.
Ell va utilitzar una gran quantitat de biblioteques aquí, i, si comencem a desplaçar-se a través de
el que això és, és la primera, crec, crac per l'iPhone original.
>> Quan es volia fer jailbreak a l'iPhone original, el que significa que desnuar d'AT & T
i en realitat instal · lar programari especial en ell i fer coses que Apple no volia que la gent ho fa,
algú es va prendre el temps per esbrinar exactament com podrien explotar fallades de programari,
errors, errors en el programari d'Apple, i així va néixer iUnlock.c--
que si es compila en l'equip i el va instal · lar en un iPhone
que estava connectat al seu ordinador a través de, per exemple, un cable USB,
això li donaria privilegis d'administrador o root al teu iPhone
i li permeten fer gairebé tot el que vulguis.
I així ha estat aquest fascinant gat i la rata
entre Apple i la resta del món, en particular pel que, igual que moltes empreses,
tractar de bloquejar les seves coses avall de manera que només es pot fer amb ella el que tenia planejat.
Però gràcies a gent com aquesta i la comprensió de detalls de baix nivell -
i en aquest cas la programació C - i moltes de les construccions conegudes
que hem començat a jugar, vostè pot realment aprofitar el maquinari
d'una manera millor li sembli i no necessàriament una entitat corporativa.
Així, per exemple, no tinc ni idea del que tot això està fent,
GetVersion però sona bastant senzill,
i sembla que aquesta és una funció que aquesta persona va escriure.
Es necessita algun tipus de nombre enter com a argument, no torna res,
però sembla bucle amb un bucle aquí i si una condició, si la interrupció condició,
i d'alguna manera es relaciona amb els números de versió si es desplaça cap avall,
tot i que moltes d'aquestes paraules clau seran nous.
I hi ha un munt de funcions a aquí mai hem vist i que no vegi mai
en el transcurs del semestre.
>> Al final del dia, segueix les mateixes regles i la lògica que hem estat jugant amb fins ara.
Així que això és massa vell per trencar les seves 3s iPhone o dies aquests 4s 5s o aviat,
però sàpiguen que tot està molt deriva d'aquest món que hem bussejat a.
Fem una ullada a un petit exemple més simple:
aquest, només per escalfar amb una mica de sintaxi i també un altre tipus de dades
que ja hem parlat, però no han vist realment en C.
Es tracta d'un arxiu anomenat positive1.c, i, pels comentaris a la part superior
això només requereix que l'usuari proporcioni un nombre positiu.
Així que és un exemple d'un bucle do-while, que és agradable per als programes d'usuari interactives
on ha de dir-li a l'usuari que faci alguna cosa,
i si ells no cooperen els crides o rebutjar la seva entrada.
Un exemple: jo faré línies 19 a la 24
sempre i quan l'usuari no se m'ha donat un nombre positiu.
Aquest detall aquí a la línia 18, per què jo declare n per sobre d'aquest bucle sencer construir
en contraposició a la dreta al costat de la línia 22 en què realment importa per obtenir n? Si.
[Estudiant] Scope. >> Si, pel que aquest problema d'abast.
I, en termes senzills, quin abast es refereix?
Si. >> [Resposta dels estudiants inaudible] >> Pots parlar una mica més alt?
[Estudiant] On es pot accedir a aquesta variable. >> Perfect.
On es pot accedir a una variable en particular.
I, en general, la regla general fins ara ha estat que l'abast d'una variable
es defineix per les claus més recents que he vist.
>> I així, en aquest cas, si he comès l'error de declarar n en la línia 22, la línia havia de funcionar.
M'agradaria aconseguir un int, de manera que el posa en aquesta variable n en la línia 22,
però quina línia de codi ara no tindria ni idea del que estic parlant? >> [Estudiant] 25.
[Malan] 25, i resulta que 24 així perquè en aquest cas cau fora de les claus.
Així que una mica d'una molèstia, però molt fàcil de resoldre amb només declarar la variable
fora de la pròpia funció.
Ja veurem el dia d'avui es pot anar un pas més enllà
i que fins i tot pot resultar una mica mandrós.
I que no es recomana en general, sinó que fins i tot podria tornar mandrós
i posar una variable a nivell mundial, per així dir, no dins d'una funció, no dins d'un bucle,
sinó en el propi arxiu, fora de totes les funcions que vostè ha escrit, com ho vaig fer aquí a la línia 15.
Això és generalment mal vist, però s'adonen que és una solució de vegades a altres problemes,
ja que amb el temps veurem.
Així que per ara anem a deixar-ho així, però anem a veure si podem reescriure aquesta
només per començar a expressar-nos de manera diferent.
Aquest programa, només perquè quedi clar, és positive1.
Deixa anar per davant aquí i al meu finestra de terminal fer positive1, Enter.
Compila bé. Vaig a córrer positive1, premeu Enter.
Exigeixo que em donis un enter positiu. Diré -1. Això no va funcionar.
0, 99. Això sembla que funciona.
Potser no és la prova més rigorosa, però almenys és una comprovació de validesa agradable
que estem en el camí correcte.
>> Així que ara seguirem endavant i obrir la versió 2 d'aquesta,
i el que és diferent ja?
Posa en pràctica la mateixa cosa, però el que està saltant com clarament diferent aquesta vegada?
Aquesta bool en verd. Es destaca en verd, aquesta paraula clau es coneix com bool, que és un tipus de dades.
No ve integrat en totes les versions de C.
Has d'incloure una biblioteca específica.
En el nostre cas, vaig incloure la biblioteca CS50 perquè tinguem accés a bool.
No obstant això, en la línia 18, sembla que tenim un valor booleà anomenat aquí agraïts.
Podria haver cridat a aquesta res, però em va cridar agraït
només per transmetre algun tipus de significat semàntic.
Així que al principi de la línia 18, estic agraït pel que sembla no
perquè el valor agraït Boolean s'inicialitza a false a la línia 18.
I llavors sembla que el que he fet aquí, a les línies 21-23
s'ha acabat tipus de reescriure la meva lògica.
Així que no funcionalment diferents, però en la línia 22 ara comprovo si el int l'usuari ha proporcionat
és més gran que 0, llavors simplement canviar el valor d'agrair a true.
I per què ho faig? Com que en la línia 25, pel que sembla vaig a comprovar una condició.
És aquest bucle while agraït és fals.
Així que em va proposar això com una alternativa a la versió 1
perquè és almenys una mica més intuïtiu potser, és una mica més de terra en Anglès.
Així que faci el següent mentre no estàs agraït o agraïda mentre que és fals.
I aquesta vegada jo també, aparentment, no m'importa recordar el que l'usuari va escriure en
perquè no hi ha cap avís de n variable, el que en realitat, una petita mentida piadosa allà.
>> Funcionalment, el programa és una mica diferent una vegada que arribem al fons de la qüestió
perquè no vaig a recordar el que n és.
Però jo volia demostrar que també en aquest cas tot i que hem vist getInt
i GetString s'utilitza en el costat dret d'un signe igual fins ara
perquè recordem el valor, tècnicament, no és estrictament necessari.
Si per qualsevol raó vostè no els importa per guardar el valor,
el que desitja és comprovar el valor, observi que simplement podem escriure això com getInt,
obert parin, parin prop.
Aquesta funció tornarà un valor, com ho hem estat dient.
Se't va a tornar un int.
I així, si mentalment pensar que això passi,
quan escric en 99, getInt torna el número 99,
i per tant conceptualment, és com si el meu codi eren en realitat això.
Així que si 99 és en realitat major que 0, llavors es converteix en veritat agraït,
després la línia 25 es dóna compte ooh, hem acabat perquè ara estic agraït,
i en la línia 26, que simplement dir: "Gràcies pel enter positiu!"
el que va resultar ser.
Ara farem el sucre sintàctic lleu aquí, per dir-ho.
A veure si podem netejar aquesta línia 25 amb aquesta variant de la tercera i última en positive3.
>> Tingueu en compte que l'única diferència ara és quina línia de codi? >> [Estudiant] 25. >> [Malan] Sí, 25.
I no hem vist realment aquest truc encara, però ens van fer veure el signe d'exclamació en dilluns,
que denota què? >> [Els estudiants] no. No >> o negació.
Així que pren un valor booleà i voltejar el seu valor.
Cert converteix en fals, fals es fa realitat.
Així que això, proposo, és encara una mica més intuïtiva manera d'escriure el codi
perquè encara agraït inicialitzar en false, el segueixo fent el següent,
Vaig posar agraït a true quan arribi el moment,
però ara vostè pot realment només traduir el codi verbal esquerra a dreta,
mentre que (gracias!), ja que el punt explosió o exclamació denota la noció de no
així que mentre no agraït.
Així que de nou, no hem introduït nous conceptes en si.
Parlem de booleans enrere quan juguem amb Scratch,
però s'adonen ara podem començar a escriure el nostre codi de moltes maneres diferents.
Per tant, i en pset1 si vostè és una espècie de lluita per descobrir la manera d'escriure algun programa,
més probable és que estàs de sort perquè no hi pot haver qualsevol nombre de solucions
que li pot succeir a.
Per exemple, això és només 3 de fins i tot el més simple dels programes. Està bé.
I ara recordo el dilluns ens vam anar en aquesta nota amb valors de retorn.
Així que per a la primera vegada que escrivim un programa que no només té principal;
també té la seva pròpia funció personalitzada que vaig escriure aquí.
Així, en la línia 31 a la 34 He implementat una funció de cub.
No és complex. És només a * a * a en aquest cas.
Però l'important d'això és que estic prenent d'entrada en forma d'un
i m'estic tornant sortida en forma de * a * a.
Així que ara tinc la capacitat, tant com solia fer-ho amb prinf sol,
anomenar aquesta funció cridant a la funció de cub.
>> I la funció de cub té alguna informació, i la funció retorna un cub de sortida.
Per contra, printf acabo de fer alguna cosa.
No va tornar tot el que ens importava, tot i que en un a part que retorna cap valor;
que acaba generalment ho ignoren.
Printf acabo de fer alguna cosa. Tenia un efecte secundari de la impressió a la pantalla.
En canvi aquí, tenim la funció de cub, que en realitat torna alguna cosa.
Així que per a aquells que estan familiaritzats amb això, és una idea bastant senzilla.
Però per a aquells menys familiaritzats amb la idea de passar a les entrades i sortides de tornar,
tractarem només una cosa simple super.
Hi ha algú que ve còmode a l'escenari breument?
Vostè ha d'estar còmode amb una càmera a vostè també. Sí? Bé.
¿Et dius? >> [Estudiant] Ken. >> Ken. Està bé. Ken, anem a dalt.
Ken serà una funció del tipus aquí.
Seguirem endavant i fer això. Anem una mica sofisticat.
Gust a conèixer-lo. Benvingut al centre de l'escenari. Està bé.
Anem a colpejar el botó aquí. Està bé.
Així que aquí tens una pissarra moderna,
i el que jo sóc és la funció principal, per exemple,
i no tinc un iPad a la mà.
>> Jo no me'n recordo com - Bé, no puc dir que.
Jo realment no tinc bona lletra,
i per tant, vull d'imprimir alguna cosa a la pantalla per a mi.
Estic sent el programa principal, i jo hauré de dir això
escrivint en el meu gargots i després passar que una entrada.
Tan ximple encara que aquest exercici és, la noció de funcions i cridar a una funció
i retorna una funció realment es redueix a això.
Estic principal, que acabo d'escriure printf, entre cometes alguna cosa a la pantalla,
Estic executant aquest programa, i tan bon punt es diu printf,
Pren un argument o un paràmetre de vegades entre cometes dobles.
Aquí està l'argument. Ho estic passant a Ken.
Ell és un quadre negre escrit un nombre d'anys
que pel que sembla només sap imprimir coses a la pantalla.
Així que executar.
Això no és dolent. Molt bo.
Així que ara es porta a terme l'execució de Ken. Ha de donar-me res a canvi?
No és que hem vist fins ara.
Un cop més, és en realitat printf torna un nombre, però anem a ignorar que per ara
perquè mai he utilitzat. Així que això és tot per Ken.
I ara principal pren el control de nou el programa
perquè aquesta línia de codi, printf, es porta a terme l'execució.
I ens ocupem del nostre camí, l'execució de qualsevol altres línies hi són.
Així que ara anem a provar un exemple una mica diferent.
Aquesta vegada aquí primer anem a esborrar la pantalla, i aquesta vegada anem a fer la funció de mesurament de volum,
però aquesta vegada, espero que un valor de sortida.
>> Així que seguirem endavant i fer-ho.
Ara tinc una línia de codi que diu que x es cúbica de x.
La línia de codi, el record, es veu així: x = cub (x);
Llavors, com es va a treballar? Seguirem endavant i donar-li una pantalla en blanc de nou.
Vaig a escriure ara el valor de x,
que en aquest moment passa a ser, diguem, 2 per mantenir les coses simples.
He escrit en un tros de paper el valor de 2, la qual cosa és el meu valor x.
L'hi dono a Ken. >> I acabo d'escriure la resposta? >> Sí, anem a escriure la resposta.
Bé. I ara m'ha de retornar alguna cosa. Perfecte. Niça segue.
Així que ara em passa de nou el valor de 8 en aquest cas, i què he de fer amb ell?
En realitat - veurem, obtenir aquest dret. Què faré amb ell?
Ara em vaig a prendre aquest valor i emmagatzemar-lo en realitat en aquests mateixos bits en la memòria.
Però noti que sóc una mena de lluita aquí.
Estic una mica confós perquè on puc realment escriure el valor de x,
perquè el que acabes de fer és físicament Ken mà un tros de paper que tenia el valor 2,
que era x, i, de fet, això és precisament el que va succeir.
Així que resulta que quan es crida a la funció i se li passa un argument
com hola, món, ni se li passa un argument com el 2,
en general, està passant una còpia d'aquest argument.
I així com jo vaig anotar el número 2 aquí i l'hi va donar a Ken,
això vol dir que encara tinc una còpia del valor 2 en algun lloc
perquè de fet, ara que ho he aconseguit tornar el valor 8, he de tornar a la memòria RAM
i en realitat anotar 8, on una vegada vaig tenir el número 2.
Així visualment, recorda aquesta idea de passar a, literalment, una còpia del valor.
>> Ken fa les seves coses, em fa una mica de volta - en aquest cas un valor com 8 -
i després he de fer alguna cosa amb aquest valor si vull mantenir aquí.
Així que tot això tornarà a ser massa familiar en poc temps.
Moltes gràcies per aquesta demostració aquí, Ken. [Aplaudiment]
Molt ben fet.
Anem a veure com això es relaciona en última instància, a part de la funció de trucada que hem estat fent aquí.
Deixa anar per davant i ens porti de nou a l'exemple cubicació aquí.
Tingueu en compte que si volem realment començar a prendre aquest més futur,
haurem de tenir en compte el fet que el nombre x que està sent passat per aquí
és diferent del que realment està passant en la funció.
Així que de nou, aquest pas per còpia serà molt afí en un moment.
Anem a fer una ullada a alguna cosa que no acaba de funcionar bé encara.
Vaig a seguir endavant i obrir un exemple calessa tercera, que està viciat per la naturalesa,
i es diu buggy3 i implementa una funció d'intercanvi.
Aquí tenim una funció principal que ha x i i arbitràriament inicialitza a 1 i 2, respectivament.
Podríem utilitzar getInt, però només necessitem un exercici simple,
pel que és codificada com 1 i 2.
En les línies 21 i 22, que pel que sembla imprimir x i i, una per línia.
A continuació, a la línia 23, sostinc que estic canviant aquests valors, punt, punt, punt.
Em aparentment cridar a una funció en la línia 24 d'intercanvi trucada que dura 2 arguments.
Està totalment de fiar per les funcions que prendre 2 arguments. Hem vist printf fer-ho ja.
>> Així intercanvi aparentment presa x i i, i com suggereix el seu nom,
Espero que això canviarà aquests 2 valors.
Així que em diuen en la línia 25 "canviar!" i reimprimir x i i
sota el supòsit que han estat efectivament intercanviats.
Però si realment executar aquest programa - que em obri una finestra de terminal,
vull deixar buggy3 - com el seu nom ho indica, això no acabarà bé
perquè quan premeu la tecla Enter, cal notar que x és 1, i és 2,
i no obstant això, al final del programa, encara són, de fet, el mateix.
Així que basat en la demostració acaba amb Ken, el que realment està passant?
Entrem en aquesta funció swap. És súper curt. No és més que unes poques línies de codi de temps.
Però quin és el problema fonamental que s'ha de basar en la simple història diu aquí amb Ken?
Per què el canvi d'trenca?
[Estudiant] Vostè està emmagatzemant una còpia, no la variable.
Exactament. Estem a guardar una còpia, no la variable en si.
En altres paraules, d'intercanvi aparentment té 2 arguments, un int,
i és anomenat arbitràriament a i b,
i aquí he passat a x i i, que són, respectivament, 1 i 2,
però no estic literalment passant x, no estic literalment passant i,
Estic passant una còpia de x i una còpia de i.
És gairebé com si copiar i enganxar en canvi
els valors que desitja per manipular realment.
Així que si aquest és el cas, quan l'inici del programa l'execució de la línia 35 després de 36 anys,
quan arribi a la línia 37, en aquest moment de la història, quin és el valor de a?
En aquest punt de la història, línia 37, quin és el valor d'una en aquest moment? >> [Estudiant] 1.
[Malan] Simplement ha de ser 1, a la dreta, ja que x es passa com a primer argument,
i aquesta funció només arbitràriament està trucant al seu primer argument.
De la mateixa manera és I el segon argument, i és simplement trucar a la b arbitràriament segon argument.
>> Aquesta dicotomia és en realitat bastant simple explicació. Pensa en això.
Cap de nosaltres ha conegut la persona que va escriure printf,
pel que segurament, ell o ella no té idea del que les nostres variables de 30 anys més tard s'havia d'anomenar.
Així que ha d'haver una distinció entre el que diuen les variables en les funcions que escrius
i el que vostès anomenen les variables en les funcions que està trucant o utilitzant.
En altres paraules, he escrit els meus variables com x i i,
però si algú havia escrit la funció d'intercanvi, ell o ella segurament no sabria
el que els meus variables es dirà,
així adonar-se que això és per què té aquesta dualitat de noms.
Tècnicament, jo podria fer això per casualitat,
però tot i així es passa com còpies.
Només seria una pura coincidència estèticament si aquesta persona que va escriure intercanvi
havia utilitzat els mateixos noms.
Així que en aquest punt de la història, línia 37, a és 1, b és 2, i ara em dedico a intercanviar-les.
En primer lloc, voldria realment fer això molt més simple.
No sé quines són aquestes 3 línies de codi feien.
Permetin-me fer això: b = a, a = b; fet.
Per què aquesta trencat, lògicament?
És una cosa de la intuïtiu, oi?
Així una i B es converteix en b es converteix en una,
però el problema és que tan aviat com s'executa la línia 37, quin és el valor de a i b?
El mateix, 1, perquè ha pallissa, per dir-ho, has canviat b sigui igual a.
Així que un cop que s'ha executat la línia 37, que està molt bé, ara tens 2 còpies de la número 1
dins d'aquesta funció, de manera que a continuació, quan vostè diu en la línia 38 a = b,
ets una mica fotut perquè estàs assignant 1 a 1.
Vostè ha perdut el tipus de valor que li importava.
Així que en la versió original d'aquest, observi el que vaig fer.
Jo en canvi va tenir una tercera línia de codi que es veia així.
Jo declaro una variable temporal.
>> Tmp és un nom molt comú per a una variable temporal, i és un int
perquè ha de coincidir amb el que jo vull fer una còpia de.
Puc guardar una còpia de dins de tmp, així que una vegada que la línia 37 s'ha executat,
el valor de a és - comprovació de validesa ràpida - 1, el valor de b és 2,
i el valor de tmp és també 1.
Així que ara executar la línia 38.
Quan la línia 38 s'executa, una presa el valor de b. I b va ser de 2, de manera que ara és un 2.
Així que en aquest punt de la història, a és 2, b és 2, i tmp és 1,
de manera que ara, lògicament, podem valorar només tmp plop a la b i ja està.
Per això hem resolt aquest problema.
Malauradament, quan executo aquest programa en aquesta forma, en realitat no canviar cap valor.
Però perquè quedi clar, per què?
He arreglat el problema lògic de fa un moment,
però de nou, si executa aquest programa, x i i no canvien
pel final de l'execució del programa.
[Comentari estudiant inaudible] >> No hem tornat res, així que això és cert.
Però resulta que hi ha un petit problema aquí, perquè fins ara,
l'únic que he estat capaç de tornar és una cosa, i aquesta és una restricció de la C.
Només pot tornar realment un valor, en aquest cas estic una mica encallat aquí
perquè vaig poder retornar el nou valor de x o podia tornar el nou valor de i,
però vull que els dos de tornada.
Així que torna no és la solució simple aquí.
Però el problema fonamental és per què? Què hem canviat en realitat?
[Estudiant] a i b. >> A i b.
Però a i b són còpies de x i i, pel que acabem de fer tot aquest treball,
Acabem de passar 3 minuts parlant sobre la funció d'intercanvi i els 3 d'aquestes variables,
i això és genial, perfectament correcte en l'aïllament,
però a i b de l'abast només és en aquestes línies aquí.
>> Així com un bucle, si es declara un enter i dins del bucle for,
De la mateixa manera, si vostè està declarant dins de a i b de la funció que vostè ha escrit,
només són vàlids dins d'aquesta funció, el que significa que tan aviat com intercanvi es realitza executant
i anem a partir de la línia 24 a la línia 25, x i i no han canviat en absolut.
Vostè acaba de perdre un munt de temps que es triga còpies de variables.
Així resulta que la solució a això és en realitat no evident.
No és més que suficient per retornar valors perquè només podem retornar un valor,
i realment vull canviar tant x com i, a la vegada,
així que haurem de tornar a això.
Però per ara, adonar-se que el problema fonamental deriva del fet que a i b són còpies
i estan en el seu propi àmbit.
Tractarem de resoldre això d'alguna manera.
Permetin-me retrocedir en realitat aquí i obren, diguem, una quarta variant d'això, buggy4.
Què passa amb això?
Aquest és un problema similar però més senzill que mirar abans de prendre una punyalada en la seva solució.
Aquest programa es diu increment, i pel que sembla s'inicialitza un enter x a 1 a la línia 18.
Llavors em diuen x és 1, llavors em diuen "Incrementar ..."
Llavors truqui increment, però després en les línies 22 i 23, que diuen que ha estat incrementat,
Jo reclam x ara és el que és - 2, probablement - però aquest programa està lliure d'errors.
Quin és el problema?
Si. >> [Resposta dels estudiants inaudible] >> Exactament.
Així que x ha estat declarada, per descomptat, en la línia 18.
És dins de claus principal.
Així que la resposta simple és que mentre que x existeix aquí,
que no existeix en la línia 32, de manera que aquest programa realment ni tan sols es compilarà.
El compilador quan intento compilar aquest codi va a cridar
sobre algun identificador no declarat o alguna cosa per l'estil. De fet, ho intentarem.
Es tracta de fer buggy4. Aquí està.
L'ús de 'x' identificador no declarat en la línia 32.
I, de fet, serem més explícit aquí avui perquè això sigui útil
en hores d'oficina ia casa.
>> Tingueu en compte que és una mica críptic escrit.
Però el fet que té Clang ens cridava, dient buggy4.c: 32:5, és realment útil.
Això significa que l'error està en la línia 32 a la posició de caràcter 5.
Així 1, 2, 3, 4, 5. Això és, en efecte, on el problema és.
I també, també, tenir en compte en les hores d'oficina ia casa, tinc sort aquí.
Tinc un error. Serà relativament fàcil de solucionar.
Però si tens una pàgina amb la missatges d'error aclaparadores,
de nou adonar-se que el situat més avall podria ser un símptoma de la més alta.
Així que sempre persegueix als seus errors, de dalt a baix
perquè no només podria ser un efecte en cadena
que suggereix que té problemes molt més del que realment fan.
Llavors, com podem solucionar aquest problema si el meu objectiu és incrementar x? >> [Estudiant] x Faci global.
Bé, pel que podem fer x global.
Anem a tirar pel dret que em va advertir sobre abans, però dimonis, només necessitem una solució ràpida,
així que anem a dir int x aquí. Això fa que x global.
Així que ara principal té accés a la mateixa i l'increment té accés,
i així que permetin-me anar endavant i compilar aquest moment.
Fer buggy4, Enter. Sembla compilar ara.
Anem a córrer buggy4. I sembla que funciona realment.
Aquesta és una d'aquelles coses que es fan com jo dic, no el que faig,
com acabo de fer aquí, ja que en general,
nostres programes es posaran molt més interessant i molt més que això,
i si la solució a problemes de la vida s'acaba de posar totes les variables a la part superior del seu arxiu,
molt ràpidament quins programes es horriblement difícil de manejar.
Es fa més difícil d'idear nous noms de variables,
es fa més difícil entendre què variable està fent què,
i així, en general, això no és una bona solució.
Així que farem això millor.
No volem utilitzar una variable global aquí.
>> Jo vull incrementar x, així que òbviament podria -
al final del dia, això és una mica d'una història ximple perquè simplement fer això -
però si jo no sabia res d'aquest operador o que no se li va permetre canviar principal en si,
Com podria jo posar en pràctica Ken aquí aquesta vegada no per incrementar cub però a?
Com puc canviar això d'aquí? Si.
[Estudiant] Pass a x i tornar després [inaudible] >> Bé, bé.
Per què no puc passar en x i llavors en comptes de tornar-lo,
Per què no m'ho torni x + 1.
Un parell de coses que han de canviar aquí. Estic en el camí correcte.
Què més necessita per modificar? Algú més. Si.
[Resposta dels estudiants inaudible]
He de canviar el tipus de retorn d'increment perquè no s'anul · larà.
Res Void mitjans s'estan tornant, però és evident que ara és,
així que això ha de canviar a - >> [estudiant] int.
int per ser coherent amb el que en realitat estic tornant.
Ara, una altra cosa és encara amb errors aquí. Si.
[Resposta dels estudiants inaudible] >> [Malan] Així que necessito per incrementar x?
[Resposta dels estudiants inaudible] >> [Malan] Ah, així que he de passar x.
Així que he de fer això aquí. >> [Comentari estudiant inaudible]
[Malan] Així que el prototip, he de canviar això aquí.
Així que això ha de ser un int, això ha de ser -
hmm, jo ​​en realitat tenen un error aquí. Anem a arreglar això primer.
Quin ha de ser aquesta realitat? Ha de ser alguna cosa int.
Podria ser x, però, francament, si vostè comença a trucar a tots els de la seva x variables,
que rebrà menys i menys clara quin és quin.
>> Així que anem a triar arbitràriament una nomenclatura diferent per les funcions del meu ajudador;
les funcions que estic escrivint. L'anomenarem a, o podríem anomenar -
Diguem que és el nombre sigui encara més explícit.
Així que he de tornar tot el que el nombre és més 1,
i ara he de canviar una cosa aquí i una altra cosa aquí.
Què he de canviar en la línia 21 en primer lloc? >> [Resposta dels estudiants inaudible]
[Malan] he de assignar a x. No puc cridar increment (x).
Necessito recordar la resposta en canviar el valor de x en el costat esquerre.
I tot i que x es troba ara a l'esquerra i la dreta, que és totalment bé
pel fet que el costat dret s'executa primer i després es va deixar caure en la cosa de l'esquerra -
x en aquest cas.
I finalment, aquesta és una solució fàcil ara.
Això només ha de coincidir amb el que està a baix, el nombre int.
Així que un munt de canvis per a una funció realment estúpid
però representativa de les coses que cada vegada voldrà fer.
Així que buggy4. M'he cagat en algun lloc.
Oh, Déu meu. Cinc errors en un programa de 6 línies.
Llavors, què hi ha de dolent en la línia 18, el caràcter 5?
Així que he de declarar aquest tipus int.
Anem a veure. Hi ha un munt d'altres errors.
Oh, Déu meu - 19, 18, 21 -, però de nou, anem a esborrar la pantalla, L Control d'aquí,
i torneu a executar Clang.
Així que 5 problemes que en realitat és només una.
Així que ara anem a executar buggy4, Enter. Sort, x s'ha incrementat correctament.
Està bé. Qualsevol pregunta sobre la forma d'incrementar els nombres? Si.
[Pregunta estudiant inaudible] >> Bona pregunta.
Com és que només puc canviar x a nombre i el programa sabrà immediatament?
>> Un cop més, pensar-hi com aquesta abstracció.
Així que si jo sóc principal i Ken és l'increment, francament, no m'importa el que Ken crida al seu iPad.
No m'importa el que ell anomena qualsevol cosa que tingui a veure amb la implementació d'aquesta funcionalitat.
Aquest és un detall d'implementació que jo, principal, no han de preocupar.
I així, simplement canviant constantment dins de la funció - i el número de sèrie aquí aquí -
és tot el que pren tant de temps com jo recompilar.
És com si es pensa en molts de nosaltres, aquells que tinguin llicències de conduir
que han impulsat o si fins i tot ha conduït a un cotxe,
la majoria de nosaltres no tenim idea de com funciona un cotxe sota la campana.
I, literalment, si s'obre el capó, la majoria de nosaltres - jo inclòs -
no sabrem realment el que estem veient,
espècie que es pot sentir amb coses com aquesta ara mateix.
Però en realitat no han de tenir cura com el cotxe funciona,
que no han de cuidar el que totes les varetes i pistons i els cables a l'interior del cotxe
en realitat estan fent.
Així que alguna cosa com el que vostès anomenen el pistó no té importància aquí en aquest cas. La mateixa idea.
Si. >> [Pregunta estudiant inaudible]
Si hi ha més usos de la variable xa moment abans,
vostè, el programador, hauria de canviar tot arreu.
O vostè podria literalment fer Arxiu, Menú, i després Cerca, Reemplaçar - una cosa així -
però hauràs de fer aquests canvis pel seu compte.
Cal ser coherent. >> [Estudiant] Si hi ha diverses variables [inaudible]
Una ordre particular, com aquí, si es tractava d'int altre nombre? >> [Estudiant] Correcte.
[Malan] Yeah. Ordre importa quan es crida a la funció.
>> Així que si m'estaven trucant increment aquí amb una mica alguna cosa coma,
hi ha una correlació directa.
La primera variable, com es digui, es fa una còpia del primer argument per aquí.
Em sap greu. Això no hauria de ser un parèntesi.
Les línies del segon argument per dalt amb el segon. Així ordre, sí, importa. Està bé.
Em sap greu. Vaig prendre el camí més llarg per arribar-hi. Altres preguntes? Està bé.
Així que anem a veure si podem pintar un quadre del que realment està passant aquí
sota la campana, per dir-ho.
Aquest és un rectangle que podria representar la memòria del seu ordinador.
Encara que no té idea de com funciona la memòria RAM o com funciona,
almenys se suposa que té raïms d'ell en aquests dies.
Tens megabytes d'ella, tens gigabytes d'aquesta,
i sabem per setmana 0 que un byte és què? >> [Estudiant] 8 bits.
8 bits, no? Així que 8 zeros i 1.
Així que si el seu equip té un giga de RAM, 2 gigues de RAM en aquests dies,
Té un bilió o 2 milions de bytes de memòria o bits de prop de 8 milions de dòlars o 16000000000
dins del seu equip.
A diferència de la petita Wooly Willy exemple, no és típicament partícules magnètiques més.
Cada vegada més - en els ordinadors portàtils almenys - és unitats d'estat sòlid, SSD,
que simplement no tenen parts mòbils. Tot és electrònic. És tota l'electricitat basada en.
Així que pensa d'aquest rectangle com tot just representa l'1 o 2 gigabytes de memòria que té.
>> Així que és un tros de memòria.
El món de la informàtica té una mena de particions de
trossos de memòria per fer coses diferents.
Per exemple, si aquesta és la memòria RAM del seu ordinador, com ho suggereix el rectangle allà,
resulta que, per convenció, a la part superior de la memòria RAM, per dir-ho,
generalment és el que s'anomena un segment de text.
Aquests són el 0 i 1 que hagi recopilat.
Per això, quan hem mirat sota de la caputxa del a.out és,
tots aquests 0s i 1s, quan s'executa un programa,
els 0s i 1s són carregats des del disc dur en alguna cosa que es diu memòria RAM,
i en la RAM es les col · loca en la part superior.
Mentrestant, vostè té altres coses: inicialitzar les dades, desinicializar dades.
Aquestes dues franges de memòria es refereixen a les variables globals, que no s'utilitzen sovint
però de vegades si ho fa, acaben allà també.
Llavors hi ha altres coses: variables d'entorn, que no anem a passar molt temps des d'ara,
però 2 coses importants de tornar al llarg del semestre,
pila i pila.
Així que la majoria de la memòria de l'equip està reservat en executar un programa
per alguna cosa que es diu la pila i una cosa que es diu la pila.
No anem a parlar sobre el munt d'avui, però anem a parlar de la pila.
La pila està destinat a evocar la visual de les safates de menjar al menjador Mather House
o allà on sigui, on el personal de menjador netejar cada dia,
que ells comparen des del terra cap amunt,
i de la mateixa manera, a la memòria, no és la idea de posar alguna cosa en una pila,
posar alguna cosa en una pila, posar alguna cosa en una pila.
I què és el que volem dir amb això?
>> Anem a ampliar en gairebé la meitat inferior de la imatge, la memòria RAM del seu ordinador,
a proposar la següent.
Resulta que quan s'executa un programa com a.out o hello -
qualsevol que sigui el programa que has escrit -
de nou, els 0s i 1s són carregats des del disc dur, que és un emmagatzematge prolongat,
roman allà fins i tot quan es tiri de la clavilla, es carrega a la memòria RAM.
RAM és més ràpid que els discs durs - és més petit que els discs durs -
però és on els programes en viu mentre està en funcionament.
Així es fa doble clic en un programa en un Mac o PC, es carrega des del disc dur a la RAM.
Així que es carrega a la memòria RAM, el go 0s i 1s a la part superior forma,
el segment de text anomenat, però tan bon punt el programa realment es posa en marxa,
la principal funció és cridada, i principal, com hem vist, sovint té variables locals,
i té sencers i cadenes i caràcters i similars.
Així que si el teu programa que vostè ha escrit o del programa que hagi fet doble clic
utilitzat algunes variables dins de la principal,
acaben en la part inferior de la pila de la memòria, per dir-ho.
Més concretament, què significa això realment?
Això només vol dir que si anàvem a numerar els bytes de RAM a l'ordinador,
notar que aquest podria ser el nombre de bytes 0, aquest podria ser el nombre de bytes 1, 2, 3, 4, 5, 6,
tot el camí fins 2000000000 seria tot el camí fins allà a la part superior.
En altres paraules, quan es parla de la memòria RAM o en termes de bytes,
només significa que algú ha decidit a explicar el que cada un dels trossos de memòria.
Així que quan vostè necessita 32 bits per a un int o necessita 8 bits per a un char,
D'on van a parar a la memòria?
>> Conceptualment, s'acaba d'acabar en el fons d'aquesta cosa anomenada la pila.
Però l'interessant ara és quan crida a una funció principal -
suposem una funció anomenada foo, només un nom arbitrari -
el que passa és principal està a la part inferior d'aquesta pila de la memòria;
foo ara es col · loca en la part superior de la memòria principal.
Així que les variables locals que s'acaben foo tipus de vista conceptual sobre dels de principal.
Si foo crida a una altra funció anomenada bar, aquelles variables acaben aquí.
Si la barra demana una mica més, aquí, aquí, aquí.
Així que el que és interessant sobre l'execució d'un programa és que en cridar a funcions
i com aquestes funcions i cridar a funcions com les funcions que criden a funcions,
construir l'edifici aquesta pila de funcions en la memòria.
I només una vegada retorna una funció no comença a rebre aquesta memòria esquena.
Així que una de les maneres més fàcils d'executar fora de la memòria en un programa informàtic
és escriure funcions que mai tornen.
Així, per exemple, demostrarem com molt amb un programa intencionalment buggy.
Deixin-me seguir endavant i fer # include,
int main (void)
i jo vaig a fer mentre que (2> 1), el que probablement no canviarà en nosaltres,
i m'ho dius a mi seguir endavant ara i fer printf.
En realitat, això serà menys interessant visualment. Anem a fer això.
Per int i = 0; i> 0 - anem a cometre aquest error - i + +.
I no printf aquí. Anem a practicar el que predicava.
Anem a fer una mètode aquí, chorus buit, i direm int i,
i després diré printf - no, farem això més interessant.
Que en realitat no imprimeix res en absolut. Anem a això: chorus (i).
Està bé. Així que això té errors perquè per què?
Estic fent això com vaig perquè el programa no fa res d'interès.
>> Però aquest no és l'objectiu.
L'objectiu és escriure un programa que té com a principal funció fa el que, pel que sembla?
Truqui a si mateix. I en realitat, no necessitem el bucle.
Anem a simplificar encara això només per no perdre de vista realment l'error fonamental.
Principals trucades cor per cantar alguns cors,
llavors vaig fer alguna cosa estúpid i jo vam tenir cor cor anomenada
perquè vaig suposar que algú més havia de posar-ho en pràctica, potser,
i ara això no es va a compilar encara. He de fer què?
Necessito el prototip, recorda.
Així que he de tenir aquí cor void (int i);
Així que ara si em vaig per aquí - en realitat, utilitzarem la finestra més gran.
Seguirem endavant i fer cors.
L'ús d'identificador no declarat i.
Oh, això va ser estúpid. No necessitem l'argument. Anem a fer això.
M'hauria agradat haver començat d'aquesta manera. Hauria estat un programa molt més fàcil d'escriure.
Ja està. Ara anirem a la meva finestra de terminal, executeu de nou Clang, i aquí anem.
Això va ser molt ràpid.
El que en realitat acaba de passar, però?
Bé, ara vaig a afegir la línia d'impressió perquè puguem veure.
Permetin-me dir printf ("Sóc aquí") - sense variables. El deixarem així.
Permetin-me fer tornar a executar. Permetin-me tornar a executar cor.
I ... anem. Segueix endavant.
Com acotació al marge, per què no ho ha ensorrat encara?
La decisió de segmentació passar súper ràpid abans.
[Resposta dels estudiants inaudible] >> Exactament. Així que es necessita temps per imprimir, oi?
Només es necessita més treball per part de l'equip.
I aquí està: segmentation fault.
>> Així notar com de ràpid executar programes.
Si no està imprimint alguna cosa, super ràpid.
Però encara tinc aquest error de segmentació perquè el que estava passant?
Si vostè pensa sobre com la memòria de l'equip es presenta,
això passa a ser principal, però aquí anomenarem a aquest cor, i anomenarem a aquest cor.
I ara si faig la meva estètica bé, això és només dirà cor, cor, cor,
cor, cor, cor, cor, fins a la sacietat, i, finalment, què passarà?
Si el quadre gran, literalment, és la següent, què li passa conceptual?
Els excessos de la pila la pila.
O, pitjor encara, que acaba d'envair tot, incloent el segment de text,
que és el 0 i 1 que representa el programa.
En resum, això és només super, super malament.
El seu programa s'ha disparat fora de control.
Vostè està utilitzant la memòria molt més del previst
tot a causa d'un error estúpid en aquest cas,
o en aquest cas una funció molt deliberadament fet en si de trucada.
Ara, això no és del tot dolent.
Les funcions que es diuen en realitat té un gran poder quan l'hi usa correctament.
Jo no ho he fet servir correctament aquí.
Així que això no és del tot dolent, però el fet que en realitat mai m'aturo trucant
és una debilitat fonamental d'aquest programa aquí.
Llavors, on anem amb tot això? Què està passant realment?
Quan dic a la funció d'increment com si estiguéssim fent en aquests exemples,
Tinc un valor com una que jo pas polz
Em passa una còpia del número 1, de manera que passa a continuació.
Entrarem en l'increment exemple, aquest tipus per aquí.
Això és el que està succeint realment.
Quan dic increment cada passa x, gràficament, el que està passant aquí és el següent.
>> Si tinc el valor d'1 emmagatzemen aquí i jo en realitat cridar increment,
que ara es diu cor - l'iPad m'està tirant d'aquí.
Anem a trucar a aquest increment, i no sabem el que aquesta funció ve serà.
Llavors, què està passant realment aquí en algun lloc principal que tinc un tros de memòria
que emmagatzema el número 1.
Quan dic increment, estic fent servir un altre tros de la memòria,
però ara tinc la còpia de 1.
En augmentar aquest valor, aquest es converteix en 2,
però llavors el que passa tan aviat com torna d'increment?
Aquesta memòria només es va lliurar de nou al sistema operatiu,
el que significa que tot el que hem fet és gens útil.
L'1 que figurava originalment en el principal segueix sent realment allà.
Llavors, ¿a on anem amb això?
Resulta que en la memòria que té aquesta seqüència de back-to-back de bytes
que es poden posar coses a dins, i resulta que ja hem vist alguna cosa
que consisteix a col · locar les coses tornin a esquena amb esquena amb esquena.
Què és una cadena basada en la setmana 1 i la setmana 2 ara?
És només un conjunt de caràcters.
Així que resulta tal com es pot posar els números a la memòria,
De la mateixa manera es pot posar caràcters en la memòria.
I un cop que comencem a posar en la memòria de personatges d'esquena a l'esquena amb esquena,
resulta que l'ús de les coses més simples com un bucle o un bucle while,
podem repetir d'esquerra a dreta sobre els caràcters d'una cadena
i començar a fer massatges a personatges completament diferents -
podria esdevenir una b, b podria ser c -
pel que en última instància, podem prendre una frase Anglès que realment té sentit
i convertir cadascuna d'aquestes una cartes en un moment
caminant a través de la memòria del nostre ordinador d'esquerra a dreta per xifrar en realitat.
Així que tindrem nostres cinc minuts de descans aquí,
i quan tornem, anem a començar aquest procés de codificació de la informació.
>> Està bé.
Abans de submergir-se en alguna crypto i aquestes coses anomenades matrius,
permetin-me fer una pausa per a qualsevol pregunta, perquè em sento com si realment alguna cosa confusa
alguns d'aquests temes. Així que anem a arreglar ara si podem.
Acabem de parlar sobre valors de retorn, parlem d'arguments,
i parlem d'aquesta idea, que tornarem a les pròximes setmanes,
de visualització de la memòria com un grapat sencer d'aquestes safates apilades, per dir-ho,
de baix a dalt, de manera que cada safata que es posen a la pila
representa una funció que està sent anomenat.
Alguna pregunta?
Permeteu-me fer-li una pregunta aquí.
Permetin-me simplificar això al que era abans que alguns de la nostra anterior Q & A.
El fet que l'increment té parèntesi d'obertura, nombre int, tancat parèntesi -
¿Quin nombre representa int?
[Estudiant] Un argument. >> Un argument. Bé. Però el que és un argument?
[Resposta dels estudiants inaudible] >> Què és això? >> [Estudiant] Una cosa que es passa polz
Està bé, així que alguna cosa que passa polz I més en general, és només l'entrada.
Si estigués escrivint una funció i propòsit d'aquesta funció en la vida
és fer una cosa una mica diferent cada vegada que l'utilitzi,
llavors l'única forma perquè això succeeixi realment sembla que deixés entrar
perquè es pugui fer alguna cosa diferent amb aquesta entrada cada vegada.
>> Així que cal especificar dues coses quan una funció presa d'entrada.
Cal especificar el nom que voleu donar a aquesta entrada
exclusivament per a la seva conveniència, perquè pugui referir-s'hi
en la funció que vostè està escrivint, com ho vaig fer aquí a la línia 32.
Però també cal especificar el seu tipus, ja que C és un llenguatge de programació
que només requereix que si vols una variable, vostè ha de dir-li a l'ordinador quin tipus de dades és,
en gran part, a que sàpiga el nombre de bits a assignar a aquesta variable
perquè podria ser de 6 - ho sento, no serà 6.
Pot ser 16, pot ser 8, pot ser 32, fins i tot 64,
però l'equip ha de saber.
Ara, la INT a la banda esquerra representa el que, per contra?
[Resposta dels estudiants inaudible] >> Què és això? >> [Estudiant] Tipus de funció.
El tipus d'una funció i, més específicament, el tipus de la seva producció. Dreta.
Així, mentre que la cosa en parèntesi representa la seva entrada, si s'escau,
la cosa a l'esquerra representa la sortida.
I en aquest cas, l'increment aparentment torna un int,
i així int és el tipus de retorn d'aquesta funció.
Què significa tornar?
Literalment, s'utilitza la paraula clau return i després, si ho tornarà
a la dreta de la paraula clau és un nombre enter,
llavors que és consistent amb el que hem promès.
No es podria fer alguna cosa com això - hola, món - perquè això és una cadena.
>> Òbviament, no és un nombre enter.
Així que en resum, la càrrega està realment en nosaltres, el programador, per ser específic
quant al que estem tornant i per llavors de seguir per tornar.
El context aquí és que la memòria del seu ordinador és un gigabyte, 2 gigabytes -
el que sigui - potser és més, potser és menys,
però l'equip que considera que té diferents seccions.
Una cosa passa allà baix, una mica més va allà dalt,
coses diferents va en el medi, i avui simplement començar a explicar la història,
però anem a tornar a aquest moment de nou.
Per ara, l'única memòria que realment importa és el segment de text
ja que només representa el 0 i 1 que Clang s'emeten.
Així que quan s'executa una ordre en el teclat com a.out
o fa doble clic en una icona en Mac OS o Windows,
el programa es carrega des del disc dur a la RAM
i es va deixar caure al cim de la memòria RAM de l'ordinador, per dir-ho.
Mentrestant, comença el teu programa d'entrenament i principal trucada
al programa que va escriure o escriu el programa de Microsoft o Apple,
qualsevol de les seves variables locals acaben aquí baix a la part inferior de la memòria del seu ordinador.
Però si les trucades principals a una altra funció que té variables o arguments, acaben sobre.
I si aquesta funció crida a alguna cosa, acaben sobre d'ell, a sobre d'ell, a sobre d'ell.
>> I només una vegada una funció es fa executar és la pila de safates, per dir-ho,
comencen a posar-se més i més.
I això és el que llavors, en poques paraules, explica per què quan es diu cub
o pot trucar al increment, que està passant per una còpia del valor.
I el que això significa és que pictòricament està literalment escrit el número 1
en una altra part de la memòria, el canvi que 1 a 2 en el cas d'increment
oa un 8 en el cas de cub i després estirar que la memòria de distància
tan bon punt l'increment dels rendiments o de funcions de cub. Pregunta.
[Estudiant] On s'emmagatzemen les variables globals?
Les variables globals s'emmagatzemen en el que s'anomena actualment les dades inicialitzats o dades sense inicialitzar,
la diferència està en si té una variable global i se li assigna un valor immediat
amb el signe d'igualtat, acaba a la part superior hi ha,
i si el que diuen int x; sense valor, acaba lleugerament inferior en RAM
simplement per convenció.
Altres preguntes? Està bé.
Així que aquesta imatge tornarà a mesura que més poderós
amb el que podem fer amb l'ordinador,
però per ara, tindrem una breu introducció a la criptografia,
un tipus específic de criptografia que no resol tots els problemes del món
però és resoldre alguns.
En aquest cas aquí, tenim una cosa que es diu criptografia de clau secreta.
Criptografia de clau secreta, com el nom suggereix, deriva la seva seguretat d'un secret.
>> Per exemple, si estaven de tornada a l'escola primària i que estaven passant una carta secreta mica d'amor
per al noi o la noia amb la qual estaven aixafant en endavant, si volia passar aquesta nota a través de l'audiència,
és probable que no anava a escriure una nota a Anglès o el que la seva llengua materna és.
Més aviat, és possible xifrar o simplement pot enviar-los un missatge de text en aquests dies.
Però que en realitat podria passar una nota a través de la sala de classe.
I per fer-ho amb seguretat, de tal manera que els seus amics i el professor
no saps el que estàs escrivint, és possible arribar a un algoritme bastant simple,
jove, encara que és possible que, amb només barrejar les paraules.
Així que en lloc d'escriure una pot escriure b,
en lloc de b pot escriure c,
en lloc de c pot escriure d, i així successivament.
O bé, podria arribar a una traducció més sofisticada
de cartes a diferents lletres.
Però el problema és el noi o la noia a la qual li està enviant aquesta nota
ha de saber alguna cosa, que és el que, òbviament? >> [Estudiant] El que vostè està enviant.
Quin és el seu secret, com ho és que com traduir els una i la de B i de C i D's.
És només l'addició d'1 a cadascuna de les lletres per anar de A a B, de B a C?
És més complex que això?
>> Així que tu i el teu enamorat és necessari tenir aquesta informació secreta,
però hi ha una espècie de catch-22 aquí.
Si aquesta és la primera vegada que enviarà aquesta carta d'amor a través de la classe,
Com és aquest nen o nena sabrà quin és el secret fins i tot és?
Així clau secreta de xifrat no resol tots els problemes del món,
i de fet hi ha una relació que aquí tornarem a cap al final del semestre.
De la mateixa manera, no la majoria de nosaltres coneix a algú que treballa, per exemple, a Amazon.com,
i no obstant això, molts de nosaltres hem comprat coses a Amazon.com,
i se'ns ha ensenyat a assumir que aquestes transaccions de comerç electrònic són segurs.
La direcció URL https probablement diu, hi ha potser una icona de cadenat poc ximple en algun lloc,
hi ha una mena de criptografia assegurar la seva informació de targeta de crèdit
entre vostè i Amazon.com.
I no obstant això, si la criptografia implica saber algun secret
i no obstant això, jo no conec a ningú a Amazon i no he arreglat sens dubte algun tipus de secret
amb algú a l'Amazones, com és el meu ordinador o navegador fent això?
Resulta que hi ha altres tipus de criptografia en conjunt de resoldre aquest problema.
Però per ara, ens centrarem en el senzill
on es pot organitzar amb antelació per conèixer algun secret
com una o altra assignació entre una i la de b.
I el procés de criptografia generalment implica això.
Vostè té una mica de text sense format, representat aquí a l'esquerra,
s'executa a través d'algun tipus d'algorisme o procediment per xifrar -
potser això és només una es converteix en b, b esdevé c -
i llavors acaba amb text xifrat.
Mentrestant, un cop que el seu enamorament rep aquesta nota secreta,
ell o ella ha de descífralo en general revertir aquest algorisme
amb la finalitat de recuperar el text sense format.
Hi ha encarnacions físiques d'aquest.
>> Per exemple, aquest és un anell descodificador secret poc,
i aquest és un anell en el sentit que hi ha dos dials aquí.
A la perifèria exterior d'aquesta cosa, no hi ha lletres de l'A a la Z,
encara estan en ordre aleatori,
ia l'interior, de fet hi ha alguns nombres
de tal manera que amb aquest anell et poden espècie de tornada a l'exterior però no l'interior
amb la finalitat d'alinear els números amb lletres.
A partir d'una pel · lícula que es diu Un conte de Nadal, veuràs que poc Ralphie
estava tan ansiós d'esbrinar quin és el missatge secret Little Orphan Annie era per a ell
que havia estat comunicada, crec, en forma de missatges numèrics en una caixa de cereal
i ha hagut d'acumular totes les petites targetes que vénen a la caixa de cereal,
calia enviar-los per correu, calia recuperar l'anell descodificador secret
de manera que vostè pot finalment entendre el que el mapeig és entre les lletres i els números
o lletres i lletres.
Com en un ordinador podem anar sobre l'aplicació o representar les coses d'aquesta manera?
Necessitem una manera d'expressar-nos una mica més flexible
que les nostres variables fins al moment han permès.
Hem tingut sencers, hem tingut caràcters, hem tingut flotadors i dobles i alguns altres,
però aquestes són les peces individuals de la memòria que realment no ens permeten expressar coses
com les paraules i les oracions i frases.
De fet, hem anomenat cordes aquestes coses,
però prometo que això és només una simplificació a la biblioteca CS50
que estem intentant pelar.
Així que anem a començar a fer això aquí.
Deixin-me seguir endavant i obrir un arxiu -
tots aquests arxius estan disponibles, com de costum, en línia - array.c anomenada
per resoldre un problema no relacionat amb les cadenes, però que pinta un quadre aquí
de com podríem utilitzar una cosa que es diu una matriu.
>> Una matriu és un tipus de dades.
És un tipus de variable de tipus que té diversos tipus de dades més petites dins d'ella
esquena amb esquena a esquena amb esquena.
Així, per exemple, si volem escriure un petit programa que et dóna la mitjana de concurs
per a un curs com 50 que té dos qüestionaris,
que podria molt fàcilment escriure aquest programa basat fins i tot en alguns dels materials de la setmana passada
mitjançant l'ús d'getInt i un parell de variables: int quiz1, int quiz2.
I és bastant senzill.
És potser 10, 20 línies de codi màxim per posar en pràctica un programa de
que demana a l'usuari 2 puntuacions prova i després calcula la mitjana
mitjançant l'addició d'ells junts, dividint per 2, i després imprimir els resultats.
Probablement podríem fer això molt fàcilment ara, després d'un cert nombre de minuts.
Però el problema és de suposar que 50 tenien 3 o 4 proves.
Suposem que li agradaria utilitzar el mateix programa per a una classe que tenia proves setmanals.
Penseu en una classe que ha exàmens setmanals.
Si hi ha 16 o més setmanes en un semestre, ara té 16 variables:
quiz1 int, int quiz2, int quiz3, int quiz4.
Així que vostè comença a veure aquesta redundància, aquesta copiant i enganxant el codi,
ha de començar a fer que t'agradaria que hi hagués una manera millor.
I gràcies a Déu, a causa de les matrius que hi ha. Així que anem a fer això.
En primer lloc, permetin-me presentar a una cosa molt simple que no hem fet servir fins ara,
però ho vas a veure de tant en tant en el codi.
>> Això és el que normalment es coneix com constant.
Així que és una constant en el sentit que aquest valor mai canvia.
La convenció humana quan es crea una constant
és l'ús de lletres majúscules només perquè realment es destaca en el seu codi,
i la paraula clau especial que s'utilitza en C # defineix.
Per això diem # defineix, després un espai, llavors la paraula que voleu utilitzar per al nom de la constant de
i després el valor de la constant.
Tingueu en compte que això és diferent de assigna alguna cosa a una variable.
No hi ha cap signe igual, no hi ha punt i coma.
Això és el que es coneix generalment com una directiva de preprocessador,
però més d'això en un altre moment.
Per ara, això crea un valor immutable anomenat TESTS
el valor numèric real és 2.
Així que on Quan vegeu proves, exàmens, proves curtes al llarg d'aquest arxiu,
això és només el número 2.
Si miro principal ara, anem a veure com funciona això.
Primer es veu una mica críptic, però és tot coses de la setmana 1.
Demani a l'usuari per als graus. Com podem fer això?
En la línia 22 - aquesta és realment la part sucosa - Declaro un flotador
però no és només un sol flotador. Estic declarant, més aviat, un conjunt de valors de punt flotant.
Aquesta variable es dirà graus, com s'implica aquí,
però l'única nova sintaxi llavors són aquests claudàtors.
El fet que el que he dit graus flotador i després obrir el parèntesi i després el nombre a -
compte si es tracta d'una constant és igual que ho vam fer -
això vol dir, "Hey ordinador, deme 2 flotadors i anem a anomenar col · lectivament graus".
>> Això està en contrast amb un procés molt més tediós així: flotador grau 1;
grade2 surar, i així successivament.
Així que una matriu que ens permet posar en pràctica aquesta idea, però molt menys desordenadament,
de tal manera que podem escriure una línia de codi en lloc de, per exemple, 16 per a un semestre de 16 setmanes.
Jo no volia que codificar 2 perquè si es pensa en això ara, lògicament,
Suposo que l'any que ve CS50 canvis a 3 qüestionaris en lloc
i jo tenia el número 2 aquí, jo tenia el número 2 aquí,
Jo tenia el número 2 aquí, el número 2 aquí.
Es torna molt tediós i molt fàcil ficar la pota
i canviar accidentalment un valor a 3 i es perdi algun altre valor de 2.
Així que vaig a aquest lloc abstracte lluny i utilitzar aquesta constant que,
Com el seu nom indica, mai canvia.
I ara no importa si tenim diferents concursos d'aquest any o el pròxim,
Només he de canviar en un lloc aquí a la part superior.
Així que això és tot, una constant és.
Mentrestant, la característica nova és que conceptual d'una matriu.
Així que els claudàtors donar-me aquesta flota i molts em permet anomenar col · lectivament graus aquí.
Així que ara anem a veure el que faré.
Aquí, a la línia 24 és l'inici d'un bucle.
>> Això és realment res especial. És només mitjançant TESTS lloc d'un nombre codificat.
Però no hi ha res intel · lectualment diferent allà la setmana passada.
Això és només printf, així printf ("Quiz #% d de% d:")
perquè només vull imprimir dóna'm concurs número 1 de 2 i després 2 de 2.
Així que això és una cosa purament estètic.
Però la part més interessant ara està en la línia 27.
Per tal d'omplir en un dels dos marcadors de posició amb un valor de punt flotant,
de nou utilitzar claudàtors.
En aquest cas, estic fent servir i perquè aquest bucle for s'ha iniciat amb i igualant el valor que, pel que sembla?
[Estudiant] 0. >> [Malan] 0.
Així que en la primera iteració d'aquest bucle, és com si jo vaig escriure això en el codi,
però en la segona iteració d'aquest bucle, és com si jo vaig escriure això en el meu codi.
Però el fet que jo estic fent servir una variable és perfecte perquè, com el seu nom ho indica,
està variant el seu valor en cada iteració,
així que estic omplint aquesta matriu un lloc al mateix temps.
Què fa aquest acord sembla?
La raó per la que va dibuixar el quadrat super simple a la pantalla d'aquí abans que ser per aquesta raó.
Una matriu és simplement un tros de memòria seguit d'un altre tros de memòria
seguit per un altre bloc de memòria i així successivament.
Així que si el meu matriu és de mida 2 en aquest cas aquí, l'únic que estaria fent
escrivint en les puntuacions dels meus concursos com aquí - Tinc 100 en aquest i després em van donar un 99 en aquest cas -
llavors aquesta memòria que ni tan sols pot utilitzar perquè només he demanat a l'equip
per una matriu de mida 2.
Les places estan encara allà, oi?
Encara disposa de 2 gigabytes de RAM, encara que només està demanant per a 2 carros.
Així que la idea darrere de les matrius és que l'ordinador només pren un tros de memòria
i després reparteix trossos més petits d'esquena a l'esquena amb esquena.
I això és tot un arranjament és.
>> És un tros contigu de memòria dins de la qual vostè pot posar les coses.
Això li passa a fer a continuació, només una mica d'aritmètica avorrit.
Si em desplaço fins aquí, aquí és on em iterar sobre la matriu.
Vinc amb la suma de tots els valors de la matriu,
i aleshores utilitzar la funció round aquí per fer realitat la suma dividida per quizzes.
Però permetin-me saludar la meva mà que com una mena d'aritmètica suficient per ara.
Però tot el que està fent per mi en última instància està calculant una mitjana.
Així que prova primer més segon qüestionari dividit per 2 i després imprimir-com un int.
Però ara anem a la transició a un exemple diferent anomenat cadena1,
que pinta un quadre similar però utilitzant cordes.
Deixin-me seguir endavant i simplificar això per un moment.
Perdona la sagnia per ara.
Observeu en la línia 19 d'aquest exemple, tinc una cadena de l'usuari.
Però noti el que estic fent en la línies 22 en endavant.
En realitat estic iterar des i fins - i aquest és un nou truc - strlen, longitud de la cadena.
Aquesta és una funció que ve amb C que si se li passa una cadena,
et diu quants caràcters hi ha en aquesta cadena. Això és tot.
I el fet que és strlen en lloc de la longitud de la cadena és només perquè és més concís.
Trenta anys enrere, la gent li agrada escriure coses tan succintament possible,
així que hem mantingut aquesta convenció aquí.
i + + només significa incrementar ia cada iteració.
I ara notin això, que és molt interessant.
En la línia 24, li dic, "Ordinador, dóna'm un personatge, 8 bits, i en diuen c".
Però què és això en la part dreta dient?
En Anglès, què representa?
[Estudiant] El primer caràcter del conjunt.
Exactament. Dóna'm el primer caràcter de la matriu.
O, més en general, em donen el caràcter ia la matriu.
I adonar-se que és important ara que com els informàtics,
en realitat estem comptant des de 0.
>> No té la discreció per començar a fer-ho.
Ara vostè ha de comportar-se d'acord amb les expectatives de l'equip i comptar de 0
perquè [0] serà el primer caràcter d'una cadena,
[1] serà la segona, [2] que serà el tercer, i així successivament.
Així que aquest programa, si ho compila, es tracta novament de cadena1, així que cadena1,
i ara m'he trobat en la meva cadena1 finestra de terminal.
S'espera per a l'entrada, així que vaig a escriure en David, Enter,
i ara imprimeix David tot en línies diferents, perquè fixa't el que estic fent.
Estic imprimint un caràcter alhora.
No entrarem en detalls avui sobre això, però he eliminat fa un moment aquest xec aquí.
Resulta que si l'usuari s'està portant malament, contradictori, confús o simplement
en realitat es pot deixar de donar una sèrie de certa extensió.
Si es prem la tecla equivocada al teclat, es pot donar cap cadena en absolut,
o si vostè és maliciós, pot intentar per enganxar al patrimoni d'un gigabyte d'un assaig
per omplir aquesta cadena, i si l'equip es queda sense memòria,
resulta que tornarem aquest valor especial anomenat NULL.
Així que per ara, només sé que hi ha aquest valor especial anomenat NULL
que ens permetrà comprovar quan estem fora de la memòria, entre altres coses.
Però si obro ara cadena2, noti una diferència aquí.
Tingueu en compte una diferència aquí amb cadena2.
Amb cadena2, aquest bucle for és una mica diferent.
>> Deixa esborrar els valors NULL perquè puguem parlar d'aquells en un altre moment.
Què hi ha de diferent en el bucle for aquesta vegada?
Puc tornar a l'exemple anterior.
Així que és la versió 2, aquesta és la versió 1. 1, 2.
1, 2.
L'anomenada strlen és on?
És a la primera part del bucle for.
Alguna idea de per què estic fent això? Si.
[Estudiant] Així no es diu a la funció cada vegada.
[Malan] Així que no cridi a la funció cada vegada. Exactament.
Recordeu que en els bucles for que són super simple
una vegada que una espècie de comprendre que aquesta és la inicialització, la condició, i l'actualització.
El problema és que la condició ocorre en cada iteració del bucle.
I així, en aquest exemple aquí, què té de dolent el fet que aquesta és la meva condició?
[Estudiant] Estàs trucant strlen.
[Malan] Ets trucant strlen una i altra vegada i una altra.
Però una vegada que has escrit en David, la longitud de la cadena és de 5,
i això no canviarà en cada iteració del bucle
perquè la cadena és encara D-A-v-i-d.
Així que aquesta és una pista del que es convertirà en una idea cada vegada més important
coneguda com una decisió de disseny on simplement no fer que l'ordinador faci la feina innecessari.
>> Així com una bestreta de pset2, pset2 en l'edició estàndard
et desafiar aplicar en la pràctica un cert nombre de xifres,
un nombre d'algorismes de xifrat, pel que ambdós puguin xifrar
i desxifrar missatges secrets molt similar a la Ralphie hi ha un descodificat.
En l'edició pirata de pset2, anirem una mica més lluny.
Ens anem a lliurar un arxiu d'un sistema informàtic actual
que conté una gran quantitat de noms d'usuari i contrasenyes xifrades reals,
i el repte de l'edició pirata serà per esquerdar les contrasenyes
i esbrinar el que la criptografia o quin secret es va utilitzar per generar realment les contrasenyes.
I farem això utilitzant un tret de C
que et donaré només un demo del conegut com a arguments de línia de comandes.
Resulta que, com alguns de vostès poden haver vist en la secció o en llibres de text,
principal no ha de sempre ser nul entre parèntesi.
Resulta que la principal també es pot escriure així, amb dos arguments,
argc i argv, on argc és el nombre de paraules
que s'escriu després del nom del programa en la línia d'ordres
i argv són les paraules reals.
I com els claudàtors indiquen allà, argv és aparentment una matriu.
Serà una cadena després d'una sèrie després d'una cadena en la memòria.
>> Llavors, què serem capaços de fer a partir de conjunt de processadors 2 és una cosa com això.
Si faig argv1, que és un exemple tornarem a dilluns, i executar-lo,
adonar que no sembla fer res.
Simplement imprimeix el seu propi nom.
Però si dic adéu classe, observi que aquest programa aparentment es repeteix
sobre cadascuna de les paraules que s'escriuen en l'indicador.
I els mitjans pels quals tindrem accés a les paraules que l'usuari ha escrit en l'indicador
és canviant principal a partir d'aquest cap de setmana des int main (void) per int main (argc, argv)
i així naixerà arguments de línia de comandes.
I un cop que estiguis molt sofisticat en això, vostè serà capaç d'escriure programes realment trippy
com aquest aquí, que va per sobre i més enllà
algunes de les funcions que hem fet fins ara, però tot molt potent.
>> Així que sortirem d'això amb la següent a la pantalla, i ens veiem el dilluns.
>> [CS50.TV]