Instruções
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ãostd::cout<<"n = "<< n <<'\n';// instrução de expressãoreturn0;// instrução de retorno}
C++ inclui os seguintes tipos de instruções:
Índice |
[editar]Rótulos
Qualquer instrução pode ser rotulada, ao prover um rótulo seguido por uma vírgula antes da instrução em si.
attr(opcional)identifier:statement | (1) | ||||||||
attr(opcional)caseconstexpr:statement | (2) | ||||||||
attr(opcional)default:statement | (3) | ||||||||
Uma sequência de atributoattr 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()}
[editar]Instruções de expressão
Uma expressão seguida por um ponto vírgula é uma declaração.
attr(opcional)expression(opcional); | (1) | ||||||||
| attr(C++11) | - | sequência opcional de qualquer número de atributos |
| expression | - | uma expressã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.
[editar]Instruções compostas
Instruções compostas ou blocos são sequências arrodeadas por chaves de instruções.
attr(opcional){statement...(opcional)} | (1) | ||||||||
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 blocoint n =1;// instrução de declaraçãostd::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 blocostd::ofstream f("test.txt");// instrução de declaração f <<"abc\n";// instrução de expressão}// fim de bloco: f is flushada e fechadastd::ifstream f("test.txt");std::string str; f >> str;}
[editar]Instruções de seleção
Instruções de seleção escolhem entre um de vários fluxos de controle.
| (até C++17) | |||||||||||||||||||||||||||||||||||||||||||||||||
| (desde C++17) | |||||||||||||||||||||||||||||||||||||||||||||||||
[editar]Instruções de iteração
Instruções de iteração executam repetidamente algum código.
attr(opcional)while(condition)statement | (1) | ||||||||
attr(opcional)dostatementwhile(expression); | (2) | ||||||||
attr(opcional)for(init-statementcondition(opcional);expression(opcional))statement | (3) | ||||||||
attr(opcional)for(for-range-decl:for-range-init)statement | (4) | (desde C++11) | |||||||
[editar]Instruções de pulo
Instruções de pulo transferem incondicionalmente controle de fluxo
attr(opcional)break; | (1) | ||||||||
attr(opcional)continue; | (2) | ||||||||
attr(opcional)returnexpression(opcional); | (3) | ||||||||
attr(opcional)returnbraced-init-list; | (4) | (desde C++11) | |||||||
attr(opcional)gotoidentifier; | (5) | ||||||||
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.
[editar]Instruções de declaração
Instruções de declaração introduzem um ou mais identificadores a um bloco.
| block-declaration | (1) | ||||||||
[editar]Blocos try
Blocos try proveem a habilidade de pegar/catch exceções lançadas/thrown quando executando outras instruções.
attr(opcional)trycompound-statementhandler-sequence | (1) | ||||||||
Blocos atômicos e sincronizadosBlocos atômicos e sincronizados são usados para implementar memória transacional.
1)bloco sincronizado, executado em ordem total única com todos os blocos sincronizados; 2)bloco atômico que aborta em exceções; 3)bloco atômico que rola de volta em exceções; 4)bloco atômico que comete em exceções. | (TM TS) | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
[editar]Veja também
Documentação C para Instruções |
