Ciao e bentornato.
In questa conferenza, voglio andare attraverso una dimostrazione
della soluzione della nostra precedente sfida che era quello di
creare alcune funzioni, principalmente la funzione GCD e un file funzione coppia, funzione valore assoluto e
una funzione radice quadrata.
Creerò un progetto e Probabilmente nominerò
solo le funzioni del progetto, vado per chiudere il mio progetto esistente qui.
Diventerà un altro applicazione console.
Non siamo davvero riusciti in librerie o qualsiasi tipo di
programmazione grafica.
Questo sarà come solo su alcune funzioni.
Di solito, vuoi avere un file buon nome lì, ma questo è
solo per scopi di apprendimento.
Quindi siamo un po 'giusti fornendo funzioni generiche.
Se fosse un programma GCD, lo farei scrivi il massimo comune divisore.
Ma la prima cosa che faremo stiamo per implementare il nostro
più grande programma di divisione comune.
Questa sarà una funzione che trova il massimo comune divisore tra
due interi non negativi valori e quindi restituisce i risultati.
Dovremmo fornire la funzione prototipi così che possiamo chiamarli e
possiamo posizionare in qualsiasi punto della funzione.
Quindi facciamolo.
Per la prima funzione, questa è una dichiarazione di funzione.
Perché creiamo una funzione dichiarazione, in
modo che possiamo invocarlo ovunque nel programma.
Non dobbiamo in realtà implementare questa
funzione sopra la funzione principale quando la chiamiamo.
Ed è solo una buona pratica, lo è molto facile da vedere in modo
chiaro cosa sta succedendo nel programma con tutti i file dichiarazioni di funzione in alto.
Questo restituirà un int.
Quindi ricorda, la prima intestazione della funzione quello che devi fare è specificare il tipo di dati
che verranno restituiti.
GCD restituirà un int.
Quindi chiamerà la funzione che è GCD.
E poi dentro le parentesi ci sono dati che vengono passati a GCD.
E questo succederà essere anche int.
Passeremo due elementi di dati.
Quindi li separiamo con virgole.
Specifichiamo il tipo di dati per ciascuno e il nome della variabile.
Sto solo per dire in ue v.
E poi ho il punto e virgola a terminare la definizione della funzione.
Ora posso definire la mia funzione di seguito il principale e posso ancora
invocarlo e non avere problemi.
Quindi ora quando vuoi davvero definire
la funzione implementarla, si esegue la stessa funzione header int valore restituito GCD.
Deve corrispondere al file dichiarazione in termini di tipi.
Potresti chiamarlo qualcos'altro come int x per i nomi, ma
saremo coerenti.
Diremo solo int v.
Sappiamo che è la funzione definizione perché ci sono
parentesi che definiscono il corpo.
Questo è il codice di implementazione.
L'attuale algoritmo per il GCD è abbastanza semplice.
Tutto quello che devi fare è scrivere un ciclo e segui il ciclo e guarda
i valori temporanei basati sui resti.
Quindi creerò un locale variabile all'interno della mia funzione GCD.
Come sappiamo che è locale perché è all'interno delle parentesi per 12-14.
Questa variabile non è accessibile all'interno della funzione principale.
È solo locale per questo blocco.
Qui sto solo andando chiama temp poiché è locale.
Adesso creerò anche il mio loop.
Userò un ciclo while.
E il mio ciclo while sta solo andando andare fino a v, che sarebbe il nostro
più grande divisore comune.
Ricorda, il più grande comune divisor accetta due parametri.
Ci vorrebbe un parametro.
E in base a entrambi questi parametri, ha un algoritmo da creare per
trovare il massimo comune divisore.
Quindi, se stiamo cercando di trovare il
divisore, dobbiamo assicurarci che v non sia uguale a zero, il nostro secondo parametro.
Questo è solo standard parti dell'algoritmo.
Mentre la v non è uguale a zero, metteremo le
parentesi per il ciclo.
Quello che faremo è lo siamo andando prima
ad assegnare la temp al valore dei moduli di u mod v.
Quindi ti imposteremo uguale a v, e imposteremo v
uguale a temp.
E poi vogliamo tornare dati da questa funzione.
Quindi come restituiamo i dati da una funzione? usiamo la parola
chiave return e restituiamo solo il dati che vogliamo restituire.
In questo caso, vogliamo restituire u.
Ora ricorda che se questa funzione non ha restituito alcun dato, avremmo
dovuto cambiare il tipo in void.
E poi potremmo semplicemente avere un ritorno senza dati.
Ma questo sta restituendo dati.
Quindi dobbiamo corrispondere.
Ed eccoci qui dì di nuovo ritorno u.
Anche se non stessimo passando i dati a questa
funzione, potremmo mettere void come parametri oppure potremmo tienili vuoti e questo direbbe
che la funzione non accetta dati, ma stiamo passando due variabili.
E queste variabili u e v lo sono variabili locali alla funzione GCD.
Possiamo usarli all'interno della funzione.
Ed è quello che stiamo facendo.
Questi sono tutti i tratti di una funzione.
Il valore di ritorno, i dati che stai passando, usando le
variabili locali e poi restituendo i dati.
Tutte queste cose prestano attenzione in la sintassi con le parentesi e poi anche
con la dichiarazione in alto.
Ora vogliamo provare a testare questa funzione.
Quindi vogliamo testarlo per tutti tipi di cose diverse.
Andiamo avanti e ricordiamolo questo restituisce dati quindi probabilmente vogliamo creare una variabile
locale in il nostro principale, lo chiameremo semplicemente risultato.
Possiamo inizializzarlo a zero.
E poi lo vogliamo fondamentalmente chiama la funzione.
Come si invoca una funzione?
Specifichiamo solo la funzione nome seguito dai dati che gli
vengono passati.
Perché questa funzione restituisce data, dirò risultato uguale a e
poi il nome della funzione.
Il nome della funzione è GCD.
E lo supererò 150 per il mio primo test e 35.
Farò altri due test passare solo numeri diversi, ma quello che voglio fare è
che voglio per stampare i dati che vengono
restituiti il risultato.
Quindi dirò printf, e lo sono dirò che il GCD di 150 e 35 è un avanzamento
riga percentuale e quindi il risultato.
Destra. Quindi la riga 10 è importante.
Stiamo recuperando i dati da GCD, quindi lo stiamo assegnando a una variabile.
E possiamo chiamare la funzione che passa in due costanti qui, 150 e 35.
Potremmo anche passare variabili.
Il modo in cui invochiamo la funzione con i dati passati ad esso
è all'interno delle parentesi, inseriamo i valori separati da virgole e quindi il punto e
virgola è alla fine lì.
Voglio fare più test.
Quindi copierò le righe 10 e 11 e inserisci solo altri dati.
Metterò 1026 e 405 e poi anche 83.
E in realtà quello che potremmo fare è invece di restituire
la variabile, potremmo effettivamente metterla semplicemente come chiama la
funzione all'interno di printf e stampala proprio lì, non dobbiamo nemmeno salvarlo.
Quindi potremmo semplicemente dire GCD 83, 240.
Dovremmo cambiare cosa stiamo
stampando in termini di valori hard-coded qui, diciamo 1026, 405 e poi anche 240 e 83.
Quindi andiamo avanti e compiliamolo.
Assicuriamoci di ottenere nessun errore o avvertenza.
Non abbiamo errori e avvisi.
Quindi eseguiamolo.
Quando lo eseguiamo, dovremmo vedere il massimo comune divisore
tre volte per determinati numeri.
Quindi vediamo il GCD di 150 e 35 è 5.
Il GCD di 1026 e 405 è 27.
E il GCD di 83 e 240 è 1.
Il massimo comune divisore significa fattori che entrano in quei due numeri,
qual è il fattore più alto.
Quindi 5 va in 35, e 5 va in 150.
E questo è il più alto.
27 va anche in 405 e 1026, ecco il più alto tra i due.
Quindi sembra che funzioni.
E abbiamo coperto le basi di passaggio di dati e restituzione di dati.
Ora vogliamo esercitarci in un paio altre cose in termini di
algoritmi e risoluzione dei problemi.
Creiamo un'altra funzione chiamato valore assoluto.
La funzione valore assoluto sta andando per restituire un galleggiante e prendere un galleggiante.
Sarà un file funzione molto semplice.
Quindi dichiareremo la funzione sulla riga cinque.
Diremo float assoluto valore, questo è un nome seguito dai parametri, e siamo solo diremo
float x, e poi finiremo con un
punto e virgola.
Di nuovo, nota la funzione dichiarazione, il valore di ritorno,
i parametri specificano con i tipi di dati e poi il nome della funzione.
Possiamo quindi andare avanti e definire questa funzione sotto la
funzione GCD e sarà molto semplice.
Definiamo la funzione con il tipo che verrà restituito, il nome e
quindi il parametro, proprio come il file dichiarazione tranne che ora abbiamo le parentesi
per iniziare il blocco di codice.
Questo è facile perché tutto ciò che dobbiamo fare è controllare il parametro che
sta passando e controllare se è minore di zero.
Se è minore di zero, allora gli assegneremo solo
l'inverso che sarebbe una x meno.
Quindi, se è un valore negativo, moltiplicherà per
un meno restituirà un positivo.
E vogliamo restituire quei dati.
Quindi diremo return x.
Ora una cosa che ho menzionato nel file
lezioni di cui non sono riuscito a fornire un esempio erano cosa se restituisci i dati dappertutto.
Perché potremmo averne un mucchio if, e potremmo tornare in ogni
istruzione if.
E così la tua funzione può, in teoria, avere molte dichiarazioni di ritorno se sono
all'interno di if o loop.
E poi potresti averne uno in fondo.
Il problema con questo è è davvero difficile da seguire.
Se hai bisogno di un reso diverso parti del codice, fondamentalmente, memorizzano semplicemente i
dati in una variabile e rimetterlo in fondo.
Ma qui questa è una semplice funzione.
Stiamo solo restituendo un valore.
Andiamo avanti e proviamo a usare questa funzione ed è davvero bello che
ci vogliono float così possiamo usalo con numeri interi e float.
Quindi creerò un paio di variabili qui
che passeremo.
E vado anche io per creare un numero intero.
Lo farò nella parte superiore del mio principale.
Vado a creare un galleggiante per F1 F2 F3.
E creerò un numero intero I1.
E ne creerò un altro variabile che memorizza il risultato ma deve
essere un float.
Quindi dovrò creare
un'altra variabile e questo
dirà solo risultato in valore assoluto, e lo inizializzerò a
0. 0.
Ora invoco il file funzione e stampare i risultati.
Quindi copierò e incolla del codice qui.
Posso richiamare la funzione e memorizzare i dati che vengono restituiti o posso
semplicemente passarli alla funzione printf.
Probabilmente voglio fare alcuni commenti qui testando
la funzione del valore assoluto.
E quando usi gli asterischi su un singolo linea, lo evidenzia un po '.
Quindi qui ho incollato solo un mucchio di chiamate all'assoluto funzione valore e quindi visualizzato alcuni risultati.
Quindi qui tra 24, chiamo valore assoluto con f1.
Ricorda, f1 è un float.
È uguale a negativo 15. 5.
Formatterò il file risultato e stampalo.
E poi lo sono anche io andando a stampare f1.
Quindi vedremo se il file il risultato
cambia chiamando la funzione rispetto all'originale.
Quindi vado a stampare il risultato della chiamata alla funzione,
quindi il valore originale.
Questo ci dirà se è cambiato del tutto.
Se originariamente era negativo e cambiato in positivo.
Farlo su più linee per più test.
E poi nella riga 37, l'unica la
differenza qui è che invece di memorizzare il valore in una variabile, Lo stamperò solo.
Quindi devo cambiare i risultati qui alla variabile di destra.
Quindi facciamolo e.
Quindi quaggiù, voglio farlo.
Quando ho scritto originariamente il file programma, li ho scritti separatamente.
Quindi, si spera, non faccio errori qui.
E cambia tutti quelli di cui ho bisogno cambiare e questo dovrebbe farlo.
Gli altri in realtà non lo sono stampando i risultati di
tutte le variabili, solo quelle della riga 26.
Altrimenti, siamo solo mostrando i risultati.
Il primo lo mostra solo è che è cambiato perché
f1 è un valore negativo.
Bene, costruiamolo.
Non abbiamo errori o avvisi.
L'output che vogliamo prestare attenzione è solo
l'output di valore assoluto.
Quindi potrebbe essere meglio effettivamente aggiungere alcuni avanzamenti di riga.
Dopo aver mostrato il nostro ultimo, aggiungiamo un paio di feed di riga.
Più facile da leggere ed eseguire questo.
Quindi ora vediamo che il risultato è 15. 5.
Quindi in realtà l'ha cambiato da negativo a positivo perché f1
era originariamente 15. 5.
E tutti gli altri risultati sono anche valori positivi.
L'ultima dichiarazione di stampa non è stata stampata il risultato, ha appena
stampato il valore restituito dalla funzione.
Sembra che stia funzionando.
L'ultima funzione che volevo definire era una funzione di radice quadrata.
Questa sarebbe una funzione che calcola la radice quadrata di un numero.
E se è un argomento negativo superato, verrà visualizzato un messaggio
e verrà restituito 1 negativo.
Quindi definiamo la dichiarazione di questa funzione come radice quadrata
float e prende un float con qualsiasi nome.
E la radice quadrata sta effettivamente andando per utilizzare la funzione valore assoluto.
Quindi possiamo definirlo sopra e ancora lo usi a causa
della dichiarazione di funzione.
Quindi definiamolo, e ci vuole un galleggiante.
Quindi stiamo diventando abbastanza utili in definizione di queste funzioni, tipo di dati
per i parametri di ritorno, parentesi.
Creeremo una coppia variabili locali qui.
Questi possono solo essere si accede all'interno del blocco.
Questo ti aiuterà con il nostro algoritmo di radice quadrata.
Noterai qui alle righe 59, Ho creato una variabile costante.
Non ne abbiamo parlato ma questo è solo un modo per creare
una costante invece di usare una definizione.
Abbiamo creato una variabile float denominata epsilon, è. 001, aiuta con il nostro calcolo
della radice quadrata da fare certo che rientri in un determinato intervallo.
Abbiamo un'ipotesi che è 1. 1 e una dichiarazione di valore assoluto qui.
In realtà non abbiamo bisogno di fornire la dichiarazione perché l'abbiamo
definita in alto, quindi posso sbarazzarmene.
Ora ricorda che dobbiamo farlo controllare i parametri, vogliamo fare la
convalida dei parametri.
Se il parametro è minore
di zero, vogliamo stampare un commento e restituire un valore negativo.
Quindi, se x è minore di zero, stampa restituisce un argomento negativo alla radice quadrata
e restituisce uno negativo.
Ecco dove avremo più valori di ritorno
e ti mostrerò come puoi tornare una volta e mettilo in fondo.
Altrimenti, abbiamo il nostro algoritmo per radice quadrata.
Non ho intenzione di spiegare il file algoritmo perché non è pertinente a
ciò che stiamo imparando.
Ma fondamentalmente, per trovare la piazza radice di un numero, ne otteniamo
il valore assoluto moltiplicandolo e poi meno nella x.
Quindi l'ipotesi è che indovineremo.
Quindi originariamente indovineremo e quindi controlla se questo
è l'algoritmo, controlla se rientra in un certo intervallo.
E se lo è, allora andremo per impostare la nostra ipotesi su qualcosa e dividerla per due
e il gioco è fatto per essere l'ipotesi che torniamo.
Quindi in fondo, noi direi indovina di ritorno.
E quindi stiamo usando il funzione valore assoluto.
È definito sotto di noi, ma abbiamo la nostra dichiarazione in
alto, quindi va bene.
Una cosa qui è che abbiamo più dichiarazioni di ritorno.
Questo è perfettamente legale, ma dovrebbe essere evitato perché è più
difficile capire cosa sta succedendo.
Quindi quello che farei qui è lo farei probabilmente memorizzare questo negativo in una
variabile diversa da guess, ma vediamo qui come possiamo farlo.
Quindi quello che farei è indovinare è inizializzato a 1. 0 e ne stiamo restituendo
uno negativo.
Probabilmente ne creerei un altro variabile chiamata float valore di ritorno.
Possiamo impostarlo a 0. 0.
E poi prima di restituirlo qui perché
questo sta saltando fuori dalla funzione matematica, posso semplicemente diciamo che il valore di ritorno è
uguale a negativo 1. 0 invece di avere il ritorno.
Allora posso controllare e posso dire se il valore restituito non è uguale
a 1 negativo. 0 perché non lo faccio
voglio eseguirlo se ho già il mio numero non valido, numero non valido e potrei racchiuderlo in
un'istruzione if.
E poi all'interno dell'istruzione while, Posso dire che il valore di ritorno è uguale a indovinare.
In questo modo restituisco il corretto cosa se fosse una voce valida.
E poi invece di tornare indovina quello che faccio è
restituire il valore di ritorno.
E questo codice è un po 'più pulito perché
ritorna solo una volta in fondo ed è più facile da seguire.
Quindi il valore restituito è negativo uno se è un argomento non valido o sarà
il quadrato effettivo root se non è un argomento non valido.
E potremmo anche fare questo semplice semplicemente non controllando nemmeno il
valore restituito qui sarebbe probabilmente più facile
dire altro e creare il file altro fa parte dell'originale se.
Quindi se è un numero positivo quello lo renderebbe anche più pulito in quel modo
in cui non hai quell'istruzione if.
Ora dobbiamo testarlo.
Andiamo avanti e proviamo questo.
Chiameremo semplicemente il file funzionare un sacco di volte.
Diremo testare la radice quadrata.
Non ne farò nessuno stampa fantasia qui.
Mi assicurerò solo che io può aggiungere un mucchio di avanzamenti di riga in modo
che sia più facile da leggere.
Premi il pulsante di inserimento lì.
Bene. Quindi ora ne farò solo un po '
printfs dove invierò alcuni dati buoni e val e alcuni dati non validi e lo formatterò allo stesso modo.
Diciamo solo la prima chiamata sarà la radice quadrata di alcune buone radici
quadrate valide.
Bene, prima controlliamo con un numero negativo.
Quindi diremo solo negativo 3 che dovrebbe stampare un errore.
Altrimenti, lo testeremo con alcuni numeri validi.
Quindi diremo la radice quadrata di 16, e passeremo solo un int, verranno convertiti,
potrei ricevere alcuni avvisi.
Beh, non voglio averne avvisi e faremo 165.
Ora eseguiamolo e proviamolo.
Speriamo che venga compilato.
Ho un errore di ortografia con float.
Ora quando lo eseguo, si spera, otterremo un buon output di radice quadrata.
Quindi qui ne abbiamo uno negativo.
E abbiamo effettivamente stampato il negativo punteggio delle discussioni, quindi va bene.
E poi gli altri sono, io credi, le radici quadrate corrette.
Quindi sembra che il file la funzione funziona abbastanza bene.
Abbiamo ottenuto la radice quadrata di 16 che è 4, 25 che è 5, 9 che è
3, 165 è 12. 85.
Quindi ho fatto qualche errore di calcolo lì.
Stavo cercando di pensare 15 per 15 che è 225.
Quindi se inserisco 225 qui, lo farebbe torna come 15 come radice quadrata.
Fornirò questo codice sorgente per te
in modo da poterlo analizzare, ma capire le dichiarazioni di funzione,
capire come definire una funzione con il tipo restituito e
l'estensione parametri che trasmettono dati, capiscono variabili locali, capiscono come per tornare solo una volta in fondo.
L'algoritmo stesso non è così importante.
Spero che questo abbia aiutato. Grazie.