DOUG LLOYD: Va bene.
Così ora affrontiamo un davvero grande argomento, funzioni.
Finora in corso, tutte le programmi che ho scritto
sono state scritte all'interno di principale.
Sono programmi piuttosto semplici.
Non è necessario avere tutti questi rami e cose da fare.
Possiamo solo andare bene tutto interno principale e
non ottiene terribilmente opprimente.
Ma come il corso va avanti e come si inizia a sviluppare programmi
indipendentemente, sono probabilmente andando per iniziare a ottenere molto di più di 10
o 15 linee.
Si potrebbe ottenere centinaia o migliaia o decine di migliaia di linee di codice.
E non è davvero che un pensiero folle.
In quanto tale, non è probabilmente una buona idea a tenere tutto dentro di principale.
Si può ottenere un po 'difficile da trovare quello che stai cercando, se lo fai.
>> Fortunatamente, però C, e praticamente ogni altro linguaggio di programmazione che
potrebbe funzionare con, permette di scrivere funzioni.
E sto solo andando a prendere un rapido a parte qui
contare che funzioni è un settore di informatica.
E vedrete molti più di loro a vari punti del corso
e se si continua su.
Dove c'è un sacco di sinonimi della stessa parola.
Così noi chiamiamo le funzioni.
Ma si potrebbe anche sentire loro denominato procedure,
o metodi, in particolare, se hai mai fatto alcuna programmazione orientata agli oggetti
before-- e non preoccuparti se non, non l'hai
un grande deal-- ma in controllo orientato lingue
sono spesso chiamati metodi.
A volte si chiamano sottoprogrammi.
Ma in realtà si riferiscono tutti alla stessa idea di base.
>> Vediamo cosa che idea è.
Che cos'è una funzione?
Beh, una funzione è davvero niente di più che una scatola nera.
Una scatola nera che ha una serie di a zero o più ingressi ed una uscita.
Così, per esempio, questo potrebbe essere una funzione.
Questa è una funzione chiamata funz.
E richiede tre ingressi a, b, ec.
E dentro quella scatola nera, abbiamo non so esattamente ciò che fa,
ma elabora gli ingressi in qualche modo e poi
dà una singola uscita, in questo caso, z.
Ora per rendere un po ' meno astratto, abbiamo
potremmo dire che forse noi hanno una funzione chiamata
Add che accetta tre ingressi a, b, e c ed elabora l'uscita in qualche modo
all'interno della scatola nera per produrre una singola uscita.
Quindi, in questo caso, se aggiungere prende 3, 6, e 7.
Da qualche parte dentro il aggiungere la funzione, avremmo
aspettarsi che essere sommati per produrre l'output, che
è 3 più 6, più 7 o 16.
>> Allo stesso modo, si dispone di una funzione chiamata mult che prende due ingressi A e B,
li elabora in qualche modo tale che l'uscita della funzione
è il prodotto dei due ingressi.
I due ingressi moltiplicati insieme.
4 e 5 di essere passati in mult, succede qualcosa, l'uscita ci aspettiamo
è 20.
Perché si parla di una scatola nera?
Beh, se non stiamo scrivendo il Funzioni noi stessi, che
abbiamo fatto un bel po 'finora CS50.
Abbiamo visto la stampa f, per esempio, che è una funzione che non abbiamo scritto
noi stessi, ma noi usa tutto il tempo.
Se non stiamo scrivendo le funzioni di noi stessi,
noi non abbiamo bisogno di sapere come è effettivamente messo in atto sotto il cofano.
>> Così, per esempio la scatola nera I appena mostrato per la moltiplicazione,
mult a, b potrebbe essere defined-- e questo è solo
alcuni pseudocode-- potrebbe essere definito come il rendimento a volte b.
Che senso ha, a destra.
Se abbiamo una funzione chiamata mult che prende due ingressi.
Ci si aspetterebbe che l'uscita sarebbe essere i due ingressi moltiplicati insieme,
a volte b.
Ma potrebbe anche essere mult implementato come questo,
abbiamo una variabile contatore a get set all'interno di mult a 0.
E allora ripetiamo questo processo b volte aggiungere un contatore a.
Ad esempio, se moltiplichiamo 3a by 5b, potremmo dire impostare contatore a 0,
ripetere cinque volte, aggiungere 3 al contatore.
Dunque iniziamo a 0 e poi facciamo cinque volte 3, 6, 9, 12, 15.
E 'lo stesso risultato. Noi ancora ottenere 3 volte 5 solo
l'implementazione è diversa.
>> Questo è ciò che intendiamo quando diciamo una scatola nera.
Significa solo che non mi interessa come è implementato sotto il cofano
finché l'uscita è quello che ci aspettiamo.
In realtà, questo è parte del contratto di utilizzo di funzioni, particolarmente
funzioni che gli altri scrivono.
Il comportamento è sempre in corso di essere tipico, imprevedibile
in base al nome della funzione.
Ed è per questo che è davvero importante quando si scrive funzioni
o quando gli altri scrivono funzioni che si potrebbe utilizzare,
che tali funzioni hanno chiare, nomi relativamente evidenti,
e sono ben documentati.
Che è certamente il caso per la funzione di come la stampa f.
>> Allora perché usiamo le funzioni?
Beh, come ho detto prima, se scriviamo tutto il nostro codice all'interno delle cose principali
può ottenere davvero ingombrante e davvero complicato.
Funzioni ci consentono la capacità di organizzare le cose e rompere
un problema molto complicato in molte sub parti più gestibili.
Funzioni ci permettono anche di semplificare il processo di codifica.
E 'molto più facile per eseguire il debug di un 10 funzione di linea rispetto a una linea 100
funzione o una funzione di 1.000 riga.
Se non ci resta che eseguire il debug piccoli pezzi alla volta,
o scrivere piccoli pezzi, al momento, rende questa esperienza di programmazione
molto meglio.
Fidati di me su quello.
>> Infine, se scriviamo funzioni che può riutilizzare quelle varie parti.
Le funzioni possono essere riciclati.
Possono essere utilizzati in un programma o un altro.
Hai già scritto la funzione, tutto quello che
bisogno di fare è dire che il programma dove trovare tale funzione.
Abbiamo riciclaggio e impiego f stampare da oltre 40 anni.
Ma è stato scritto solo una volta.
Molto utile, a destra.
Tutto ok.
Così funzioni sono grandi.
Lo sappiamo.
Ora cominciamo a scriverli.
Partiamo sempre li nei nostri programmi.
Per fare ciò, il primo cosa che facciamo è dichiarare la funzione.
Quando si dichiara una funzione di quello che stai facendo fondamentalmente
sta dicendo il compilatore, ehi, solo così sai,
Ho intenzione di scrivere una funzione più tardi
ed ecco cosa è andare a guardare come.
La ragione di questo è perché i compilatori può
fare alcune cose strane se vedono una serie di simboli
che non sono a conoscenza.
Quindi ci limitiamo a dare il compilatore un testa a testa, sto creando una funzione
e sta andando a fare questo.
Dichiarazioni di funzione generalmente se si sta organizzando il codice in un modo
che altri potranno comprendere e utilizzare,
in genere si vuole mettere tutto delle vostre dichiarazioni di funzione
in cima del codice, destra Prima di iniziare a scrivere principale anche.
E convenientemente, c'è una forma molto standard
che ogni dichiarazione di funzione segue.
Sono tutti più o meno simile a questa.
Ci sono tre parti ad una funzione dichiarazione, tipo di ritorno, nome,
e elenco di argomenti.
>> Ora il tipo di ritorno è che tipo di variabile uscita funzione volontà.
Così, per esempio, se pensiamo indietro un minuto fa per la moltiplicazione di due
funzione di numeri, che cosa ci aspettiamo se moltiplichiamo un numero intero da un numero intero
l'uscita sarà probabilmente un intero, a destra.
Moltiplicato due interi insieme, si ottiene un numero intero.
Così il tipo di ritorno di quella Funzione sarebbe int.
Il nome è quello che volete per chiamare la funzione.
Questo è probabilmente il meno importante parte della dichiarazione di funzione,
in termini di funzionalità.
Ma in realtà è probabilmente uno delle parti più importanti
della dichiarazione di funzione in termini di sapere ciò che la funzione in realtà
fa.
Se si denomina la funzione F o G o h o mistero o qualcosa del genere,
probabilmente stai andando per ottenere un piccolo sgambetto cercare
di ricordare ciò che queste funzioni fanno.
Quindi è importante dare il vostro nomi significativi della funzione.
>> Infine, lista degli argomenti è l'elenco separato da virgole
di tutti gli ingressi alla vostra funzione, ciascuno dei quali ha un tipo e un nome.
Quindi non solo si deve specificare il tipo di variabile
l'uscita funzione di volontà, anche voi volete specificare
che tipo e tipi di variabili dei la funzione sarà di accettare come input.
Allora, facciamo un esempio qui.
Diciamo solo un'occhiata ad una più concreta.
Ecco un esempio di una funzione dichiarazione di una funzione che
vorrei aggiungere due interi insieme.
La somma di due numeri interi sta per essere un numero intero e, come abbiamo appena
discusso.
E così il tipo di ritorno, qui nel verde, sarebbe int.
Questo ci che aggiungono due interi dice solo sta per, alla fine della giornata,
uscita, o sputare indietro a noi, un numero intero.
Dato ciò che questa funzione fa abbiamo vuole dare un nome significativo.
Aggiungere due interi sembra del caso, tenendo conto
stiamo prendendo due interi come input e, auspicabilmente, sommandoli.
Potrebbe essere un po 'di un ingombrante nome e francamente questa funzione
è probabilmente non necessario dal momento che abbiamo l'aggiunta
operatore, se vi ricordate dal nostro discussione degli operatori, in precedenza.
Ma diciamo solo che per amor di tesi che questa funzione è utile
e così lo chiameremo aggiungere due int.
Infine, la funzione prende due ingressi.
Ciascuno dei quali è un numero intero.
Quindi abbiamo questa virgola elenco separato degli ingressi.
Ora noi generalmente vogliamo dare un nome a ciascuno di essi
in modo che possano essere utilizzati all'interno della funzione.
I nomi non sono terribilmente importante.
>> In questo caso, noi non necessariamente avere un significato ad essi connessi.
Così possiamo solo chiamarli a e b.
Questo è totalmente bene.
Se, tuttavia, si trova in una situazione
dove i nomi delle variabili potrebbe effettivamente essere importante,
si potrebbe desiderare di chiamarli qualcosa di diverso a e b
per dare loro qualcosa in più simbolicamente significativa.
Ma in questo caso, non lo facciamo davvero sapere altro sulla funzione.
Vogliamo solo aggiungere due interi.
Quindi ci limiteremo a chiamare quelli interi a e b.
Questo è un esempio.
>> Perché non si prende un secondo di pensare a questo,
come è possibile scrivere una funzione dichiarazione di una funzione che
Moltiplica due numeri floating point?
Ti ricordi che cosa un numero in virgola mobile è?
Cosa sarebbe questa funzione dichiarazione simile?
Io in realtà consiglio di mettere in pausa il video qui e prendere quanto tempo hai bisogno.
Pensate a che cosa questo dichiarazione di funzione sarebbe?
Quale sarebbe il tipo di ritorno sarà?
Cosa sarebbe un nome significativo essere?
Quali sarebbero gli ingressi essere?
Allora perché non si mette in pausa il video qui e scrivere-up una dichiarazione di funzione
per una funzione che moltiplicare due numeri in virgola mobile insieme.
Speriamo che hai messo in pausa il video.
>> Quindi, diamo un'occhiata a un esempio di una possibile dichiarazione.
Float mult due reali galleggiano x, y galleggiante.
Il prodotto di due numeri in virgola mobile,
che ricorda il modo in cui sono rappresentare i numeri reali
o numeri con valori decimali in c, sta per essere un numero in virgola mobile.
Quando si moltiplicano un decimali da un decimale,
probabilmente stai andando per ottenere un decimale.
Si vuole dare un nome rilevante.
Moltiplicare due reali sembra che vada bene.
Ma si potrebbe davvero chiamare mult due galleggianti, o galleggianti mult.
Qualcosa di simile, purché ha dato un po 'di vero significato a ciò che
questa scatola nera stava per fare.
E ancora, in questo caso, non lo facciamo sembra avere alcun significato collegato
per i nomi dei variabili stiamo passando in,
così abbiamo appena li chiamiamo xe y.
Ora, se si chiama loro qualcosa altro, che è totalmente bene.
Infatti, se l'avete fatto tale dichiarazione invece
utilizzando invece raddoppia di galleggianti, se vi ricordate
che doppi sono una diversa senso più precisamente
specificare i numeri reali o floating point variabili.
Questo è del tutto troppo bene.
Uno di quelli che sarebbe bene.
In realtà, ci sono diversi diverse combinazioni
di modi per dichiarare questa funzione.
Ma questi sono due quelli abbastanza buoni.
Abbiamo dichiarato una funzione, che è grande.
Abbiamo detto al compilatore che cosa è, quello che stiamo andando a fare.
Ora diamo effettivamente scrivere quella funzione.
Diamogli una definizione, in modo che dentro la scatola nera
comportamento prevedibile sta accadendo.
In realtà, stiamo moltiplicando due reali numeri insieme, o numeri aggiungendo
insieme, o fare qualunque cosa sia che abbiamo chiesto alla nostra funzione per fare.
>> Quindi, in realtà, proviamo e definire moltiplicare due reali che abbiamo appena
parlato di un secondo fa.
Ora l'inizio una definizione di funzione
sembra quasi esattamente la stessa come una dichiarazione di funzione.
Ho sia di loro qui.
Nella parte superiore è la dichiarazione di funzione, tipo, nome, separati da virgola argomento
lista, punto e virgola.
Il punto e virgola indica che che è una dichiarazione di funzione.
L'inizio della funzione definizione appare quasi esattamente
lo stesso, tipo, nome, separati da virgola elenco di argomenti, senza virgola,
aprire parentesi graffa.
La parentesi graffa aperta, proprio come abbiamo fatto con principale,
significa che siamo ora cominciando a definire
ciò che accade dentro la scatola nera che abbiamo deciso di chiamare mult due reali.
Ecco un modo per la sua attuazione.
Potremmo dire, potremmo dichiarare una nuova variabile di tipo float chiamata di prodotto
e assegnare tale variabile al valore x volte a.
E poi restituire il prodotto.
Cosa vuol dire ritorno qui.
Beh ritorno è il modo Vi segnaliamo che è come
stiamo passando l'uscita sul retro.
Così restituire qualcosa, è lo stesso, questo è l'uscita della scatola nera.
Ecco come si fa.
Ecco un altro modo per la sua attuazione.
Potremmo tornare x volte a.
x è un galleggiante.
y è un float.
Quindi x y volte è anche un galleggiante.
Non abbiamo nemmeno bisogno di creare un'altra variabile.
Quindi questo è un modo diverso di implementare esattamente la stessa scatola nera.
>> Ora prendete un momento, sospendere nuovamente il video,
e cercare di definire aggiungere due interi, che è l'altra funzione che
parlato un momento fa.
Anche in questo caso, ho messo la funzione dichiarazione, e così il punto e virgola,
e una parentesi graffa aperta e un riccio chiuso
tutore per indicare dove riempiremo nei contenuti di aggiungere due interi,
così che definiamo particolare comportamento all'interno della scatola nera.
Quindi mettere in pausa il video.
E prendere tutto il tempo è necessario cercare di definire
un'implementazione di aggiungere due interi, come ad che quando la funzione genera un valore,
lo fa, infatti, il ritorno la somma dei due ingressi.
Così, proprio come nell'esempio precedente, ci sono diversi modi
che si potrebbe implementare aggiungere due int.
Eccone uno.
Qui in arancione ho solo avuto qualche comments--
Ho appena aggiunto un po ' commenti per indicare
cosa sta succedendo su ogni riga di codice.
Quindi dichiaro una variabile chiamato somma di tipo int.
Dico somma è uguale a più b.
Ecco dove stiamo effettivamente facendo il lavoro aggiungendo un insieme e b.
E torno somma.
E questo ha un senso perché somma è una variabile di tipo int.
E qual è il tipo di dati che questo Funzione mi dice che sta andando a uscita?
Int.
Così sto tornando somma, è una variabile intera.
E questo ha un senso dato quello che abbiamo dichiarato e definito la nostra funzione
da fare.
>> Ora è anche possibile definire la funzione in questo modo,
int somma risulti un plus b-- ignorare che prima step-- e poi, tornare somma.
Ora si potrebbe avere anche implementato in questo modo,
che vi consiglio non consiglio.
Questo è un male per uno stile cosa e davvero cattiva progettazione,
ma, di fatto, il lavoro.
Se si prende questo codice, che è di tipo int aggiungere male vipera punto c, e usarlo.
In realtà fa aggiungere due interi insieme.
E 'una molto scarsa attuazione di questo particolare comportamento.
Ma non funziona.
E 'qui solo per illustrare al punto che non lo facciamo davvero
importa ciò che accade all'interno la scatola nera, il tempo
in quanto ha l'output che ci aspettiamo.
Si tratta di una scatola nera mal progettato.
Ma alla fine della giornata, lo fa uscita ancora la somma di a più b.
Tutto ok.
Così abbiamo funzioni dichiarate.
E abbiamo funzione di definito.
Ecco, questo è veramente buono.
Ora cominciamo a utilizzare le funzioni che abbiamo dichiarato e abbiamo definito.
Per chiamare un function-- in realtà piuttosto easy-- tutto quello che dovete fare
è passarlo argomenti appropriati, argomenti del tipo di dati
che si aspetta, e quindi assegnare il ritorno
valore di tale funzione Questa poi scusa me--
assegnare il valore di ritorno di quella funzione a qualcosa del tipo corretto.
>> Quindi cerchiamo di avere uno sguardo a in pratica in un file
chiamato vipera 1 punto c, che Ho in CS50 IDE.
Così qui è vipera 1 punto c.
All'inizio vedete che io ho il mio include, libbra comprendono,
IO standard, e CS50 puntino h.
E poi io ho la mia dichiarazione di funzione.
Questo è dove sono dice al compilatore sono
intenzione di scrivere un funzione chiamata aggiungere due int.
Sta andando a emettere un variabile di tipo integer.
Questo è ciò che questa parte è proprio qui.
E poi ho due ingressi di un e b, ciascuno dei quali è un numero intero.
All'interno di principale, chiedo l'utente per Ingresso dicendo, dammi un numero intero.
E sono chiesto di dimenticare int, che è una funzione che
è incluso nella libreria CS50.
E che viene memorizzato in x, una variabile intera.
>> Poi li abbiamo richiesta di un altro intero.
Otteniamo un altro intero e memorizzare che in y.
E poi, qui sulla linea 28, è dove facciamo la nostra chiamata di funzione.
Stiamo dicendo, pari z int aggiungere 2 int x virgola y.
Capite perché questo ha un senso?
x è una variabile di tipo intero e y è una variabile di tipo integer.
Quindi, questo è un bene.
Che senso ha con ciò che la nostra funzione Dichiarazione sulla linea 17 assomiglia.
La lista di input separati da virgole prevede due interi, a e b.
In questo caso, possiamo chiamare loro tutto ciò che vogliamo.
Si aspetta solo due interi.
E X è un numero intero e y è un numero intero.
Che funzioni.
>> E sappiamo che la funzione sta andando all'uscita un interi pure.
E così abbiamo memorizzato la uscita della funzione,
aggiungere due interi, in un tipo intero variabile, che noi stiamo chiamando z.
E allora possiamo dire, la somma di cento per cento ie i è cento i.
rispettivamente x, yez compilando quelli per cento i di.
Qual è la definizione di aggiungono due interi assomigliano?
E 'piuttosto semplice.
E 'uno di quelli che abbiamo appena visto un secondo fa,
int somma risulti una somma più b ritorno.
funziona?
Salviamo il file.
E poi qui sul mio terminale Io vado a fare vipera 1,
e a cancellare il mio schermo.
Io vado per ingrandire perché so è un po 'difficile da vedere.
>> Quindi si compila questo programma come vipera 1.
Così possiamo fare puntino barra vipera 1.
Dammi un numero intero, 10.
Dammi un altro intero, 20.
La somma di 10 e 20 è 30.
Così abbiamo fatto una chiamata di funzione di successo.
È possibile eseguire la funzione di nuovo, negativo 10, 17 somma di negativo 10 e 17 è 7.
Questa funzione è attiva.
Ha il comportamento che ci aspettiamo che.
E così abbiamo fatto un successo la funzione, la definizione, la dichiarazione,
e una chiamata di funzione di successo.
Coppia varie punti sulle funzioni
prima di concludere questa sezione.
Ricordiamo dal nostro discussione di tipi di dati,
precedenza, che funziona a volte può prendere nessun ingresso.
Se questo è il caso, dichiarare la funzione
come avere una lista di argomenti vuoto.
Ti ricordi quello che il più funzione comune
abbiamo visto finora che prende un elenco di argomenti vuoto è?
E 'principale.
Ricordiamo inoltre che la funzione a volte in realtà non dispone di un'uscita.
In quel caso, dichiariamo la funzione come avere un tipo restituito nulla.
Concludiamo questa sezione affrontare un problema pratica.
>> Quindi, ecco il problema definito.
Voglio che scrive una funzione chiamato triangolo valida.
Ciò che questa funzione dovrebbe fare è prendere tre numeri reali
che rappresentano le lunghezze dei tre lati di un triangolo come i suoi parametri,
o dei suoi argomenti, o la sua inputs-- un'altra serie di sinonimi
che si potrebbero incontrare.
Questa funzione dovrebbe sia uscita vero o falso
a seconda che questi tre lunghezze sono in grado di fare un triangolo.
Vi ricordate il tipo di dati che abbiamo usato per indicare vero o falso?
Ora come si fa a implementare questo?
Beh so che ci sono un paio di norme in materia di triangoli
che sono in realtà utile conoscere.
Un triangolo può avere solo lati con lunghezza positiva.
Ciò ha senso.
Probabilmente stai dicendo, duh.
L'altra cosa da notare però, è che la somma
delle lunghezze di qualsiasi due lati del triangolo
deve essere maggiore del lunghezza del terzo lato.
Che in realtà è vero.
Non si può avere un triangolo di lati 1, 2 e 4, per esempio, perché 1 più 2
non è superiore a 4.
Così quelli sono le regole che determinare se i tre
ingressi possono concepibilmente formare un triangolo.
Quindi prendere un paio di minuti e dichiarare e quindi definire
questa funzione chiamata valida triangolo, tale che effettivamente
ha il comportamento specificato.
>> Il risultato sarà vero se quei tre lati sono in grado di comprendere un triangolo,
e false altrimenti Pronti a vedere come hai fatto?
Ecco una implementazione triangolo valida.
Non è l'unico.
Distinti potrebbe variare leggermente.
Ma di questo, infatti, hanno il comportamento che ci aspettiamo.
Dichiariamo la nostra funzione in molto alto, bool triangolo valido
float x float y galleggiante z.
Quindi, di nuovo, questa funzione prende tre numeri reali
come i suoi argomenti, galleggiante variabili valore punto,
ed emetterà un vero o falso valore, che è un valore booleano, richiamo.
Ecco, questo è il motivo per cui il tipo di ritorno è bool.
Poi definiamo la funzione.
La prima cosa che facciamo è controllare che che tutti i lati sono positivi.
Se x è minore o uguale a 0, o se y è uguale a 0,
o se z è minore o uguale a 0, che non può eventualmente essere un triangolo.
Non hanno lati positivi.
E così possiamo tornare falso in questa situazione.
Avanti, controlliamo per essere sicuri che ogni coppia di ingressi
è maggiore rispetto alla terza.
>> Quindi, se x + y è meno o uguale a z,
o se x + z è meno o uguale a y,
o se y + z è minore o uguale a x, che, inoltre, non può essere un triangolo valida.
Così torniamo di nuovo falso.
Supponendo che abbiamo superato entrambi i controlli anche se, allora possiamo tornare vero.
Perché quei tre lati sono in grado di returning--
creazione di un triangolo valida.
E questo è tutto.
Avete ora dichiarata e definita.
E si può essere in grado di ora usare e chiamare questa funzione.
Ottimo lavoro.
Sono Doug Lloyd.
Questo è CS50.