Statements

Sentencias son fragmentos del programa C++ que se ejecutan en secuencia. El cuerpo de cualquier función es una secuencia de sentencias. Por ejemplo:

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

C++ incluye los siguientes tipos de sentencias:

• Sentencias etiquetadas
• Sentencias de expresión
• Sentencias compuestas
• Sentencias de selección
• Sentencias de iteración
• Sentencias de salto

• Sentencias de declaración
• try bloques

Sentencias etiquetadas

Una sentencia etiquetada etiqueta una sentencia para fines de control de flujo.

Etiquetas

label se define como

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 deben tener el mismo identificador.

Las etiquetas no se encuentran mediante unqualified lookup : una etiqueta puede tener el mismo nombre que cualquier otra entidad en el programa.

void f()
{
    {
        goto label; // label en alcance aunque declarado después
        label:      // label puede aparecer al final de un bloque independiente desde C++23
    }
    goto label; // label ignora el alcance de bloque
}
void g()
{
    goto label; // error: label no está en alcance en g()
}

Declaraciones limitadas por flujo de control

Las siguientes declaraciones son declaraciones de flujo de control limitado :

• La compound-statement de un bloque try .
• La compound-statement de un handler .

Para cada sentencia limitada por flujo de control S :

• Todas las etiquetas de destino goto declaradas en S solo pueden ser referenciadas por sentencias en S .
• Cada etiqueta case o default que aparece dentro de S solo puede estar asociada con una switch statement dentro de S .

Sentencias de expresión

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

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

Una sentencia de expresión sin expresión se denomina sentencia nula . Se utiliza frecuentemente para proporcionar un cuerpo vacío a un bucle for o while . También puede utilizarse para llevar una etiqueta al final de una sentencia compuesta. (hasta C++23)

Sentencias compuestas

Una sentencia compuesta o bloque agrupa una secuencia de sentencias en una única sentencia.

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

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

Cada sentencia compuesta introduce su propio ámbito de bloque scope ; las variables declaradas dentro de un bloque se destruyen en la llave de cierre en orden inverso:

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

Sentencias de selección

Una sentencia de selección elige entre uno de varios flujos de control.

Sentencias de iteración

Una sentencia de iteración ejecuta repetidamente algún código.

Sentencias de salto

Una sentencia de salto transfiere incondicionalmente el flujo de control.

Nota: para todas las sentencias de salto, la transferencia fuera de un bucle, fuera de un bloque, o de regreso más allá de una variable inicializada con duración de almacenamiento automático implica la destrucción de objetos con duración de almacenamiento automático que están en el ámbito en el punto desde el cual se transfiere pero no en el punto al cual se transfiere. Si múltiples objetos fueron inicializados, el orden de destrucción es el opuesto al orden de inicialización.

Declaraciones de declaración

Una declaración introduce uno o más identificadores en un bloque.

try bloques

Un try bloque captura excepciones lanzadas al ejecutar otras sentencias.

Subdeclaraciones

Una subdeclaración de una declaración es una de las siguientes:

• Para una sentencia etiquetada , su statement .
• Para una sentencia compuesta , cualquier sentencia de su statement... .
• Para una sentencia de selección , cualquiera de sus statement  o compound-statement  (desde C++23) .
• Para una sentencia de iteración , su statement .

Una sentencia S1 engloba a una sentencia S2 si se satisface alguna de las siguientes condiciones:

• S2 es una subdeclaración de S1
• S1 es una declaración de selección o declaración de iteración, y S2 es la init-statement de S1 .
• S1 es un try block , y S2 es ya sea su compound-statement o el compound-statement de cualquier handler en su handler-seq .
• S1 engloba una declaración S3 y S3 engloba S2 .

Una declaración S1 está encerrada por una declaración S2 si S2 encierra S1 .

Véase también