Ciao e Benvenuto. In questa conferenza, voglio parlare della dichiarazione di passaggio.
È un'alternativa a un'istruzione if,
ma di solito viene utilizzata solo in situazioni specifiche.
Ma ha una bella sintassi interessante per fare alcune ripetizioni nella tua istruzione if.
Quindi l'operatore condizionale e le istruzioni if than else
facilitano la scrittura di programmi che scelgono tra due alternative.
È molto facile fare domande e prendere decisioni.
Tuttavia, molte volte,
un programma deve scegliere una delle diverse alternative.
E questo sarebbe essenzialmente
il se altro se altro se altro se altro se.
È complicato perché puoi ovviamente implementarlo con l'istruzione if quando
hai diverse alternative, ma
potresti avere cento altri se. Quindi è noioso, è soggetto a errori ed
è davvero solo un dolore nel sedere. È come scrivere un mucchio di codice boilerplate.
Quindi l'alternativa a questa sintassi e tutto ciò che puoi
fare nello switch puoi fare in un if.
Ma è più pulito, più facile e anche molto più efficiente.
Quindi, quando il valore di una variabile viene confrontato correttamente con valori diversi,
utilizzare l'istruzione switch.
E cosa significa se hai un'istruzione if e poi hai un'altra if, else if, else if, else
if, else if, else if, usa l'istruzione switch.
Ora, se quelle espressioni booleane sono un po 'più complicate.
Non puoi usare un'istruzione switch. Puoi usare
un'istruzione switch solo quando confronti un valore, come una costante.
L'espressione non può essere così complicata.
Ma è molto più conveniente e molto efficiente usare l'istruzione switch, e anche la maggior
parte dei linguaggi ha questo costrutto. E vedi che è molto carino. L'unica cosa che
noti che molti linguaggi costruiranno in base a c.
Se hai programmato prima, vedrai
e avrai familiarità con molti di questi
costrutti perché originariamente erano usciti in c o be, la lingua precedente.
Quindi ecco la sintassi di un'istruzione switch. Hai la parola chiave switch.
E poi all'interno dell'interruttore, hai queste parentesi sinistra e
destra, che è l'espressione. Quindi sembra proprio come l'istruzione if all'inizio
tranne che al posto della parola chiave if, hai la parola chiave switch.
Hai quindi la parentesi quadra sinistra.
Le parentesi di sinistra obbligatorie. Quella parentesi quadra sinistra avvia il corpo dell'interruttore.
E vedi la parentesi destra finale in fondo, che termina il corpo dell'interruttore.
L'altra cosa importante qui è il caso di queste parole chiave.
Case è in realtà come
l'istruzione if stessa. Quindi switch
in realtà guarderà un'espressione, non
se sia necessariamente vera o falsa.
L'interruttore potrebbe essere solo guardando una variabile o qualcosa del genere.
E poi valuterà quella variabile nelle istruzioni case.
Quindi, se il valore 1 è uguale a espressione,
se il valore n è uguale a espressione.
Ma puoi vedere questo come
se l'interruttore fosse al livello più alto e quindi i casi ciascuno
fosse un'istruzione if, confrontando i valori con le espressioni nell'interruttore.
Quindi anche i casi sono parole chiave. Noti anche i due punti dopo il caso.
Quindi hai il caso e poi hai il tuo valore.
E poi lì dentro, puoi avere più istruzioni di programma.
E poi, alla fine, hai una parola chiave di interruzione. Questa è un'altra parola chiave. Quindi ci sono tre
parole chiave qui, in realtà quattro. C'è la parola chiave switch, la parola chiave case, la parola
chiave break e quindi l'impostazione predefinita in fondo.
Quindi queste sono le cose importanti da notare. Esamineremo un esempio
dettagliato, ma puoi avere casi diversi. E ancora, questo sta solo facendo come se altrimenti, se altrimenti, se altrimenti, altrimenti se.
Quindi, se il valore uno è uguale a espressione, eseguire il codice.
Altrimenti, se il valore due è uguale
a espressione, valutalo. Altrimenti, se il valore tre è uguale a espressione, valutalo.
Altrimenti, se il valore n è uguale a espressione, eseguire il codice all'interno di quel blocco.
E il blocco per i casi inizia con i due punti e termina con la pausa.
E se non hai quella pausa lì,
ricadrà negli altri casi. Ne parleremo di nuovo.
E poi l'ultima cosa importante qui è questa parola chiave predefinita. Questo è essenzialmente l'altro, altrimenti
se, altrimenti se, altrimenti se e poi altro in fondo.
Quindi questo viene impostato se nessuno degli altri casi valuta l'espressione.
Quindi parliamo di alcuni di quei dettagli che ho menzionato.
L'espressione racchiusa tra parentesi viene confrontata correttamente con i valori.
Quindi, di
nuovo, se torniamo alla sintassi, l'espressione viene confrontata con tutti i valori.
E se equivale a uno qualsiasi dei valori, esegui il codice all'interno di quel valore.
I casi devono essere semplici costanti o espressioni costanti,
espressioni che restituiscono una costante.
Quindi potresti attivare x più y perché
se x è 5, si accenderà semplicemente 10 e confronterebbe i valori con 10.
Ma di solito, attivi una variabile che è uguale a un qualche tipo di numero.
Se viene trovato un caso il cui valore è uguale al valore dell'espressione,
vengono eseguite le istruzioni che seguono il caso.
Quando sono incluse più affermazioni, non è necessario chiuderle tra parentesi graffe.
Quindi questo sta solo dicendo
che quando è inclusa più di un'istruzione, non
sono richieste parentesi graffe per le istruzioni case.
Ricorda, per l'istruzione if, dovremmo sempre avere quelle
parentesi graffe, non è così. Puoi semplicemente metterli una riga dopo l'altra, la chiave è la rottura lì.
L'istruzione break segnala la fine del caso
particolare e fa terminare l'esecuzione dell'istruzione,
salta fuori.
Se non hai la pausa lì, il caso successivo fallirà.
Quindi si desidera includere la fine dell'istruzione break di ogni caso. Quando non includi interruzioni, di solito significa che
c'è un bug o qualcosa del genere.
L'unico motivo per cui si desidera includere un'interruzione è se si dispone di
più condizioni per l'esecuzione del codice. Quindi, se avessi più casi,
fondamentalmente dicendo se l'espressione era questo
caso, questo caso o quel caso, allora fai
la stessa cosa,
quindi toglieresti le pause.
Quindi fai attenzione alle interruzioni perché le interruzioni possono causare problemi
indipendentemente dal fatto che determinati blocchi vengano eseguiti o meno nel caso successivo.
Il caso speciale opzionale chiamato predefinito viene eseguito se il valore
dell'espressione non corrisponde a nessuno dei casi. È lo stesso di una caduta, altrimenti accade
se nessuno dei casi è vero.
Quindi, ecco un bell'esempio in cui stiamo creando uno switch per valutare un'enumerazione.
In questo caso, abbiamo un tipo di enumerazione chiamato giorno della settimana, che
è appena specificato da tutti i giorni della settimana.
E poi abbiamo creato una variabile di tipo enum week-end e l'abbiamo impostata su Monday
e poi accendiamo oggi.
Quindi, a seconda del valore di oggi, la variabile,
verrà eseguita una delle istruzioni case.
Se oggi è uguale a domenica, verrà stampato oggi è
domenica e poi salterà fuori.
Se oggi è uguale a lunedì, verrà stampato oggi è lunedì e salterà fuori.
Se non è uguale a
nessuno di loro, andrà al caso predefinito. Quindi esaminiamo questo esempio in blocchi di codice.
Qui abbiamo il nostro codice di esempio. E lo vedrai perché oggi è
uguale a lunedì, il caso
lunedì verrà valutato e vedrai che l'output oggi è lunedì.
Quindi andiamo avanti e creiamo questo codice ed eseguiamolo. Ed è quello che vedremo, oggi
è lunedì.
Perché quello che sta succedendo qui è oggi sarà lunedì. Metti questa l'espressione
che vuoi valutare la variabile oggi, quindi la valuta.
Le cose chiave da ricordare qui sono che
hai una parentesi per iniziare l'istruzione switch sulla riga 16 in una
parentesi finale per terminare il nome dello switch nella riga 29.
È possibile avere più righe all'interno di ciascuna istruzione case senza utilizzare le parentesi.
Ora vediamo cosa succede se togliamo la
dichiarazione di interruzione dopo lunedì.
Perché ricorda, la rottura salterà fuori dalla custodia. Ma se lo
rimuoviamo, quello che succederà è che
cadrà fino a martedì e vedrai entrambi i printf eseguiti
per il lunedì di oggi e oggi è martedì.
Quindi ora quando eseguiamo il
programma, vediamo che oggi è lunedì, oggi è martedì.
Questa è l'importanza dell'istruzione break.
La pausa salta fuori.
Quindi questo potrebbe essere utile se si desidera lo stesso output per lunedì e martedì.
Quindi, ad esempio, a volte vedrai
istruzioni case come questa, case Tuesday perché vuoi lo stesso output
e non importa a cosa sia uguale la variabile.
Quindi potresti vedere cose del genere, ma quando hai istruzioni case
separate che hanno un'esecuzione diversa, devi aggiungere quell'interruzione lì.
Quindi guardiamo solo domenica, lunedì e martedì.
Cosa succede se impostiamo il valore di oggi uguale a domenica
perché non ci sono casi che lo corrisponderanno.
Bene, quello che succederà è che cadrà attraverso l'impostazione predefinita e stamperà qualunque cosa.
Quindi proviamo a eseguirlo di nuovo.
E vediamo che oggi è domenica.
Spiacenti, impostalo sulla variabile sbagliata. Voglio impostarlo, diciamo
solo, mercoledì. Abbiamo avuto un caso per domenica.
Quindi ora vedremo che effettivamente stampa qualsiasi cosa perché non corrispondeva
a nessuno dei casi.
Quindi tutto quello che devi fare per cambiare è davvero memorizzare la sintassi.
L'espressione va tra parentesi, ecco cosa valuterete.
I casi devono corrispondere all'espressione. Quindi di solito stai facendo variabili,
ecco perché devono essere costanti o espressioni che restituiscono un valore costante specifico.
E poi hai casi per ogni cosa e poi un predefinito per tutti i casi, e non dimenticare le interruzioni.
Torniamo indietro e parliamo ancora un po 'e un altro esempio del
costrutto switch con case.
In questo prossimo esempio, è leggermente diverso.
Quello che stiamo facendo qui è ottenere dati dall'utente e quindi attivarli.
Quindi in questo esempio nella nostra funzione principale, inizia creando un
paio di float e poi crea un operatore carattere e poi chiede all'utente di
inserire un valore, un operatore e un valore due.
E sta usando specificatori di formato per distinguere, e tutti hanno un indirizzo di e commerciale.
A seconda del carattere che inserisci per l'operatore, che sia più meno o stella, questo è ciò
che desideri includere nel tuo caso di commutazione.
Quindi, se l'utente ha immesso un
segno più, come si vede nella colonna successiva qui, il costrutto switch, è l'operatore di accensione.
Confronterà il valore di operator, il valore dell'operatore variabile con ciascuna
di queste istruzioni case. E noterai che queste dichiarazioni case
hanno virgolette singole intorno a loro perché stiamo confrontando i caratteri.
In questo modo puoi
confrontare numeri, variabili con valori costanti specifiche o caratteri con costanti specifiche.
E poi all'interno di ogni dichiarazione del caso, stampiamo un formato specifico.
Valore uno più valore due, valore uno meno valore due.
Stiamo effettivamente eseguendo calcoli nella nostra stampa.
E poi di nuovo vedi quelle importanti dichiarazioni di rottura
che stanno saltando fuori e sono necessarie se non vuoi cadere in nessuno degli altri casi.
Notate anche che in quell'ultima istruzione case in cui ha la barra in avanti il divisore,
abbiamo un'istruzione if.
Non abbiamo parentesi attorno al caso
perché possiamo avere più affermazioni in ogni caso senza parentesi.
Quindi nell'ultimo caso diciamo che se il valore due è uguale a 0, stiamo
facendo un piccolo controllo per assicurarci di non dividere per 0.
E se non dividiamo per 0, allora eseguiremo effettivamente la nostra divisione.
E poi, proprio alla fine di quel caso, abbiamo un'altra pausa.
Il nostro caso predefinito dice che hai inserito un operatore che non sappiamo come gestire.
Ma l'istruzione switch è molto efficiente.
È molto veloce scrivere ogni volta che si confrontano
molti valori diversi con una variabile specifica e quindi si desidera eseguire operazioni diverse.
L'ultima cosa che volevo menzionare è stata la dichiarazione in relazione al processo decisionale.
Non è una dichiarazione di
decisione diretta, è più un salto a una riga di codice diversa, utilizzando un'etichetta,
ma è disponibile in c, ed è per questo che ho voluto menzionarlo.
Ci sono due parti nell'istruzione go to, l'etichetta e la parola chiave go to.
Ora, per quelli di voi che hanno già
programmato in Fortran o in altri linguaggi di base, probabilmente lo riconoscerete e probabilmente lo
avete usato un po '.
Ora arrivando a c, non c'è bisogno
di usarlo davvero. Ci sono un paio di
casi in cui ho visto che era piuttosto utile, che spiegherò tra un secondo, ma il passo è saltare
a un codice e potresti andare a qualsiasi riga di codice.
Uno dei motivi per cui alle persone non piace usarlo perché è molto difficile da seguire.
Quando mantieni un programma e se è sequenziale, vai riga per
riga, istruzioni if nei cicli while.
È già abbastanza brutto quando hai le istruzioni if nei cicli while.
Ma ora se hai qualcosa in cui fondamentalmente sei sulla riga 27 del tuo codice
sorgente e salterai alla riga 800 per nessun motivo diverso dalla semplice parola chiave go to, all'improvviso stai
saltando un sacco di codice, ed è molto difficile da mantenere e seguire.
Quindi le due parti a cui andare e il nome dell'etichetta. Il nome dell'etichetta segue
la stessa convenzione per la denominazione di una variabile, caratteri alfanumerici, non puoi
iniziare con cifre, puoi iniziare con trattini bassi.
puoi iniziare con i trattini bassi.
Fondamentalmente, usi semplicemente la parola chiave vai a e vai a un
identificatore, parte due. La seconda parte è un'etichetta da qualche parte.
Quindi, per passare effettivamente a quella riga di codice, devi etichettare quella riga di codice.
Deve esserci una dichiarazione che dica la seconda parte.
Ora ti mostrerò un esempio, ma non dovresti mai usarlo
a causa dei problemi associati alla manutenzione.
Tuttavia, volevo menzionarlo se hai programmato prima e sei abituato a usarlo.
In c, non hai davvero bisogno di usarlo così tanto.
C'è un caso d'uso che ho visto che potrebbe essere utile.
L'altro giorno stavo lavorando con un collega programmatore
e aveva un sacco di cicli annidati
o istruzioni if annidate.
Ma i loop sono probabilmente l'esempio migliore. Loop, ricorda, ripetendo il codice. Aveva molti loop annidati.
E al loop annidato molto interno, come il quinto,
voleva saltare fuori da tutti i loop perché aveva qualche condizione.
E così andava a saltare fuori da tutti quei loop.
L'altro modo per uscire dai loop è usare la parola chiave
brake, ma il freno salterà solo dal punto più interno.
Quindi non c'era davvero alcun modo efficace senza di lui impostare un gruppo
di flag e avere un mucchio di istruzioni if per uscire da ogni singolo
ciclo, quindi era solito andare a. E questo è stato un caso in cui ho
pensato che fosse piuttosto utile perché riduceva la quantità di codice che dovevi scrivere ed era abbastanza chiaro su ciò che stava accadendo.
Stavi semplicemente saltando fuori da tutti i loop annidati perché
hai soddisfatto una certa condizione.
E questo è un caso. Ma per la maggior parte, non hai davvero bisogno
di andare e per i motivi che ho menzionato è molto problematico, è difficile seguire il codice quando salti dappertutto.
Ma il go to è proprio come lo usi proprio come lo usi in altre lingue.
Hai una parola chiave con il nome dell'etichetta.
E ciò che accadrà nel tuo codice è che salterai a quella riga di codice con l'etichetta.
Quindi puoi saltare tutti i tipi di codice.
Quindi, in questo esempio, abbiamo un'etichetta chiamata top e ha i
due punti. È così che sai che è un'etichetta.
E in alto ci sono alcune affermazioni. E in fondo a
questo, hai una dichiarazione if. E tu dici che se il carattere è uguale a y, vai all'inizio.
Quindi di nuovo, vedi come puoi semplicemente saltare tutto intorno al tuo codice e questo lo rende molto difficile da seguire.
Quindi non usarlo fondamentalmente, a meno che tu non abbia molti, molti, molti loop annidati e vuoi
saltare fuori da tutti i loop. Grazie.