DOUG LLOYD: Come si inizia lavorando con funzioni,
un'altra cosa sta per diventare davvero importante per capire,
che è il concetto di portata variabile.
Così ambito è un caratteristica di una variabile
che definisce da quali funzioni tale variabile è possibile accedere.
>> Ci sono due ambiti principali in C, variabili locali e variabili globali.
Ora, variabili locali non può che accessibile nell'ambito delle funzioni
in cui sono stati creati.
Essi non sono accessibili da tutti gli altri funzione che esiste nel vostro programma,
solo la funzione in quale è stato creato.
Le variabili globali, sulla D'altra parte, si può accedere
da qualsiasi funzione del programma.
E la ragione di ciò è perché non sono creati all'interno
di qualsiasi funzione particolare.
Noi li dichiariamo al di fuori di tutte le funzioni che
significa che ogni funzione sa dove è e può accedere e manipolare.
>> Finora nel corso hai abbastanza molto lavorato esclusivamente
con variabili locali.
Ecco un esempio di un molto, molto semplice funzione principale e una molto semplice
funzione aggiuntiva che abbiamo scritto.
In questo caso, x, che Ho colorato verde solo
per evidenziare la località o la portata di tale variabile,
è locale per la triplice funzione.
principale non può riferirsi a x affatto.
Non sa cosa sia.
Nessun altra funzione, infatti, se aveva funzioni aggiuntive a qui,
potrebbe riferirsi a x.
>> Allo stesso modo, i risultati che ho di colore blu, è solo locale a principale.
Solo principale sa cosa il risultato variabile è.
tripla non può usarlo.
>> Ora, come ho già detto, esistono variabili globali.
Se si dichiara di variabile al di fuori di ogni funzione,
tutte le funzioni del programma può fare riferimento ad esso.
Quindi, in questo caso, ho evidenziato in verde una dichiarazione di variabile globale.
In questo caso, la essere variabile dichiarata
è chiamato globale, solo essere molto chiari su di esso.
È di tipo float.
E assegno che il valore 0,5050.
>> Noterete che nella principale e in triple, sono in grado di fare riferimento a globale.
E infatti, se vado attraverso il programma come indicato, principali primi inviti tripla,
moltiplica triple globali del 3, che imposta il suo valore a 1,5-qualcosa,
1.51 o qualcosa del genere, e allora principale stampa anche il valore
di globale.
Quindi principale non stamperà 0,5050 esso, stamperà out globali 3, 1.51.
Quindi hai avuto modo di stare attenti quando si sta lavorando con le variabili globali.
Mentre sono molto flessibili in essere in grado di trasmettere informazioni
intorno in modo che ogni funzione può usare,
può anche avere qualche conseguenze pericolose
se cambia una funzione il valore di una variabile
prima che ci si aspetta di essere cambiato.
>> Perché è importante questa distinzione?
Perché ci preoccupiamo se alcune variabili sono locali e altri sono globali?
Beh, per la maggior parte, le variabili locali in C sono quella che viene chiamata passato per valore
quando facciamo una chiamata di funzione.
Che cosa significa?
>> Beh, quando si passa una variabile per valore, il chiamato, che
è un altro modo di dire la funzione di che riceve la variabile che
viene passato come input, in realtà non riceve la variabile stessa.
Riceve proprio copia di esso per lavorare con.
Questa è una distinzione molto importante.
Abbiamo appena visto un secondo fa che con le variabili globali,
se manipoliamo la globale variabili in una funzione, l'effetto
in una funzione che svolge attraverso ogni altra funzione.
>> Ma con le variabili locali, non è vero.
Ogni funzione quando riceve variabili in ingresso
ricevere copie di tali variabili, non variabili stesse.
Allora, qual è l'effetto collaterale di questo?
Ciò significa che la variabile in il chiamante, la funzione che
è di effettuare la chiamata di funzione, è invariato a meno che non si sostituisce esso.
>> Ad esempio, in questo codice pippo non è cambiato affatto.
Int foo è uguale a 4, chiamare tripla di foo, all'interno di triple,
ci aspetteremmo che foo sarebbe moltiplicato per 3 e restituito,
ma c'è in realtà alcun effetto.
>> Qui, però, una differenza molto sottile.
Questo ha l'effetto che vogliamo.
Capite perché?
Stiamo sovrascrivendo foo in questo formato tempo.
>> Così int foo è uguale a 4, foo uguale foo tripla, quando facciamo la chiamata,
tripla ottiene la propria copia di foo, la propria copia di 4.
Dice ritorno 4 volte 3, o qualsiasi altra cosa variabile viene passato in tempi 3.
E poi si assegna il ritorno valore della tripla di foo di nuovo.
Quindi, questo in realtà sovrascriverà foo.
Questo è l'unico modo per farlo questo con variabile locale.
Così ora se si aggiunge un altro riga di codice qui
a fine principale stampare il valore di foo,
sarebbe infatti stampare 12.
>> Portata variabile è generalmente non troppo di un problema
se è il nome tutta la vostra variabili cose diverse.
Ma può ottenere tipo di brutto se lo stesso nome della variabile
appare in molteplici funzioni, che avverrà molto.
Se mai si lavora in il mondo reale, dove
si sta lavorando in collaborazione i programmi e le persone in diverse squadre
stanno lavorando insieme per scrivere la stessa programma o lo stesso insieme di programmi,
faranno spesso riutilizzo variabile nomi, in particolare quelle comuni
come x, y, i, j, e così via.
>> Ma quando variabili hanno lo stesso nome, le questioni di portata
può ottenere un po 'più difficile da analizzare.
Per esempio, sapete ciò sarebbe stampato
al termine di questo particolare programma?
Prendi un minuto.
Mettere in pausa il video e leggere attraverso questo programma.
Si può vedere in cima siamo avere una dichiarazione di funzione
per una funzione denominata incremento.
Tale funzione prende un singolo parametro, un numero intero che noi chiamiamo x.
Ed emette un numero intero.
Questo è il tipo di ritorno all'inizio.
>> Poi abbiamo principale, un paio di righe di codice principale, l'ultima delle quali
è una dichiarazione di stampa.
E ricordate, questa è la domanda qui.
Che cosa è in realtà sta per essere stampato al termine di questa funzione?
E poi in realtà abbiamo la definizione di incremento al di sotto.
>> Così ha un minuto, scorrere il codice, tracciare le cose.
Sapete che cosa verrà stampata a Alla fine di questo particolare programma?
>> Tutto ok.
Speriamo, hai preso un paio di secondi per cercare di analizzare questo fuori.
Facciamolo assieme.
>> Così ho attraversato fuori incremento del dichiarazione in alto là.
E 'stata una specie di distrazione.
Non è la sua variabile.
Non ha un proprio campo di applicazione.
E 'solo una funzione dichiarazione, quindi per fini
di cercare di analizzare che cosa è accadendo in questo programma,
potremmo anche semplicemente evitare.
>> Ora abbiamo in questo caso, la motivo questo problema è difficile
è perché abbiamo variabili locali in sia principale incremento, ciascuna delle quali
è chiamato x.
E, naturalmente, il nocciolo della questione è cercando di suss fuori che x viene cambiato
e come avere cambiato.
Così ho colorato ogni istanza di x che è locale al rosso principale.
E ho colorato ogni istanza di x che è locale per incrementare blu.
>> Avviso in quella terza linea di principale, y uguale incremento
x, che incremento non è essere passò x di principale, o la x rossa.
E 'sempre passato una copia di esso.
Ed è solo andare a lavorare con che copia di esso, il blu x.
Se siete matematicamente inclinato, si potrebbe
hanno invece pensato a questo come x sub m per il main e sub x i per incremento.
Ma è la stessa idea.
x sub m, o sulla X rossa del nella diapositiva precedente,
sono le variabili che sono local-- è l'istanza di x, piuttosto che
è locale principale, e x sub i, o il variabili blu nella diapositiva precedente,
sono le istanze di x che sono locali per incrementare.
>> Quindi, sono stati in grado di capire ciò che questa funzione stampata alla fine?
Sono Doug Lloyd, e questo è CS50.