Instrucciones

Las instrucciones son fragmentos de un programa de C++ que se ejecutan en secuencia. El cuerpo de una función es una secuencia de instrucciones. Por ejemplo:

int main()
{
    int n = 1;                        // instrucción de declaración
    n = n + 1;                        // instrucción de expresión
    std::cout << "n = " << n << '\n'; // instrucción de expresión 
    return 0;                         // instrucción return
}

C++ incluye los siguientes tipos de instrucciones:

[editar] Etiquetas

Cualquier instrucción puede ser etiquetada al proporcionar una etiqueta seguida de dos puntos antes de la instrucción misma. Con fines de control de flujo.

Una instrucción puede llevar varias etiquetas.

Las etiquetas (y solamente las etiquetas) tienen ámbito de función. Una etiqueta con un identificador declarado dentro de una función coincide con todas las sentencias goto con el mismo identificador en esa función, en todos los bloques anidados, antes y después de su propia declaración.

Dos etiquetas en una función no pueden tener el mismo identificador.

Las etiquetas se ignoran por la búsqueda no calificada: una etiqueta puede tener el mismo nombre que cualquier otra entidad en el programa.

void f() {
    {
        goto label; // etiqueta en ámbito aunque se declaré más tarde
label:;
    }
    goto label; // la etiqueta ignora el ámbito de bloque
}
 
void g() {
    goto label; // error: etiqueta no en ámbito en g()
}

[editar] Instrucciones de expresión

Una expresión seguida de un punto y coma es una instrucción.

La mayoría de las instrucciones en un programa típico de C++ son instrucciones de expresión, tales como asignaciones o llamadas de función.

Una instrucción de expresión sin una expresión se llama una instrucción nula. Se usa frecuentemente para proporcionar un cuerpo vacío a un bucle for o while. También puede ser usada para acarrear una etiqueta al final de una instrucción compuesta.

[editar] Instrucciones compuestas

Las instrucciones compuestas o bloques son secuencias de instrucciones entre llaves. Agrupan una secuencia de instrucciones en una sola instrucción.

Cuando se espera una instrucción, pero necesitan ejecutarse múltiples instrucciones en secuencia (por ejemplo, en una instrucción if o en un bucle), puede usarse una instrucción compuesta:

if (x > 5)          // inicio de la instrucción if
{                   // inicio de bloque
    int n = 1;      // instrucción de declaración
    std::cout << n; // instrucción de expresión
}                   // fin de bloque, fin de la instrucción if

Cada instrucción compuesta introduce su propio ámbito de bloque; las variables declaradas dentro de un bloque se destruyen en el punto de la llave que cierra, en orden inverso:

int main()
{ // inicio de bloque externo
    {                                // inicio de bloque interno
        std::ofstream f("prueba.txt"); // instrucción de declaración
        f << "abc\n";                // instrucción de expresión
    }                                // fin de bloque interno: f se vacía y se cierra
    std::ifstream f("prueba.txt");  // instrucción de declaración
    std::string str; // instrucción de declaración
    f >> str; // instrucción de expresión
} // fin de bloque externo, str se destruye,f se cierra

[editar] Instrucciones de selección

Las instrucciones de selección escogen de entre varios flujos de control.

[editar] Instrucciones de iteración

Las instrucciones de iteración ejecutan repetidamente algún código.

[editar] Instrucciones de salto

Las intrucciones de salto transfieren el control de flujo incondicionalmente.

Nota: para todas las instrucciones de salto, transferencia fuera de un bucle, fuera de un bloque o de vuelta después de una variable inicializada con duración de almacenamiento automática, implica la destrucción de objetos con duración de almacenamiento automática que se encuentran en ámbito en el punto del cual se inició la transferencia, pero no en el punto al que se transfirió. Si múltiples objetos fueron inicializados, el orden de destrucción es el inverso del orden de inicialización.

[editar] Instrucciones de declaración

Las instrucciones de declaración introducen uno o más identificadores dentro de un bloque.

[editar] Bloques try

Los bloques try proporcionan la habilidad de capturar excepciones lanzadas cuando se ejecutan otras instrucciones.

[editar] Véase también