Mudanças entre as edições de "Sumário de operadores de controle de fluxo em ANSI C"
Linha 5: | Linha 5: | ||
Um ramo é chamado (executado) apenas se o programa escolher percorrê-lo através de testes lógicos. Desta forma é possível executar determinadas instruções ou outras de acordo com condições que podem variar no tempo. | Um ramo é chamado (executado) apenas se o programa escolher percorrê-lo através de testes lógicos. Desta forma é possível executar determinadas instruções ou outras de acordo com condições que podem variar no tempo. | ||
− | == | + | ==Comando if== |
É a mais simples forma de ramificação. A expressão entre parênteses será testada, se for verdadeira uma instrução ou um bloco de instruções será executado. Se for falso esta instrução ou bloco será ignorada e o programa segue seu curso sem portanto executar certo trecho de código. Um teste é tido como verdadeiro se seu resultado é um valor diferente de zero. Abaixo dois exemplos, o primeiro executando um comando simples e outro um bloco (instrução composta) | É a mais simples forma de ramificação. A expressão entre parênteses será testada, se for verdadeira uma instrução ou um bloco de instruções será executado. Se for falso esta instrução ou bloco será ignorada e o programa segue seu curso sem portanto executar certo trecho de código. Um teste é tido como verdadeiro se seu resultado é um valor diferente de zero. Abaixo dois exemplos, o primeiro executando um comando simples e outro um bloco (instrução composta) | ||
− | // | + | //Comando simples |
− | if (expressão_de_teste_logico) | + | if (expressão_de_teste_logico) instrução; |
− | |||
+ | //Comando composto | ||
if (expressão_de_teste_logico) | if (expressão_de_teste_logico) | ||
{ | { | ||
Linha 19: | Linha 19: | ||
} | } | ||
− | == | + | ==Comando if em estrutura if...else== |
Pode-se também determinar o que se deve fazer se o teste for falso. Neste caso em uma execução apenas um trecho será executado, não há possibilidade de ambos serem executados na mesma execução. | Pode-se também determinar o que se deve fazer se o teste for falso. Neste caso em uma execução apenas um trecho será executado, não há possibilidade de ambos serem executados na mesma execução. | ||
+ | //Comando simples | ||
+ | if (expressão_de_teste_logico) instrução1; else instrução2; | ||
+ | |||
+ | //Comando composto | ||
if (expressão_de_teste_logico) | if (expressão_de_teste_logico) | ||
{ | { | ||
Linha 35: | Linha 39: | ||
} | } | ||
− | == | + | ==Comando if aninhado (em cascata)== |
Pode-se ainda configurar operadores if em cascata, desta forma pode-se testar diferentes condições lógicas. Apenas um trecho de código será executado em um ciclo de execução. | Pode-se ainda configurar operadores if em cascata, desta forma pode-se testar diferentes condições lógicas. Apenas um trecho de código será executado em um ciclo de execução. | ||
− | if ( | + | if (expressão_de_teste_logico_1) |
{ | { | ||
− | + | instrução1_1; | |
− | + | instrução2_1; | |
− | + | instruçãoN_1; | |
} | } | ||
− | else if( | + | else if(expressão_de_teste_logico_2) |
{ | { | ||
instrução1_2; | instrução1_2; | ||
Linha 64: | Linha 68: | ||
//se o teste lógico der verdadeiro o instrução1 será executado, | //se o teste lógico der verdadeiro o instrução1 será executado, | ||
//caso contrário será executado o instrução2 | //caso contrário será executado o instrução2 | ||
− | expressão_teste_lógico ? instrução1 : instrução2 | + | expressão_teste_lógico ? instrução1 : instrução2; |
− | == | + | ==Comando switch== |
− | Se assemelha ao if aninhado podendo tratar diversos casos, porém testa apenas uma variável de números inteiros. Tem a vantagem de ser mais eficiente e fácil de ler. É necessário ter ao menos um caso declarado. O operador default é opcional. | + | Se assemelha ao if aninhado podendo tratar diversos casos, porém testa apenas uma variável de números inteiros. Tem a vantagem de ser mais eficiente e fácil de ler. É necessário ter ao menos um caso declarado. O operador default é opcional. Não é necessário usar "{}" para executar instruções em blocos dentro dos casos. |
− | switch ( | + | switch (valor_inteiro_a_ser_testado) |
{ | { | ||
case constante1: | case constante1: | ||
Linha 86: | Linha 90: | ||
} | } | ||
− | ==Palavras-chave== | + | |
+ | ===Palavra-chave break=== | ||
+ | A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch. | ||
+ | |||
+ | =Repetição= | ||
+ | |||
+ | ==Laço while== | ||
+ | Um laço while é como um "if" que se repete. Há portanto um teste lógico e caso seja verdadeiro a instrução simples ou bloco de instruções a seguir será executado. A diferença se comparado com o if é que após executar as instruções o programa volta a realizar o teste lógico podendo repetir a execução caso verdadeiro ou sair do laço while se falso. Este tipo de laço possibilita a condição de não haver execução das instruções internas caso a condição nunca seja tida como verdadeira. | ||
+ | |||
+ | //Comando simples | ||
+ | while (expressão_de_teste_logico) instrução; | ||
+ | |||
+ | //Comando composto | ||
+ | while (expressão_de_teste_logico) | ||
+ | { | ||
+ | instrução1; | ||
+ | instrução2; | ||
+ | instruçãoN; | ||
+ | } | ||
+ | |||
+ | ==Laço do...while== | ||
+ | Neste laço a expressão de teste é executada no final ao invés de ser no início como no while. Na prática as instruções no corpo da estrutura após o "do" serão executadas ao menos uma vez. | ||
+ | |||
+ | //Comando simples | ||
+ | do instrução while(expressão_de_teste_logico); | ||
+ | |||
+ | //Comando composto | ||
+ | do | ||
+ | { | ||
+ | instrução1; | ||
+ | instrução2; | ||
+ | instruçãoN; | ||
+ | } while (expressão_de_teste_logico); | ||
+ | |||
+ | ==Laço for== | ||
+ | Esta estrutura de repetição pode ser escrita de maneira mais compacta que um laço while e a estrutura já prevê ações típicas de um laço que são comandos de inicialização e modificadores pós execução do ciclo, além do teste lógico. Esta estrutura é muito utilizada quando o laço deve ser repetido uma quantidade conhecida de vezes. Sua estrutura é for(expressão1;expressão2;expressão3) onde a expressão1 será sempre executada e apenas uma vez ao iniciar o laço. A expressão2 é a expressão de teste, será sempre checada toda vez que se iniciar um ciclo de repetição, se verdadeira o corpo do comando será executado e a expressão3 será por fim processada. expressão1 é tipicamente utilizada para inicialização de variáveis e a expressão3 para incremento ou decremento de variáveis de controle. | ||
+ | |||
+ | //Comando simples | ||
+ | for(expressão1; expressão2; expressão3) | ||
+ | instrução; | ||
+ | |||
+ | //Comando composto | ||
+ | for(expressão1; expressão2; expressão3) | ||
+ | { | ||
+ | instrução1; | ||
+ | instrução2; | ||
+ | instruçãoN; | ||
+ | } | ||
+ | |||
+ | |||
+ | ==Palavras-chave das estruturas de repetição== | ||
===break=== | ===break=== | ||
A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch. | A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch. | ||
===continue=== | ===continue=== | ||
A palavra-chave continue faz com que a corrente execução seja interrompida e se retorne ao teste lógico do laço. Se parece com o break mas ao invés de sair do laço, a execução continua testando. Serve para "pular" a execução do laço. | A palavra-chave continue faz com que a corrente execução seja interrompida e se retorne ao teste lógico do laço. Se parece com o break mas ao invés de sair do laço, a execução continua testando. Serve para "pular" a execução do laço. |
Edição das 19h14min de 4 de maio de 2016
Comandos de controle de fluxo em ANSI C: Ramificação e repetição. Ramificação está decidindo que ações tomar de acordo com certas condições e repetição está tratando de quantas vezes realizar determinada ação.
Ramificação
Um ramo é chamado (executado) apenas se o programa escolher percorrê-lo através de testes lógicos. Desta forma é possível executar determinadas instruções ou outras de acordo com condições que podem variar no tempo.
Comando if
É a mais simples forma de ramificação. A expressão entre parênteses será testada, se for verdadeira uma instrução ou um bloco de instruções será executado. Se for falso esta instrução ou bloco será ignorada e o programa segue seu curso sem portanto executar certo trecho de código. Um teste é tido como verdadeiro se seu resultado é um valor diferente de zero. Abaixo dois exemplos, o primeiro executando um comando simples e outro um bloco (instrução composta)
//Comando simples if (expressão_de_teste_logico) instrução;
//Comando composto if (expressão_de_teste_logico) { instrução1; instrução2; instruçãoN; }
Comando if em estrutura if...else
Pode-se também determinar o que se deve fazer se o teste for falso. Neste caso em uma execução apenas um trecho será executado, não há possibilidade de ambos serem executados na mesma execução.
//Comando simples if (expressão_de_teste_logico) instrução1; else instrução2;
//Comando composto if (expressão_de_teste_logico) { instrução1; instrução2; instruçãoN; } else { instrução1_2; instrução2_2; instruçãoN_2; }
Comando if aninhado (em cascata)
Pode-se ainda configurar operadores if em cascata, desta forma pode-se testar diferentes condições lógicas. Apenas um trecho de código será executado em um ciclo de execução.
if (expressão_de_teste_logico_1) { instrução1_1; instrução2_1; instruçãoN_1; } else if(expressão_de_teste_logico_2) { instrução1_2; instrução2_2; instruçãoN_2; } else { instrução1_3; instrução2_3; instruçãoN_3; }
Operador ? :
Se assemelha ao "if...else". Primeiro se declara o teste lógico (fazendo a função do conteúdo entre parênteses do if), depois do "?" a instrução para caso verdadeiro (equivale ao comando simples após o if) e após ":" o comando se falso (equivale a instrução simples do else).
//Formato da estrutura "? :" //se o teste lógico der verdadeiro o instrução1 será executado, //caso contrário será executado o instrução2 expressão_teste_lógico ? instrução1 : instrução2;
Comando switch
Se assemelha ao if aninhado podendo tratar diversos casos, porém testa apenas uma variável de números inteiros. Tem a vantagem de ser mais eficiente e fácil de ler. É necessário ter ao menos um caso declarado. O operador default é opcional. Não é necessário usar "{}" para executar instruções em blocos dentro dos casos.
switch (valor_inteiro_a_ser_testado) { case constante1: instrução1; break; case constante2: instrução2; break; case constante1: instrução3; break; default : instrução4; break; }
Palavra-chave break
A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch.
Repetição
Laço while
Um laço while é como um "if" que se repete. Há portanto um teste lógico e caso seja verdadeiro a instrução simples ou bloco de instruções a seguir será executado. A diferença se comparado com o if é que após executar as instruções o programa volta a realizar o teste lógico podendo repetir a execução caso verdadeiro ou sair do laço while se falso. Este tipo de laço possibilita a condição de não haver execução das instruções internas caso a condição nunca seja tida como verdadeira.
//Comando simples while (expressão_de_teste_logico) instrução;
//Comando composto while (expressão_de_teste_logico) { instrução1; instrução2; instruçãoN; }
Laço do...while
Neste laço a expressão de teste é executada no final ao invés de ser no início como no while. Na prática as instruções no corpo da estrutura após o "do" serão executadas ao menos uma vez.
//Comando simples do instrução while(expressão_de_teste_logico);
//Comando composto do { instrução1; instrução2; instruçãoN; } while (expressão_de_teste_logico);
Laço for
Esta estrutura de repetição pode ser escrita de maneira mais compacta que um laço while e a estrutura já prevê ações típicas de um laço que são comandos de inicialização e modificadores pós execução do ciclo, além do teste lógico. Esta estrutura é muito utilizada quando o laço deve ser repetido uma quantidade conhecida de vezes. Sua estrutura é for(expressão1;expressão2;expressão3) onde a expressão1 será sempre executada e apenas uma vez ao iniciar o laço. A expressão2 é a expressão de teste, será sempre checada toda vez que se iniciar um ciclo de repetição, se verdadeira o corpo do comando será executado e a expressão3 será por fim processada. expressão1 é tipicamente utilizada para inicialização de variáveis e a expressão3 para incremento ou decremento de variáveis de controle.
//Comando simples for(expressão1; expressão2; expressão3) instrução;
//Comando composto for(expressão1; expressão2; expressão3) { instrução1; instrução2; instruçãoN; }
Palavras-chave das estruturas de repetição
break
A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch.
continue
A palavra-chave continue faz com que a corrente execução seja interrompida e se retorne ao teste lógico do laço. Se parece com o break mas ao invés de sair do laço, a execução continua testando. Serve para "pular" a execução do laço.