C++
Controllo del flusso

Osservazioni

Astuccio

Introduce un'etichetta case di un'istruzione switch. L'operando deve essere un'espressione costante e deve corrispondere alla condizione dell'interruttore nel tipo. Quando viene eseguita l'istruzione switch, passa all'etichetta case con operando uguale alla condizione, se presente.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

interruttore

Secondo lo standard C ++,

L'istruzione switch fa sì che il controllo venga trasferito a una delle diverse istruzioni a seconda del valore di una condizione.

Lo switch parola chiave è seguito da una condizione parentesi e un blocco, che può contenere etichette case e un'etichetta default facoltativa. Quando viene eseguita l'istruzione switch, il controllo verrà trasferito a un'etichetta case con un valore corrispondente a quello della condizione, se presente, o all'etichetta default , se presente.

La condizione deve essere un'espressione o una dichiarazione, che ha un numero intero o un tipo di enumerazione o un tipo di classe con una funzione di conversione in un numero intero o un tipo di enumerazione.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

catturare

La parola chiave catch introduce un gestore di eccezioni, ovvero un blocco in cui il controllo verrà trasferito quando viene generata un'eccezione di tipo compatibile. La parola chiave catch è seguita da una dichiarazione di eccezione parentesi, che è simile nella forma a una dichiarazione di parametro di funzione: il nome del parametro può essere omesso e l'ellissi ... è consentita, che corrisponde a qualsiasi tipo. Il gestore delle eccezioni gestirà l'eccezione solo se la sua dichiarazione è compatibile con il tipo dell'eccezione. Per ulteriori dettagli, vedere la rilevazione di eccezioni .

try {
    std::vector<int> v(N);
    // do something
} catch (const std::bad_alloc&) {
    std::cout << "failed to allocate memory for vector!" << std::endl;
} catch (const std::runtime_error& e) {
    std::cout << "runtime error: " << e.what() << std::endl;
} catch (...) {
    std::cout << "unexpected exception!" << std::endl;
    throw;
}

predefinito

In un'istruzione switch, introduce un'etichetta a cui verrà eseguito il salto se il valore della condizione non è uguale a uno dei valori delle etichette del caso.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

class Base {
    // ...
    // we want to be able to delete derived classes through Base*,
    // but have the usual behaviour for Base's destructor.
    virtual ~Base() = default;
};

Se

Presenta una dichiarazione if. La parola chiave if deve essere seguita da una condizione parentesi, che può essere un'espressione o una dichiarazione. Se la condizione è veritiera, la sottostazione successiva alla condizione verrà eseguita.

int x;
std::cout << "Please enter a positive number." << std::endl;
std::cin >> x;
if (x <= 0) {
    std::cout << "You didn't enter a positive number!" << std::endl;
    abort();
}

altro

La prima sottostazione di un'istruzione if può essere seguita dalla parola chiave else . La sottostazione dopo la parola chiave else verrà eseguita quando la condizione è falsa (ovvero, quando la prima sottostazione non viene eseguita).

int x;
std::cin >> x;
if (x%2 == 0) {
    std::cout << "The number is even\n";
} else {
    std::cout << "The number is odd\n";
}

vai a

Salta a un'istruzione etichettata, che deve trovarsi nella funzione corrente.

bool f(int arg) {
    bool result = false;
    hWidget widget = get_widget(arg);
    if (!g()) {
        // we can't continue, but must do cleanup still
        goto end;
    }
    // ...
    result = true;
  end:
    release_widget(widget);
    return result;
}

ritorno

Restituisce il controllo da una funzione al relativo chiamante.

Se return ha un operando, l'operando viene convertito nel tipo di ritorno della funzione e il valore convertito viene restituito al chiamante.

int f() {
    return 42;
}
int x = f(); // x is 42
int g() {
    return 3.14;
}
int y = g(); // y is 3

Se return non ha un operando, la funzione deve avere un tipo di reso void . Come caso speciale, una funzione di annullamento del void può anche restituire un'espressione se l'espressione ha tipo void .

void f(int x) {
    if (x < 0) return;
    std::cout << sqrt(x);
}
int g() { return 42; }
void h() {
    return f(); // calls f, then returns
    return g(); // ill-formed
}

Quando restituisce main , std::exit viene chiamato implicitamente con il valore restituito e il valore viene quindi restituito all'ambiente di esecuzione. (Comunque, il ritorno da main distrugge le variabili locali automatiche, mentre chiamare std::exit direttamente no.)

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Missing argument\n";
        return EXIT_FAILURE; // equivalent to: exit(EXIT_FAILURE);
    }
}

gettare

1. Quando il throw verifica in un'espressione con un operando, il suo effetto è di generare un'eccezione , che è una copia dell'operando.

   void print_asterisks(int count) {
       if (count < 0) {
           throw std::invalid_argument("count cannot be negative!");
       }
       while (count--) { putchar('*'); }
   }
   

2. Quando il throw verifica in un'espressione senza un operando, il suo effetto consiste nel ripensare all'eccezione corrente . Se non ci sono eccezioni attuali, viene chiamato std::terminate .

   try {
       // something risky
   } catch (const std::bad_alloc&) {
       std::cerr << "out of memory" << std::endl;
   } catch (...) {
       std::cerr << "unexpected exception" << std::endl;
       // hope the caller knows how to handle this exception
       throw;
   }
   

3. Quando il throw verifica in un dichiaratore di funzioni, introduce una specifica di eccezione dinamica, che elenca i tipi di eccezioni che la funzione è autorizzata a propagare.

   // this function might propagate a std::runtime_error,
   // but not, say, a std::logic_error
   void risky() throw(std::runtime_error);
   // this function can't propagate any exceptions
   void safe() throw();
   

   Le specifiche delle eccezioni dinamiche sono deprecate dal C ++ 11.

Si noti che i primi due usi del throw sopra elencati costituiscono espressioni piuttosto che dichiarazioni. (Il tipo di un'espressione di lancio è void .) Ciò rende possibile annidarli all'interno di espressioni, in questo modo:

unsigned int predecessor(unsigned int x) {
    return (x > 0) ? (x - 1) : (throw std::invalid_argument("0 has no predecessor"));
}

provare

La parola chiave try è seguita da un blocco o da un elenco di inizializzatore del costruttore e quindi da un blocco (vedere qui ). Il blocco try è seguito da uno o più blocchi catch . Se un'eccezione si propaga dal blocco try, ognuno dei blocchi catch corrispondenti dopo il blocco try ha l'opportunità di gestire l'eccezione, se i tipi corrispondono.

std::vector<int> v(N);     // if an exception is thrown here,
                           // it will not be caught by the following catch block
try {
    std::vector<int> v(N); // if an exception is thrown here,
                           // it will be caught by the following catch block
    // do something with v
} catch (const std::bad_alloc&) {
    // handle bad_alloc exceptions from the try block
}    

Strutture condizionali: if, if..else

se e altro:

usato per verificare se l'espressione data restituisce vero o falso e agisce in quanto tale:

if (condition) statement

la condizione può essere qualsiasi espressione C ++ valida che restituisca qualcosa da verificare con verità / falsità, ad esempio:

if (true) { /* code here */ }  // evaluate that true is true and execute the code in the brackets
if (false) { /* code here */ } // always skip the code since false is always false

la condizione può essere qualsiasi cosa, una funzione, una variabile o un confronto, ad esempio

if(istrue()) { } // evaluate the function, if it returns true, the if will execute the code
if(isTrue(var)) { } //evalute the return of the function after passing the argument var
if(a == b) { } // this will evaluate the return of the experssion (a==b) which will be true if equal and false if unequal
if(a) { } //if a is a boolean type, it will evaluate for its value, if it's an integer, any non zero value will be true, 

se vogliamo verificare una molteplicità di espressioni, possiamo farlo in due modi:

usando operatori binari :

if (a && b) { } // will be true only if both a and b are true (binary operators are outside the scope here
if (a || b ) { } //true if a or b is true 

usando if / ifelse / else :

per un semplice interruttore o se altrimenti

if (a== "test") {
    //will execute if a is a string "test" 
} else {
    // only if the first failed, will execute 
}

per più scelte:

if (a=='a') { 
// if a is a char valued 'a'  
} else if (a=='b') {
// if a is a char valued 'b' 
} else if (a=='c') {
// if a is a char valued 'c'
} else { 
//if a is none of the above
}

tuttavia, è necessario notare che è necessario utilizzare ' switch ' se il codice verifica il valore della stessa variabile

Istruzioni di salto: pausa, continua, goto, uscita.

L'istruzione di rottura:

Usando l'interruzione possiamo lasciare un ciclo anche se la condizione per la sua fine non è soddisfatta. Può essere usato per terminare un ciclo infinito o per costringerlo a terminare prima della sua fine naturale

La sintassi è

break;

Esempio : spesso utilizziamo i casi di break switch , vale a dire una volta che un caso in cui lo switch è soddisfatto, viene eseguito il blocco di codice di tale condizione.

switch(conditon){
case 1: block1;
case 2: block2;
case 3: block3;
default: blockdefault;
} 

in questo caso se il caso 1 è soddisfatto allora viene eseguito il blocco 1, quello che vogliamo veramente è solo il blocco1 da elaborare, ma invece, una volta processato il blocco1, i blocchi rimanenti, block2, block3 e blockdefault vengono elaborati anche se solo il caso 1 è stato saturato Per evitare questo, utilizziamo l'interruzione alla fine di ogni blocco come:

switch(condition){
case 1: block1;
        break;
case 2: block2;
        break;
case 3: block3;
        break;
default: blockdefault;
        break;
}

quindi viene elaborato un solo blocco e il controllo esce dal ciclo di commutazione.

break può anche essere usato in altri loop condizionali e non condizionali come if , while , for etc;

esempio:

if(condition1){
   ....
   if(condition2){
    .......
    break;
    }
 ...
}

L'istruzione continua:

L'istruzione continue fa in modo che il programma salti il ​​resto del ciclo nell'iterazione corrente come se la fine del blocco di istruzioni fosse stata raggiunta, facendolo saltare alla seguente iterazione.

La sintassi è

continue;

Esempio considerare quanto segue:

for(int i=0;i<10;i++){
if(i%2==0)
continue;
cout<<"\n @"<<i;
}

che produce l'output:

 @1
 @3
 @5
 @7
 @9

questo codice ogni volta che la condizione i%2==0 è soddisfatta, continue viene elaborata, questo fa sì che il compilatore salti tutto il codice rimanente (stampa @ e i) e viene eseguita l'istruzione di incremento / decremento del ciclo.

L'istruzione goto:

Permette di fare un salto in assoluto verso un altro punto del programma. È necessario utilizzare questa funzione attentamente poiché la sua esecuzione ignora qualsiasi tipo di limitazione di nidificazione. Il punto di destinazione è identificato da un'etichetta, che viene quindi utilizzata come argomento per l'istruzione goto. Un'etichetta è composta da un identificatore valido seguito da due punti (:)

La sintassi è

goto label;
..
.
label: statement;

Nota: l' uso dell'istruzione goto è altamente sconsigliato perché rende difficile tracciare il flusso di controllo di un programma, rendendo il programma difficile da capire e difficile da modificare.

Esempio :

int num = 1;
STEP:
do{
 
    if( num%2==0 )
    {
        num = num + 1;
        goto STEP;
     }

   cout << "value of num : " << num << endl;
   num = num + 1;
 }while( num < 10 );

produzione :

value of num : 1
value of num : 3
value of num : 5
value of num : 7
value of num : 9

ogni volta che la condizione num%2==0 è soddisfatta, goto invia il controllo di esecuzione all'inizio del ciclo do-while .

La funzione di uscita:

exit è una funzione definita in cstdlib . Lo scopo exit è terminare il programma in esecuzione con un codice di uscita specifico. Il suo prototipo è:

void exit (int exit code);

cstdlib definisce i codici di uscita standard EXIT_SUCCESS e EXIT_FAILURE .