Instruções - cppreference.com

Instruções são fragmentos do programa C++ que são executados em sequência. O corpo de qualquer função é uma sequência de instruções. Por exemplo:

int main()
{
    int n = 1;                        // instrução de declaração
    n = n + 1;                        // instrução de expressão
    std::cout << "n = " << n << '\n'; // instrução de expressão
    return 0;                         // instrução de retorno
}

C++ inclui os seguintes tipos de instruções:

1) instruções de expressão;

2) instruções compostas;

3) instruções de seleção;

4) instruções de iteração;

5) instruções de pulo;

6) instruções de declaração;

7) blocos try;

8) blocos atômicos e sincronizados (TM TS).

Rótulos

Qualquer instrução pode ser rotulada, ao prover um rótulo seguido por uma vírgula antes da instrução em si.

1) alvo para goto;

2) rótulo de caso numa instrução switch;

3) rótulo default numa instrução switch.

Uma sequência de atributo attr pode aparecer logo antes do rótulo (em tal caso ela se aplica ao rótulo), ou logo antes de qualquer instrução em si, em tal caso ela se aplica à instrução inteiro. Uma instrução pode carregar múltiplos rótulos.

Um rótulo (e somente um rótulo) com um identificador declarado dentro de uma função está em escopo em todo o lugar nessa função, em todos os blocos ninhados, antes e depois de sua própria declaração.

Dois rótulos numa função não devem ter o mesmo identificador.

Rótulos não são encontrados por busca não-qualificada: um rótulo pode ter o mesmo nome que qualquer outra entidade no programa.

void f()
{
   {   
       goto rotulo; // rótulo em escopo embora declarado depois
label:;
   }
   goto rotulo; // rótulo ignora escopo de bloco
}

void g()
{
    goto rotulo; // erro: rótulo não está em escopo em g()
}

Instruções de expressão

Uma expressão seguida por um ponto vírgula é uma declaração.

A maioria de instruções num programa C++ típico são instruções de expressão, tais como assinamentos ou chamadas de função.

Uma instrução de expressão sem uma expressão é chamada uma expressão nula. Ela é frequentemente usada para prover um corpo vazio a um loop for ou while. Ela também pode ser usada para carregar um rótulo no fim de uma instrução composta.

Instruções compostas

Instruções compostas ou blocos são sequências arrodeadas por chaves de instruções.

Quando uma instrução é experada, mas múltiplas instruções precisam de ser executadas em sequência (por exemplo, numa instrução if ou num loop), uma instrução composta pode ser usada:

if (x > 5)          // começo de instrução if
{                   // começo de bloco
    int n = 1;      // instrução de declaração
    std::cout << n; // instrução de expressão
}                   // fim de bloco, fim de instrução if

Cada instrução composta introduz seu próprio escopo de bloco; variáveis declaradas dentro de um bloco são destruídas na chave de fechar em ordem reversa:

int main()
{
    {                                // começo de bloco
        std::ofstream f("test.txt"); // instrução de declaração
        f << "abc\n";                // instrução de expressão
    }                                // fim de bloco: f is flushada e fechada
    std::ifstream f("test.txt"); 
    std::string str;
    f >> str; 
}

Instruções de seleção

Instruções de seleção escolhem entre um de vários fluxos de controle.

1) instrução if;

2) instrução if com um cláusula else;

Instruções de iteração

Instruções de iteração executam repetidamente algum código.

Instruções de pulo

Instruções de pulo transferem incondicionalmente controle de fluxo

3) instrução return com uma expressão opcional;

5) instrução goto.

Nota: para todas as instruções d epulo, tranferir para fora de um loop, fora de um bloco, ou de volta por ume variável inicializada com duração de armazenamento automática envolve a destruição de objetos com duração de armazennamento automática que estão em escopo no ponto transferido de mas não de ponto transferido para. Se múltiplos objetos foram inicializados, a ordem de destruição é a oposta da ordem de inicialização.

Instruções de declaração

Instruções de declaração introduzem um ou mais identificadores a um bloco.

Blocos try

Blocos try proveem a habilidade de pegar/catch exceções lançadas/thrown quando executando outras instruções.

Veja também