Ciao e Benvenuto.
In questa conferenza, voglio parlare sulla restituzione dei dati dalle funzioni.
Fino a questo punto, sappiamo cosa una funzione è sappiamo perché è utile,
sappiamo come definire funzioni noi sapere come passare i dati alle funzioni.
Ora vogliamo parlare di come noi può restituire dati da funzioni, il
che è anche molto utile.
Nel nostro esempio precedente, quando noi moltiplicare due numeri, una funzione di
moltiplicazione mostrava i risultati di il calcolo al terminale.
Ricorda, ce l'avevamo istruzione printf lì dentro.
Inoltre, abbiamo avuto un esempio in cui noi erano solo una semplice funzione in precedenza.
Abbiamo appena stampato i dati all'interno della funzione.
Volevamo essere gentili invece di portalo là perché in
realtà sta facendo più di una cosa.
In realtà l'ha stampato, il file i dati sono stati restituiti e
sono stati stampati i dati nella funzione principale.
Potresti non voler sempre avere il file risultati visualizzati nei calcoli.
La funzione diventa di più flessibile, più generico che a
sua volta ne consente l'utilizzo di più se puoi restituire i dati.
Quindi le funzioni possono restituire dati utilizzando la sintassi specifica in c.
Dovremmo avere familiarità con questo un po 'perché
ricorda la nostra funzione principale al molto alla fine stiamo restituendo dati
in molti esempi.
Quindi siamo stati un po 'esposti a questo.
Semplicemente non l'abbiamo davvero capito cosa significa.
Diamo un'altra occhiata al file forma generale di una funzione.
Ricorda, questa intestazione della funzione.
Abbiamo avuto un tipo di ritorno che era la parola che è stata definita per prima.
E poi abbiamo avuto il nome, e poi avevamo i parametri separati
da virgole tra parentesi.
Conosciamo già il file nome e parametri.
Quella prima cosa è il tipo di ritorno.
Il tipo restituito specifica il tipo di dati del valore
restituito dalla funzione.
Le funzioni possono restituire qualsiasi tipo di dati.
Devi solo far sapere al compilatore che tipo di dati stai restituendo se.
È un int, un float, un double qualunque cosa sia, devi specificarlo
nell'intestazione della funzione.
Il tipo restituito.
Il tipo di ritorno che abbiamo visto proprio qui, ed è possibile specificare quel tipo di valore che
deve essere restituito da una funzione fintanto che è un tipo legale in c.
Ho citato i principali, double, float e così via.
Ma puoi anche tornare enumerazioni e puntatori.
Non abbiamo discusso dei suggerimenti, ma rende molto, molto flessibile quando
puoi restituire i puntatori.
Il tipo restituito can anche essere evitare il tipo.
Vedi spesso questa parola chiave vuota.
Ora capiamo cosa significa.
Void significa che nessun dato sta per essere restituito.
Se vedi vuoto prima del file nome della funzione, non stai
restituendo alcun dato.
Se vedi vuoto all'interno dei parametri list, non stai passando alcun dato.
Void è solo una parola chiave generica che per i tipi restituiti e per i parametri, noterai anche che puoi
usare void anche come un puntatore, ma ci arriveremo
quando ci arriveremo.
Ma il vuoto è un modo per non dire nulla.
E il motivo per cui includi vuoto invece di non
includere nulla perché rende il programma più leggibile.
In realtà, quando passi i dati a un file funzione e
non hai dati che vengono passati, puoi avere si tratta solo di parentesi vuote.
È facile leggere se hai vuoto lì dentro.
Lo stesso con un tipo restituito tranne il tipo di ritorno che devi avere void.
Non puoi lasciarlo semplicemente vuoto.
Void significa che nessun dato lo è verrà restituito.
La dichiarazione di ritorno.
Abbiamo parlato di come puoi identificare quali dati verranno restituiti ma come
farlo effettivamente restituisci i dati.
All'interno del corpo della funzione, tu devi avere una dichiarazione in cui puoi
dire cosa stai per restituire.
Perché ricorda il corpo di un file può contenere molti dati.
Può avere variabili locali, sì hai qualcosa che sai che la
funzione potrebbe fare un calcolo specifico, magari facendo più calcoli, cosa
vuoi restituire.
Per fortuna c'è questa affermazione con la parola chiave return.
Se fornisci il reso senza nome di variabile dopo o espressione,
significa che sei solo uscendo dalla funzione.
È simile a un'interruzione in un ciclo.
Stai solo tornando dalla funzione.
E puoi fornire questo in funzioni definite come void.
Rende chiaro quando stai uscendo dalla funzione.
Dovresti davvero avere solo il ritorno in un punto in
fondo alla funzione.
Ci arriveremo più tardi, ma tu non può averlo da nessuna parte in una funzione.
Se lo vedi da qualche parte in una funzione, significa che stai saltando
fuori da quella funzione.
Il motivo per cui è bello avere in fondo è molto chiaro
quando esci dalla funzione.
Se hai più resi anche se stai restituendo dati in tutta la
tua funzione, è difficile da dire quando torni.
Quindi cosa mi piace fare nel mio file funzioni è creare variabili e tornare solo
una volta in fondo.
Se devo restituire qualcosa una funzione o intendo in una specifica istruzione if in una funzione o
qualcosa imposterò la variabile e poi la
restituirò in fondo.
Quindi se hai ritorno e tu non hai
nulla dopo, significa solo che stai uscendo da funzione senza dati restituiti.
Questo in realtà non è usato così tanto.
Lo usi solo nel vuoto funzione, non restituisce un valore.
La forma più generale di L'istruzione return restituisce
una variabile o un'espressione.
X più y o restituendo x.
Questa forma della dichiarazione di ritorno ha da utilizzare con il tipo restituito
specificato nell'intestazione della funzione.
Se stai restituendo un int, qualunque sia la variabile o l'espressione che stai
restituendo deve essere un int.
Deve valutare un int, se stai restituendo un int.
Ora se stai trasformando un doppio, deve valere il doppio.
Ricorda, puoi averne molti diversi tipi di dati restituiti.
Il valore restituito al programma chiamante è
il valore che risulta quando il l'espressione è valutata così.
Se hai x più y, sta tornando il risultato di tale espressione e deve essere
dello stesso tipo di dichiarazione di funzione come ho detto.
Una funzione che ha istruzioni nel corpo
della funzione ma non restituisce un valore deve avere l'estensione restituire il tipo come void, have to.
Non puoi non averlo.
Se non ce l'hai e lo sei non restituendo
alcun dato, riceverai un messaggio di errore.
Quando compili il programma e contiene una funzione con un tipo di ritorno void che
cerca di farlo restituisce un errore del compilatore di valori.
Void significa nessun dato di ritorno, no restituisce una variabile un'espressione.
Se una funzione non ha un vuoto tipo di ritorno
e ha un tipo di ritorno valido, otterrai un messaggio di errore se il
compilatore tenta di restituire un tipo diverso da a specificato o se sono appena
tornati da senza nulla dopo di esso.
Quindi fai attenzione a questo.
Quelle parole chiave all'inizio del le dichiarazioni funzionali sono importanti.
Influisce direttamente sull'implementazione della funzione e la compilazione ti dirà se sbagli e non restituisci i dati
corretti o se non ne restituisci nessuno
dati o se restituisci i dati quando non dovresti
restituire i dati.
Se l'espressione restituisce un valore è diverso un tipo
diverso dal tipo restituito nella funzione header, c proverà a convertirlo.
Il compilatore proverà per convertirlo se può.
Quindi, ad esempio, se stai tornando un float e la tua espressione è I più x con
due interi, sta andando per convertirlo semplicemente in un float.
Se stai restituendo un int e hai
un'espressione che sta eseguendo calcoli in virgola mobile lo convertirà in un it.
Perderai dati in questo caso, ma farà la conversione.
Non è sempre possibile per fare la conversione.
Nei casi in cui non è possibile, avrai un errore
prodotto dal compilatore.
Se stai cercando di restituire un int quando
dovresti restituire una stringa o quando stai provando per
restituirlo quando dovresti restituire un enum, è andando a lamentarsi del compilatore.
Puoi anche averne più di uno dichiarazione di ritorno una
funzione, l'ho menzionato brevemente e perché non vuoi farlo.
Ma puoi farcela.
Puoi avere più resi per tutta la funzione.
Rende solo il codice più difficile segui perché stai
saltando fuori dalla funzione dappertutto.
Quando torni e l'hai fatto più valori di ritorno,
assicurati di nuovo se hai una funzione sta
restituendo qualcosa, hai un'espressione o un valore di quel tipo o può essere convertito.
Ora che abbiamo parlato passando e restituendo dati, sappiamo
come invocare una funzione, ma voglio dire un
paio di altre cose sull'invocazione.
Chiami una funzione semplicemente usando il nome della funzione seguito dagli argomenti
passati che sono tra le parentesi, lo sappiamo, fino a
quel momento lo sappiamo ma io vuoi dichiararlo formalmente, è così che puoi
invocare una funzione.
Quando chiami la funzione, il file valori
degli argomenti specificati tra parentesi verranno assegnati ai parametri
all'interno della funzione.
I parametri sono rappresentativi variabili con un tipo di dati.
È quindi possibile utilizzare quella variabile qualsiasi lato nel corpo della funzione.
Quando la funzione termina o viene eseguita certo codice, utilizzerà quei valori forniti come argomenti,
come ho detto.
Gli argomenti che specifichi quando chiamare una funzione dovrebbe concordare nel
tipo numero e sequenza quando il parametri nell'intestazione della funzione.
Anche l'ordine è importante, non l'ho fatto enfatizzalo, ma se
dice int x doppio y, devi prima farlo passare nell'int poi il doppio.
Non puoi passare in double e int.
L'ordine è molto, molto specifico.
Quindi assicurati di passare i dati come un argomento quando
si richiama la funzione allo stesso modo della funzione è dichiarato nell'intestazione della funzione nell'elenco
dei parametri, passando il tipo giusto è anche quello.
Invocare una funzione e assegnando i dati restituiti.
Se una funzione restituisce dati, il file la funzione può assegnare quei dati semplicemente
usando l'operatore uguale e dopo anche il ritorno oppure puoi memorizzarlo in una variabile locale,
se lo desideri.
Funzionerà anche con un'espressione.
Quindi puoi dire return x plus y, puoi dire return x, puoi
dire return una costante.
Questo esempio qui è dopo di te richiamare la chiamata quando si desidera assegnare
i dati restituiti.
Quindi puoi dire che int x è uguale a mio chiamata di funzione, qualunque cosa restituisca
quella funzione verrà assegnata a x.
E se la mia chiamata di funzione ritorna x più y, il risultato di x più
y verrà assegnato a x.
Quindi puoi assegnare i dati che sono restituito da
una chiamata di funzione semplicemente avendo una variabile nel file lato sinistro
dell'uguale e l'invocazione della funzione sul file lato destro degli uguali.
La funzione chiamante non ha per riconoscere o elaborare il valore restituito
da una funzione chiamata.
Non hai bisogno di avere quell'incarico lì.
Se una funzione restituisce dati e non ti interessano quei dati, non devi
assolutamente avere gli uguali, puoi semplicemente invocare la funzione.
Non avrebbe davvero senso perché se restituisce dati
significa che probabilmente devi guardare ma non devi farlo.
Il compilatore non lo farà lamentarsi se si richiama solo
una funzione e non si gestiscono i dati.
Dipende da te come tu desidera utilizzare i dati restituiti
dalle chiamate di funzione.
Ecco un esempio di invocazione una funzione e restituisce anche dati da
una funzione.
In questo esempio, moltiplica due numeri.
Questo era proprio come l'esempio di noi aveva in precedenza, ma l'esempio
precedente non ha restituito alcun dato.
L'esempio precedente mostrava l'output.
In questo esempio, siamo non visualizza alcun output.
Stiamo restituendo i dati e quindi stiamo visualizzando
l'output nella funzione principale.
Qui il nostro moltiplicare due numeri accetta due numeri interi come parametri.
Moltiplichiamo questi due numeri interi.
E poi invece di stampare questo importo o il valore, stiamo utilizzando la parola
chiave return e siamo specificando una variabile denominata risultato e poi abbiamo il
punto e virgola per terminarla.
Quando vedi quella parola chiave di ritorno all'interno del corpo della funzione, stai
restituendo quei dati.
E ricorda, puoi hanno più posti.
Ma puoi solo fargliene restituire uno value, non puoi restituire più valori.
Quindi, se hai la parola chiave return in più posti, deve essere all'interno di
un'istruzione if o di un ciclo perché stai saltando fuori proprio allora.
Se hai un ritorno seguito da un altro ritorno, ti
darà un errore perché direbbe te avere due resi in entrambi i casi.
Stai sempre tornando a risultati, non puoi farlo.
Ma la parola chiave return è importante.
Stai restituendo una variabile.
E poi vedi nel principale funzione a cui vengono assegnati i
dati restituiti un'altra variabile locale chiamata risultato.
Noterai che stiamo usando gli stessi nomi qui.
Questo ha a che fare con la funzione ambito
di cui parleremo nella prossima conferenza, locale variabili contro variabili globali.
Tutto ciò che serve per prestare attenzione in questa lezione c'è il fatto
che questa funzione si è moltiplicata due numeri restituiscono dati.
Come lo restituisci, lo restituisci utilizzando la parola chiave
return seguita dalla variabile dell'espressione.
Noti anche che si moltiplicano due numeri specificano il tipo di ritorno nella
parte superiore dell'intestazione della funzione.
Restituisce un int.
Quindi dobbiamo restituire un int.
Lo noti anche quando assegniamo i dati nella funzione
principale, li stiamo assegnando in int.
Assegnando quelli molto facili noi basta avere l'operatore uguale.
Se non ci importava dei dati, noi potrebbe semplicemente chiamare moltiplicare
due numeri e poi non farci niente ma.
Dopo aver ricevuto i dati restituiti dalla funzione, lo stampiamo
quindi utilizzando una funzione printf.
Questo rende la funzione più coerente che richiede dati.
In realtà non stiamo mostrando i risultati all'interno della funzione.
Ci sono momenti in cui non vogliamo per
visualizzare i risultati, vogliamo solo moltiplicare due numeri e poi potremmo voler dividere il prodotto.
Flessibilità con il trasferimento dei dati e i dati restituiti sono un grosso problema.
Questo è un semplice esempio.
Ti esponi a questo più nella nostra prossima sfida.