IL dichiarazioni condizionali (note anche come strutture di controllo decisionale) come if, if else, switch, ecc. vengono utilizzate per scopi decisionali nei programmi C.
Sono anche conosciuti come dichiarazioni decisionali e vengono utilizzati per valutare una o più condizioni e prendere la decisione se eseguire o meno una serie di dichiarazioni. Queste dichiarazioni decisionali nei linguaggi di programmazione decidono la direzione del flusso di esecuzione del programma.
Necessità di dichiarazioni condizionali
Ci sono situazioni nella vita reale in cui dobbiamo prendere alcune decisioni e, sulla base di queste decisioni, decidiamo cosa dovremmo fare dopo. Situazioni simili si verificano anche nella programmazione dove dobbiamo prendere alcune decisioni e sulla base di queste decisioni eseguiremo il successivo blocco di codice. Ad esempio, in C se si verifica x, esegui y, altrimenti esegui z. Possono esserci anche più condizioni come in C se si verifica x allora esegui p, altrimenti se si verifica la condizione y esegui q, altrimenti esegui r. Questa condizione di C else-if è uno dei tanti modi per importare più condizioni.
Tipi di dichiarazioni condizionali in C
Di seguito sono riportate le dichiarazioni decisionali disponibili in C:
- se Dichiarazione
- Istruzione if-else
- Nidificata se istruzione
- if-else-if Scala
- cambiare dichiarazione
- Operatore condizionale
- Istruzioni di salto:
- rottura
- Continua
- vai a
- ritorno
Discutiamo ciascuno di essi uno per uno.
1. se in C
IL se dichiarazione è la dichiarazione decisionale più semplice. Viene utilizzato per decidere se una determinata istruzione o blocco di istruzioni verrà eseguito o meno, ovvero se una determinata condizione è vera allora un blocco di istruzioni verrà eseguito altrimenti no.
Sintassi dell'istruzione if
if ( condition ) { // Statements to execute if // condition is true }> Ecco, il condizione dopo la valutazione sarà vero o falso. C se l'istruzione accetta valori booleani: se il valore è vero, eseguirà il blocco di istruzioni sottostante, altrimenti no. Se non forniamo le parentesi graffe '{' e '}' dopo if(condizione), per impostazione predefinita l'istruzione if considererà la prima istruzione immediatamente seguente come all'interno del suo blocco.
Diagramma di flusso dell'istruzione if
Diagramma di flusso dell'istruzione if
Esempio di se in C
C
// C program to illustrate If statement> #include> > int> main()> {> >int> i = 10;> > >if> (i>15) {> >printf>(>'10 is greater than 15'>);> >}> > >printf>(>'I am Not in if'>);> }> |
>
>Produzione
I am Not in if>
Poiché la condizione presente nell'istruzione if è falsa. Pertanto, il blocco sotto l'istruzione if non viene eseguito.
2. if-else in C
IL Se La sola istruzione ci dice che se una condizione è vera eseguirà un blocco di istruzioni e se la condizione è falsa non lo farà. Ma cosa succede se vogliamo fare qualcos'altro quando la condizione è falsa? Ecco che arriva il C altro dichiarazione. Possiamo usare il altro dichiarazione con il Se istruzione per eseguire un blocco di codice quando la condizione è falsa. IL istruzione if-else è costituito da due blocchi, uno per l'espressione falsa e uno per l'espressione vera.
Sintassi di if else in C
if ( condition ) { // Executes this block if // condition is true } else { // Executes this block if // condition is false }> Diagramma di flusso dell'istruzione if-else
Diagramma di flusso di if else
Esempio di if-else
C
// C program to illustrate If statement> #include> > int> main()> {> >int> i = 20;> > >if> (i <15) {> > >printf>(>'i is smaller than 15'>);> >}> >else> {> > >printf>(>'i is greater than 15'>);> >}> >return> 0;> }> |
>
>Produzione
i is greater than 15>
Il blocco di codice successivo a altro l'istruzione viene eseguita come condizione presente nel file Se l'affermazione è falsa.
3. Nidificato if-else in C
Un if nidificato in C è un'istruzione if che è la destinazione di un'altra istruzione if. Le istruzioni if nidificate significano un'istruzione if all'interno di un'altra istruzione if. Sì, il C ci consente di annidare istruzioni if all'interno di istruzioni if, ovvero possiamo inserire un'istruzione if all'interno di un'altra istruzione if.
Sintassi di Nested if-else
if ( condition1 ) { // Executes when condition1 is true if ( condition2 ) { // Executes when condition2 is true } else { // Executes when condition2 is false }> Diagramma di flusso di Nidificato if-else
Diagramma di flusso di if-else nidificati
Esempio di nidificato if-else
C
// C program to illustrate nested-if statement> #include> > int> main()> {> >int> i = 10;> > >if> (i == 10) {> >// First if statement> >if> (i <15)> >printf>(>'i is smaller than 15
'>);> > >// Nested - if statement> >// Will only be executed if statement above> >// is true> >if> (i <12)> >printf>(>'i is smaller than 12 too
'>);> >else> >printf>(>'i is greater than 15'>);> >}> > >return> 0;> }> |
>
>Produzione
i is smaller than 15 i is smaller than 12 too>
4. Ladder if-else-if in C
IL if else if dichiarazioni vengono utilizzati quando l'utente deve decidere tra più opzioni. Le istruzioni C if vengono eseguite dall'alto verso il basso. Non appena una delle condizioni che controllano l'if è vera, l'istruzione associata a quell'if viene eseguita e il resto della scala C else-if viene ignorata. Se nessuna delle condizioni è vera, verrà eseguita l'istruzione else finale. if-else-if ladder è simile all'istruzione switch.
Sintassi di if-else-if Ladder
if ( condition ) statement; else if ( condition ) statement; . . else statement;>
Diagramma di flusso della scala if-else-if
Diagramma di flusso di if-else-if
Esempio di Ladder if-else-if
C
// C program to illustrate nested-if statement> #include> > int> main()> {> >int> i = 20;> > >if> (i == 10)> >printf>(>'i is 10'>);> >else> if> (i == 15)> >printf>(>'i is 15'>);> >else> if> (i == 20)> >printf>(>'i is 20'>);> >else> >printf>(>'i is not present'>);> }> |
>
>Produzione
i is 20>
5. cambia istruzione in C
IL istruzione switch case è un'alternativa al ladder if else if che può essere utilizzato per eseguire il codice condizionale in base al valore della variabile specificata nell'istruzione switch. Il blocco switch è costituito da casi da eseguire in base al valore della variabile switch.
Sintassi dell'interruttore
switch ( expression ) { case value1: statements; case value2: statements; .... .... .... default: statements; }> Nota: L'espressione switch dovrebbe restituire un numero intero o un carattere. Non può valutare nessun altro tipo di dati.
Diagramma di flusso dell'interruttore
Diagramma di flusso dell'interruttore in C
Esempio di istruzione switch
C
// C Program to illustrate the use of switch statement> #include> > int> main()> {> >// variable to be used in switch statement> >int> var = 2;> > >// declaring switch cases> >switch> (var) {> >case> 1:> >printf>(>'Case 1 is executed'>);> >break>;> >case> 2:> >printf>(>'Case 2 is executed'>);> >break>;> >default>:> >printf>(>'Default Case is executed'>);> >break>;> >}> > >return> 0;> }> |
>
>Produzione
Case 2 is executed>
6. Operatore condizionale in C
IL operatore condizionale viene utilizzato per aggiungere codice condizionale nel nostro programma. È simile all'istruzione if-else. È noto anche come operatore ternario poiché funziona su tre operandi.
Sintassi dell'operatore condizionale
( condition ) ? [true_statements] : [false_statements] ;>
Diagramma di flusso dell'operatore condizionale
Diagramma di flusso dell'operatore condizionale
Esempio di operatore condizionale
C
// C Program to illustrate the use of conditional operator> #include> > // driver code> int> main()> {> > >int> var;> >int> flag = 0;> > >// using conditional operator to assign the value to var> >// according to the value of flag> >var = flag == 0 ? 25 : -25;> >printf>(>'Value of var when flag is 0: %d
'>, var);> > >// changing the value of flag> >flag = 1;> >// again assigning the value to var using same statement> >var = flag == 0 ? 25 : -25;> >printf>(>'Value of var when flag is NOT 0: %d'>, var);> > >return> 0;> }> |
>
>Produzione
Value of var when flag is 0: 25 Value of var when flag is NOT 0: -25>
7. Istruzioni di salto in C
Queste istruzioni vengono utilizzate in C per il flusso di controllo incondizionato attraverso le funzioni di un programma. Supportano quattro tipi di istruzioni di salto:
UN) rottura
Questa istruzione di controllo del ciclo viene utilizzata per terminare il ciclo. Appena il rottura viene incontrata un'istruzione all'interno di un ciclo, le iterazioni del ciclo si fermano lì e il controllo ritorna immediatamente dal ciclo alla prima istruzione dopo il ciclo.
Sintassi di pausa
break;>
Fondamentalmente, le istruzioni break vengono utilizzate in situazioni in cui non siamo sicuri del numero effettivo di iterazioni del ciclo o vogliamo terminare il ciclo in base a qualche condizione.
Esempio di pausa
C
// C program to illustrate> // to show usage of break> // statement> #include> > void> findElement(>int> arr[],>int> size,>int> key)> {> >// loop to traverse array and search for key> >for> (>int> i = 0; i if (arr[i] == key) { printf('Element found at position: %d', (i + 1)); break; } } } int main() { int arr[] = { 1, 2, 3, 4, 5, 6 }; // no of elements int n = 6; // key to be searched int key = 3; // Calling function to find the key findElement(arr, n, key); return 0; }> |
>
>Produzione
Element found at position: 3>
B) Continua
Questa istruzione di controllo del ciclo è proprio come l'istruzione break. IL Continua dichiarazione è opposto a quello della rottura dichiarazione , invece di terminare il ciclo, forza l'esecuzione della successiva iterazione del ciclo.
Come suggerisce il nome, l'istruzione continue forza il ciclo a continuare o eseguire l'iterazione successiva. Quando l'istruzione continue viene eseguita nel ciclo, il codice all'interno del ciclo successivo all'istruzione continua verrà saltato e inizierà la successiva iterazione del ciclo.
Sintassi di continuare
continue;>
Diagramma di flusso di Continua
Diagramma di flusso dell'istruzione C continue
Esempio di continua
C
// C program to explain the use> // of continue statement> #include> > int> main()> {> >// loop from 1 to 10> >for> (>int> i = 1; i <= 10; i++) {> > >// If i is equals to 6,> >// continue to next iteration> >// without printing> >if> (i == 6)> >continue>;> > >else> >// otherwise print the value of i> >printf>(>'%d '>, i);> >}> > >return> 0;> }> |
>
>Produzione
1 2 3 4 5 7 8 9 10>
Se crei una variabile in if-else in C, sarà locale solo per quel blocco if/else. Puoi utilizzare variabili globali all'interno del blocco if/else. Se il nome della variabile creata in if/else è uguale a qualsiasi variabile globale, verrà data priorità alla 'variabile locale'.
C
#include> > int> main()> {> > >int> gfg = 0;>// local variable for main> >printf>(>'Before if-else block %d
'>, gfg);> >if> (1) {> >int> gfg = 100;>// new local variable of if block> >printf>(>'if block %d
'>, gfg);> >}> >printf>(>'After if block %d'>, gfg);> >return> 0;> }> |
>
>Produzione
Before if-else block 0 if block 100 After if block 0>
C) vai a
IL vai alla dichiarazione in C, detta anche istruzione di salto incondizionato, può essere utilizzata per saltare da un punto all'altro all'interno di una funzione.
lattice di dimensioni del testo
Sintassi di goto
Syntax1 | Syntax2 ---------------------------- goto label; | label: . | . . | . . | . label: | goto label;>
Nella sintassi precedente, la prima riga indica al compilatore di andare o saltare all'istruzione contrassegnata come etichetta. In questo caso, un'etichetta è un identificatore definito dall'utente che indica l'istruzione di destinazione. L'istruzione immediatamente seguita dopo 'etichetta:' è l'istruzione di destinazione. L''etichetta:' può anche apparire prima dell'istruzione 'goto label;' nella sintassi precedente.
Diagramma di flusso dell'istruzione goto
Esempi di goto
C
// C program to print numbers> // from 1 to 10 using goto> // statement> #include> > // function to print numbers from 1 to 10> void> printNumbers()> {> >int> n = 1;> label:> >printf>(>'%d '>, n);> >n++;> >if> (n <= 10)> >goto> label;> }> > // Driver program to test above function> int> main()> {> >printNumbers();> >return> 0;> }> |
>
>Produzione
1 2 3 4 5 6 7 8 9 10>
D) ritorno
IL ritorno in C restituisce il flusso dell'esecuzione alla funzione da cui viene chiamato. Questa affermazione non necessita obbligatoriamente di alcuna dichiarazione condizionale. Non appena l'istruzione viene eseguita, il flusso del programma si interrompe immediatamente e restituisce il controllo da dove è stato chiamato. L'istruzione return può restituire o meno qualcosa per una funzione void, ma per una funzione non void deve essere restituito un valore restituito.
Diagramma di flusso del rendimento
Diagramma di flusso del ritorno
Sintassi del ritorno
return [expression] ;>
Esempio di reso
C
// C code to illustrate return> // statement> #include> > // non-void return type> // function to calculate sum> int> SUM(>int> a,>int> b)> {> >int> s1 = a + b;> >return> s1;> }> > // returns void> // function to print> void> Print(>int> s2)> {> >printf>(>'The sum is %d'>, s2);> >return>;> }> > int> main()> {> >int> num1 = 10;> >int> num2 = 10;> >int> sum_of = SUM(num1, num2);> >Print(sum_of);> >return> 0;> }> |
>
>Produzione
The sum is 20>