Ciao e bentornato.
In questa conferenza, voglio parlare sulla definizione delle funzioni in c.
Definizione di una funzione.
Conosciamo l'importanza delle funzioni.
Comprendiamo i vantaggi.
Vorremo usare funzioni nei nostri programmi.
Quindi, quando crei una funzione professionale in c, devi specificare l'intestazione
della funzione come prima riga della definizione della funzione.
Parleremo della definizione una funzione e parleremo
anche dell'implementazione di una funzione.
Implementazione di una funzione è solo la risoluzione di problemi,
è solo un normale codice c.
Definire una funzione è dire che la funzione esiste.
Quindi, quando definisci una funzione, il file la prima cosa che fai
è avere quell'intestazione della funzione e poi segui quello con una parentesi graffa che avvia il codice
di blocco per la funzione.
Quindi è proprio come quando usi un file parentesi
graffa in un'istruzione if, proprio come quando usi una parentesi graffa in un ciclo for, ad eccezione della
parentesi graffa richiesta per le funzioni.
Non è possibile eliminarlo.
E significa sempre l'inizio del codice per quella funzione.
Qualunque cosa tra l'inizio e la parentesi graffa finale è il codice
per la funzione.
È dove stai andando per implementare l'attività.
Quindi tra le parentesi graffe c'è chiamato il corpo della funzione e la prima
riga della funzione si chiama intestazione della funzione.
L'intestazione della funzione definisce il nome della funzione, i
parametri della funzione.
Ne parleremo parametri e argomenti in dettaglio.
Ma adesso, basta ho bisogno di sapere che
c'è qualcosa chiamato parametri.
E il parametro specificherà il numero e il tipo di valori
come passare dati, parametri hanno a che fare con il passaggio di dati.
Il tipo per il valore che la funzione restituisce.
Abbiamo accennato a queste funzioni possiamo restituire i dati.
Quindi in quell'intestazione della funzione, avrai
il nome della funzione, i dati che si può prendere può essere accettato
dalla funzione e dai dati restituito dalla funzione.
Non ci concentreremo adesso sui dati che possono essere passati o sui dati
restituiti, ci limiteremo a parlare della creazione di una semplice funzione.
Il corpo della funzione contiene solo codice normale, e quel codice viene eseguito
quando tu chiamare o invocare la funzione.
E il corpo della funzione stesso avrà accesso a tutti i valori
passati come argomenti.
Quindi i dati a cui passi è possibile utilizzare quei dati
all'interno del corpo della funzione.
Quello che sembra è questo, l'intestazione della funzione.
L'intestazione della funzione ha la prima parola.
E l'intestazione della funzione è un file parola chiave che rappresenta il tipo
di dati che saranno restituito dalla funzione.
La prossima parola chiave c'è il nome della funzione.
E poi hai una parentesi sinistra e poi hai parametri separati da
virgole, che saranno i dati passato alla funzione.
E poi hai quello parentesi destra per
terminare l'intestazione della funzione.
Poi hai la parentesi graffa che indica l'inizio
dell'implementazione della funzione.
E hai un numero qualsiasi di dichiarazioni per svolgere un'attività.
Come ho detto, lo vuoi fai in modo che le tue funzioni siano piccole.
Vogliono essere coesi.
Non vogliono esserlo dappertutto.
Vogliono avere un singolo concentrati, fai qualcosa di specifico.
Come ho detto se hai una funzione che riceve l'input, legge l'input.
Non stampa l'output.
Non esegue alcun ordinamento o non fa nient'altro.
Se hai una funzione chiamata sort, ordina i dati.
Non riceve input.
Le funzioni devono essere coeso e piccolo.
È molto più facile eseguire il debug di quelli funzioni, quindi rendili coesi.
E poi hai quel diritto parentesi graffa, che
termina l'implementazione della funzione.
Questa è una funzione sembra in c.
Adesso concentriamoci sulla funzione nomi e parleremo dei parametri e
dei tipi restituiti in seguito.
Di nuovo la prima riga della funzione definizione dice al compilatore in ordine
da sinistra a destra tre cose sulla funzione, come ho detto.
Il tipo di valore ritorna, il nome della funzione e
quindi i dati necessari.
Questo è solo per riassumere, è importante.
Per quanto riguarda i nomi delle funzioni, vuoi per scegliere nomi di funzioni significativi.
È importante quanto scegliere nomi di variabili significativi.
Colpisce notevolmente il leggibilità del programma, quindi
non denominare le funzioni xo y.
Assegna un nome alla funzione basata su cosa farà.
Se sta aggiungendo due numeri, nominalo aggiungi.
Se sottrae due numeri, chiamalo sottrarre.
In questo esempio, ecco la nostra semplice funzione.
Non preoccuparti del vuoto preoccupati solo per il nome qui.
Abbiamo una funzione messaggio di stampa denominato.
E poi vediamo quella parentesi graffa
che significa l'inizio della funzione, e poi abbiamo qualche implementazione.
E questa implementazione non fa altro che
visualizzare una stringa, un testo.
E poi abbiamo quello parentesi graffa destra.
Quindi questa è una funzione molto semplice non fa molto, visualizza l'output.
In questo esempio per la stampa messaggio, la prima riga
del messaggio di stampa dice al compilatore che la funzione non restituisce alcun valore.
Questa è la parola chiave void.
Ancora una volta, non è necessario concentrarsi su quello, ma è quello che sta facendo.
Il prossimo è il nome.
E poi dopo il nome c'è argomenti, vengono chiamati parametri.
E usiamo di nuovo la parola chiave void se non stiamo trasmettendo alcun dato.
L'istruzione nella funzione il corpo può essere assente, ma le parentesi
graffe devono essere sempre presenti.
Quindi non devi averne effettivamente implementazione, ma devi avere le parentesi graffe
perché una funzione sia presente.
Se non ci sono dichiarazioni in il corpo di una funzione, il
tipo restituito deve essere nullo.
E ancora, ci concentreremo su questo più tardi e la funzione non farà
nulla perché non hai implementazione.
Se definisci una funzione con un corpo vuoto, può comunque essere utile
anche se lo è non realizzare nulla.
Di solito lo fai durante il fase di test di un programma molto ampio.
E cosa ti permette di fare è che puoi eseguire il programma
solo con determinate funzioni in realtà fare qualcosa, ti aiuta a testare
meglio, ti aiuta a isolare gli errori.
Potresti anche avere l'implementazione nel test nel corpo
della funzione ma commentalo.
E poi puoi farlo approccio divide et impera.
Mentre provi sempre di più e di più, puoi quindi iniziare a inserire
l'implementazione nei corpi delle funzioni.
È un passo dopo passo processo di lavoro.
Lavori costantemente in piccolo blocchi, aggiunta di codice, test di quel codice e quindi passaggio a quello
successivo step e quindi alla fine l'intera implementazione sarà
completata e verranno implementate tutte le funzioni.
Quindi c'è un caso d'uso per avere un corpo funzione
che non ha codice o commentato.
Funzioni di denominazione.
Il nome di una funzione può essere qualsiasi nome legale.
Proprio come quando sei nominando una variabile, non
è possibile utilizzare parole riservate.
Quindi queste sono parole chiave nel file linguaggio come invio raddoppia perché
rappresentano i tipi di dati.
Sizeof è un operatore.
Vuoi essere in grado usarlo per o se.
Potresti anche non averne due funzioni con lo stesso nome.
E anche questo è riferito come funzione di sovraccarico, una specie di.
Ma non puoi avere due funzioni con lo stesso nome, il sovraccarico non è
supportato in c.
Infine, puoi avere lo stesso nome come una funzione che si trova nella
funzione di libreria standard.
Tecnicamente, se non includi quella libreria include il file di intestazione, potresti essere in
grado di averlo.
Ma se mai volessi effettivamente usare quella funzione di libreria, il compilatore si
lamenterebbe e direbbe che hai due funzioni con lo stesso nome.
Quindi non nominare le tue funzioni come uguale alle funzioni di libreria standard.
Un nome legale è lo stesso di una variabile, una sequenza di
lettere e cifre per iniziare.
Il primo carattere deve essere una lettera e la lettera può essere un trattino basso.
Non puoi iniziare le funzioni con numeri o qualsiasi tipo di
carattere strano.
Il nome che scegli dovrebbe essere significativo e pertinente a ciò
che fa la funzione.
L'ho già detto, lo ripeto per enfasi, i nomi significativi
sono molto importanti.
Definirai spesso la funzione nomi e anche nomi di variabili che consistono
in più di una parola.
Quindi ora voglio parlare un po ' un po 'solo sullo stile di codifica.
Probabilmente l'hai notato quando l'ho fatto scritto il mio codice che uso camel case.
Ci sono tre modi diversi puoi scrivere i nomi delle
tue variabili e funzioni.
Puoi separare ciascuna delle parole in un nome di funzione
con un carattere sottolineato, è un approccio.
Puoi scrivere in maiuscolo la prima lettera di ogni parola oppure
puoi scrivere in maiuscolo le parole dopo la prima parola e avete ancora strimpellare insieme.
Ricorda, non puoi avere spazi in mezzo.
Questo è solo un approccio per denominazione perché è
importante che tu segua alcune convenzioni in modo che sia più facile da leggere.
Ho solo una lunga parola con cinque parole diverse.
Quindi, se avessi una funzione che dice verifica l'input valido, non vorresti
averli tutti in minuscolo.
Sarebbe davvero difficile da leggere e identificare dove erano le parole.
Quindi il caso del cammello è un modo per identificare dove sono le parole in
molte parole ed è facile da vedere cosa sta facendo quella funzione.
Un carattere di sottolineatura è un altro modo per separare le parole.
E capitalizzando la prima lettera di ogni parola è un altro modo per separare.
È importante essere in grado di farlo separare le parole in una funzione
per renderla più leggibile.
Di solito uso la custodia del cammello.
E quando usi uno di questi convenzioni, vuoi usarlo per
tutto, vuoi usare per denominare le variabili, si desidera utilizzarlo per
i nomi delle funzioni.
Di solito, segui semplicemente questo convenzione di codifica comune, rende le
cose più leggibili.
Prototipi di funzioni.
Abbiamo parlato della definizione di una funzione.
Che dire della dichiarazione di una funzione.
Potresti dire perché ne hai bisogno dichiarare una funzione, non la
dichiari quando la definisci.
Ma c'è anche un concetto di dichiarare una funzione.
Ed è necessario se vuoi per utilizzare la funzione prima che sia
implementata, prima che sia definita.
Quindi un prototipo di funzione è un file istruzione che definisce una funzione.
Dice essenzialmente al compilatore tutti i dettagli della funzione.
Ne definisce il nome, il tipo restituito e il tipo di ciascuno dei suoi parametri.
Quindi sembra un'intestazione di funzione.
Fornisce tutto l'esterno specifiche della funzione, principalmente
probabilmente hai anche sentito il termine firma, firma della
funzione ecco cos'è.
Sta specificando i dati restituiti, i dati necessari e
tutto ciò che riguarda la funzione stessa.
Vuoi scrivere un prototipo di funzione allo stesso modo in cui scrivi l'intestazione della
funzione, l'unica differenza è quella metti un punto e virgola alla fine.
E questo è giusto dichiarando la funzione.
Questo sta dicendo che la funzione esiste.
Un prototipo di funzione consente il compilatore per generare le istruzioni
appropriate a ciascuno punto in cui chiami la funzione.
Controlla anche che stai usando il file funzionare correttamente in ogni chiamata.
Il motivo per cui fornisci la funzione headers è così che puoi invocare la funzione senza
un avviso o un file dichiarazione di funzione senza che sia implementata, quindi è davvero solo l'ordine del
tuo codice e ti darò un esempio di
questo in un secondo.
Quando includi un'intestazione standard in un programma, il file di
intestazione aggiunge il prototipo della funzione.
I prototipi di funzione di solito entrano in gioco file di intestazione se si desidera riutilizzarli in
molti file di origine diversi.
Se li usi solo in un unico file file sorgente, puoi semplicemente
metterli in alto nel file sorgente.
Ma poiché stiamo usando il printf funzione che può essere utilizzata
in molti diversi file sorgente, quell'intestazione la funzione sarà definita nell'intestazione o
in quella dichiarazione di funzione sarà definito nell'intestazione.
E in questo caso, stdio. h.
Quindi di solito compaiono in file di origine se solo quel file di
origine utilizza quella funzione.
Altrimenti, li metti in un file file di intestazione se
vengono riutilizzati da molti file di origine.
Consente qualsiasi funzione in file per chiamare una qualsiasi di quelle
funzioni definite indipendentemente da dove hai posizionato l'implementazione.
Se metti l'implementazione di una funzione, dopo averla chiamata, c si
lamenterà e dirà che non lo sa.
Perché quando compili, stai compilando riga per riga.
Se inserisci la dichiarazione in in alto, quindi puoi invocare la
funzione prima che sia definita, prima che sia implementato.
I nomi dei parametri non devono essere necessariamente i lo stesso utilizzato nella definizione della funzione.
Puoi avere nomi diversi.
Quando dico nomi, quelli sono gli identificativi dei dati.
Puoi cambiare il nome del file parametri nel prototipo di funzione.
Devi ancora avere gli stessi dati tipi, ma puoi cambiare i nomi.
È sempre una buona pratica includi le dichiarazioni di
funzione per tutte le funzioni nel tuo file programma all'inizio del file.
Mantiene il tuo programma più coerente al progetto e impedisce che
si verifichino errori in qualsiasi fase se vuoi chiamare quella
funzione prima di implementarla.
Ecco un esempio di alcuni prototipi di funzioni.
Nella parte superiore del file file, abbiamo i nostri include.
E poi ne abbiamo alcuni funzioni che abbiamo dichiarato,
media, somma e ottieni dati.
Noti che sembra proprio come un'intestazione di funzione.
Ha il tipo di ritorno, ha i parametri che sono
definiti nella funzione, ma ha un punto e virgola alla fine.
Non c'è implementazione per queste funzioni.
Lo stai solo dicendo al compilatore questa è la funzione esiste ed
è così che è definita.
Ciò che questo ti permette di fare è adesso nella tua funzione principale,
potresti chiamare la media, potresti chiamare la somma, potresti chiamare per ottenere i dati.
E le implementazioni effettive possono essere al di sotto di dove li stai chiamando.
Se non hai la funzione intestazioni qui, quando
hai provato a chiamarli nel principale, se lo erano definito sotto la routine principale,
avresti errori o avvertenze.
Quindi diamo un'occhiata a quello in blocchi di codice.
Qui abbiamo la nostra solita routine principale.
Ora diciamo che vogliamo per creare una funzione o vogliamo invocare una
funzione.
Invocheremo un file funzione chiamata add e non
accetterà alcun parametro.
Lo chiamiamo nel nostro funzione principale in linea 7.
Stava andando a implementalo sulla riga 10.
Diremo void add and non faremo nemmeno niente.
Lo terremo vuoto.
Quando andiamo a compilare questo, cosa noterai che questo compilatore dà
solo un avvertimento.
Dice che add ha un'estensione dichiarazione implicita.
Puoi sbarazzarti di quell'avvertimento utilizzando una dichiarazione di funzione.
Puoi dichiarare la funzione in alto fondamentalmente dicendo al compilatore che stai andando usalo
da qualche parte, ma non sai
dove sia l'implementazione.
Quindi quello che puoi fare è che puoi dì void add proprio qui e
aggiungi semplicemente il punto e virgola.
Ora se ne sbarazzerà avviso e alcune compilazioni ti daranno effettivamente
un errore.
Ora, quando lo compilo, ce l'ho nessun avviso e nessun errore.
Quindi questa è una funzione dichiarazione fa.
Ti permette di mettere la funzione ovunque.
Ora se non hai la funzione dichiarazione in alto e avevi l'implementazione
sopra dove tu lo stavi chiamando, quindi anche tu non vedrai l'errore
perché il compilatore sta per conoscere la funzione prima di
tentare effettivamente di invocarla.
Quindi, se lo costruiamo, anche tu vedrò che non ci sono errori.
Ora ho detto che tu di solito voglio dichiarare tutte le
tue funzioni in alto solo per buona pratica e penso che tu abbia bisogno di farlo.
Quindi continua a farlo.
Ma se esci da quello abitudine, devi dichiarare le tue
funzioni prima di chiamarle oppure devi fornire
prototipi di funzioni perché non vuoi avvisi o errori nel programma.
Ecco come puoi definire un file funzione, ed è così che puoi
usare i prototipi di funzione.
Nella prossima lezione parleremo
dei parametri.
Come passare i dati a una funzione.
Grazie.