C++
Control de flujo

Observaciones

caso

Introduce una etiqueta de caso de una declaración de cambio. El operando debe ser una expresión constante y coincidir con la condición de cambio en el tipo. Cuando se ejecuta la instrucción de cambio, saltará a la etiqueta del caso con el operando igual a la condición, si la hay.

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

cambiar

Según la norma C ++,

La instrucción de switch hace que el control se transfiera a una de varias declaraciones, según el valor de una condición.

El switch palabra clave va seguido de una condición entre paréntesis y un bloque, que puede contener etiquetas de case y una etiqueta default opcional. Cuando se ejecuta la instrucción de cambio, el control se transferirá a una etiqueta de case con un valor que coincida con el de la condición, si corresponde, o a la etiqueta default , si corresponde.

La condición debe ser una expresión o una declaración, que tenga un tipo de entero o enumeración, o un tipo de clase con una función de conversión a tipo de entero o enumeración.

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

captura

La palabra clave catch introduce un controlador de excepciones, es decir, un bloque al que se transferirá el control cuando se lance una excepción de tipo compatible. A la palabra clave catch le sigue una declaración de excepción entre paréntesis, que es similar en forma a una declaración de parámetro de función: el nombre del parámetro se puede omitir, y se permiten los puntos suspensivos ... que coinciden con cualquier tipo. El controlador de excepciones solo manejará la excepción si su declaración es compatible con el tipo de excepción. Para más detalles, ver excepciones de captura .

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;
}

defecto

En una declaración de cambio, introduce una etiqueta a la que se saltará si el valor de la condición no es igual a ninguno de los valores de las etiquetas de 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;
};

Si

Introduce una sentencia if. La palabra clave if debe ir seguida de una condición entre paréntesis, que puede ser una expresión o una declaración. Si la condición es verdadera, se ejecutará la subestación posterior a la condición.

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();
}

más

La primera subestación de una sentencia if puede ir seguida de la palabra clave else . La subestación después de la palabra clave else se ejecutará cuando la condición sea falsey (es decir, cuando no se ejecute la primera subestación).

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

ir

Salta a una declaración etiquetada, que debe estar ubicada en la función actual.

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;
}

regreso

Devuelve el control de una función a su interlocutor.

Si el return tiene un operando, el operando se convierte al tipo de retorno de la función y el valor convertido se devuelve al llamante.

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

Si return no tiene un operando, la función debe tener un tipo de retorno void . Como caso especial, una función void -returning también puede devolver una expresión si la expresión tiene el 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
}

Cuando se devuelve main , std::exit se llama implícitamente con el valor de retorno, y el valor se devuelve al entorno de ejecución. (Sin embargo, regresar de main destruye las variables locales automáticas, mientras que llamar std::exit directamente no lo hace).

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

lanzar

1. Cuando se produce el throw en una expresión con un operando, su efecto es lanzar una excepción , que es una copia del operando.

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

2. Cuando se produce el throw en una expresión sin un operando, su efecto es volver a emitir la excepción actual . Si no hay una excepción actual, se llama a 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. Cuando se produce el throw en un declarador de función, introduce una especificación de excepción dinámica, que enumera los tipos de excepciones que la función puede propagar.

   // 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();
   

   Las especificaciones de excepciones dinámicas están en desuso a partir de C ++ 11.

Tenga en cuenta que los dos primeros usos de throw enumerados anteriormente constituyen expresiones en lugar de declaraciones. (El tipo de una expresión de lanzamiento es void ). Esto hace posible anidarlos dentro de expresiones, de esta manera:

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

tratar

A la palabra clave try le sigue un bloque, o una lista de inicialización de constructor y luego un bloque (ver aquí ). Al bloque try le sigue uno o más bloques catch . Si una excepción se propaga fuera del bloque try, cada uno de los bloques catch correspondientes después del bloque try tiene la oportunidad de manejar la excepción, si los tipos coinciden.

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
}    

Estructuras condicionales: if, if..else

si y si no

se usaba para verificar si la expresión dada devuelve verdadero o falso y actúa como tal:

if (condition) statement

la condición puede ser cualquier expresión válida de C ++ que devuelva algo que se verifique con la verdad / falsedad, por ejemplo:

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 condición puede ser cualquier cosa, una función, una variable o una comparación, por ejemplo.

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, 

Si queremos comprobar si hay varias expresiones, podemos hacerlo de dos maneras:

utilizando operadores binarios :

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 :

para un simple cambio ya sea si o bien

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

para opciones múltiples:

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
}

sin embargo, debe tenerse en cuenta que debe usar ' switch ' en su lugar si su código verifica el valor de la misma variable

Saltar declaraciones: romper, continuar, goto, salir.

La instrucción de descanso:

Usando break podemos dejar un bucle incluso si la condición para su final no se cumple. Puede usarse para terminar un bucle infinito, o para forzarlo a que termine antes de su final natural.

La sintaxis es

break;

Ejemplo : a menudo utilizamos break en los casos de switch , es decir, una vez que se cumple un caso, el bloque de código de esa condición se ejecuta.

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

en este caso, si se satisface el caso 1, entonces se ejecuta el bloque 1, lo que realmente queremos es que solo se procese el bloque1, pero una vez que se procesa el bloque1, los bloques restantes, el bloque2, el bloque3 y el bloqueo por defecto también se procesan, aunque solo el caso 1 fue satisfecho Para evitar esto, usamos break al final de cada bloque como:

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

por lo que solo se procesa un bloque y el control sale del bucle de conmutación.

break también se puede usar en otros bucles condicionales y no condicionales como if , while , for etc;

ejemplo:

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

La instrucción continua:

La instrucción de continuación hace que el programa omita el resto del bucle en la iteración actual como si se hubiera llegado al final del bloque de instrucciones, lo que provocó que saltara a la siguiente iteración.

La sintaxis es

continue;

Ejemplo considera lo siguiente:

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

que produce la salida:

 @1
 @3
 @5
 @7
 @9

i este código siempre que se cumpla la condición i%2==0 continue se procesa, esto hace que el compilador omita todo el código restante (imprimiendo @ ei) y se ejecute la declaración de incremento / decremento del bucle.

La instrucción goto:

Permite realizar un salto absoluto a otro punto del programa. Debe usar esta función con cuidado, ya que su ejecución ignora cualquier tipo de limitación de anidamiento. El punto de destino se identifica mediante una etiqueta, que luego se utiliza como un argumento para la instrucción goto. Una etiqueta está hecha de un identificador válido seguido de dos puntos (:)

La sintaxis es

goto label;
..
.
label: statement;

Nota: El uso de la instrucción goto es altamente desaconsejable porque dificulta el seguimiento del flujo de control de un programa, lo que hace que el programa sea difícil de entender y de modificar.

Ejemplo:

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 );

salida:

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

siempre que se cumpla la condición num%2==0 goto envía el control de ejecución al comienzo del bucle do-while while.

La función de salida:

exit es una función definida en cstdlib . El propósito de exit es terminar el programa en ejecución con un código de salida específico. Su prototipo es:

void exit (int exit code);

cstdlib define los códigos de salida estándar EXIT_SUCCESS y EXIT_FAILURE .