2.5 Caracteres char
3.4.4 Operadores de decremento e incremento
Os operadores de incremento e decremento são dois operadores essenciais na vida de qualquer programador. Imagine que necessita de contar um número cujo qual nem o programador sabe o fim. Vai adicionar/subtrair valor a valor? Não, não é necessário.
1 #include <stdio.h> 2 3 int main() { 4 int num; 5 6 num = 1;
3.4 Operadores lógicos 31
7 printf("O número é %d\n", num);
8
9 num = num + 1;
10 printf("O número é %d\n", num); 11
12 num += 1;
13 printf("O número é %d\n", num);
14
15 return 0; 16 }
O código acima imprime a frase “O número é x”, onde x corresponde ao valor da variável num nesse momento. Este algoritmo faz com que a variável inicialmente tenha um valor de 1, passando por 2, chegando finalmente a 3. As linhas num = num + 1 e num += 1 são equivalentes.
Existe outra forma mais simples para adicionar/subtrair um valor a uma variável: através dos operadores ++ e -. Veja como ficaria o código anterior com estes operadores:
1 #include <stdio.h> 2 3 int main() { 4 int num; 5 6 num = 1;
7 printf("O número é %d\n", num);
8
9 num++;
10 printf("O número é %d\n", num);
11
12 num++;
13 printf("O número é %d\n", num);
14
15 return 0;
16 }
Este último trecho de código irá imprimir o mesmo que o código anterior. Agora, a diferença aparenta não ser imensa, porém estes operadores serão extremamente úteis em testes lógicos/de repetição.
Para remover uma unidade bastaria colocar - ao invés de ++. Então podemos concluir que este operador torna o incremento/decremento mais rápido, mas só funciona quando o assunto é uma unidade. Veja o seguinte exemplo:
1 #include <stdio.h> 2 3 int main() { 4 int num; 5 6 num = 1;
7 printf("O número é %d\n", num);
8
9 num--;
10 printf("O número é %d\n", num);
11
12 return 0;
13 }
Posição do operador
Estes operadores podem ocupar duas posições: antes ou depois do nome da variável, ou seja, posso colocar tanto num++ como ++num. Quando são utilizados isoladamente, não existe nenhuma diferença. Porém, quando estamos a efetuar uma atribuição, existem diferenças. Analise o seguinte exemplo:
1 #include <stdio.h>
3.4 Operadores lógicos 32 3 int main() { 4 int a, b, c; 5 6 a = 0; 7 b = a++; 8 c = ++a; 9 10 printf("A: %d, B: %d, C: %d", a, b, c); 11 12 return 0; 13 }
Em primeiro lugar, são declaradas três variáveis: a, b e c. Seguidamente, é atribuído o valor 0 à primeira variável. Quando o valor a++ é atribuído à variável b, esta fica com valor 0 ou 1? E o que acontece com a variável a? A variável b irá assumir o valor 0, e um valor é incrementado a a ficando esta com o valor 1, ou seja, b = a++ é um atalho para o seguinte:
1 b = a;
2 a++;
Depois desta atribuição, é atribuída à variável c, o valor ++a, ou seja, primeiro é
incrementado o valor da variável a e só depois é que o valor de esta é atribuído à variável c. Então, isto é um atalho para o seguinte:
1 ++a;
Ca
pítulo
4
Controlo de Fluxo
Este quarto capítulo tem como objetivo mostrar-lhe as formas de controlar o fluxo de uma aplicação, de um algoritmo, de um programa.
Definição 21. Controlo de Fluxo refere-se ao controlo que se tem sobre a ordem de comandos a
serem executados no decorrer de um programa.
Ao controlar o fluxo pode-se direcionar o utilizador para as ações que este escolheu e executar apenas trechos de código dependendo de uma determinada condição, controlando a ordem pela qual os comandos são executados.
Existem diversas estruturas que nos permitem controlar o fluxo de uma aplicação. A maioria das que são aqui abordadas são transversais à maioria das linguagens de programação existentes. Antes de continuar aconselhamos a que reveja os operadores relacionais e lógicos no capítulo 3.
4.1
Estrutura if/else
A primeira estrutura a abordar é a conhecida if else o que, numa tradução literal para Portu- guês, quer dizer “se caso contrário”. Com esta estrutura, um determinado trecho de código pode ser executado dependendo do resultado de um teste lógico.
Definição 22. Um teste lógico consiste na determinação da verdade ou falsidade de uma condição.
Sintaxe
1 if (condição) {
2 // código a executar caso a condição seja verificada
3 } else {
4 // caso contrário, isto é executado.
5 }
Exemplo
Imagine que necessita criar um pequeno programa que deve imprimir se o valor de uma variável é maior, menor ou igual a 50. Como irá proceder? A criação deste algoritmo é deveras simples, bastando inicializar a variável e efetuar um teste lógico. Veja então como este problema poderia ser resolvido: 1 #include <stdio.h> 2 3 int main() { 4 int n = 25; 5 6 if (n >= 50) {
7 printf("O valor %d é maior ou igual a 50.", n); 8 } else {
4.2 Estrutura while 34
9 printf("O valor %d é menor que 50.", n);
10 }
11
12 return 0; 13 }
Se executar o trecho de código anterior, a mensagem O valor 25 é menor que 50. será imprimida, pois não se verificou a condição n >= 50, executando-se o código dentro do bloco else.
Imagine agora que precisa verificar as seguintes três condições: • É maior que 50?
• É igual a 50? • É menor que 50?
O caminho mais óbvio seria o seguinte:
1 if (n > 50) {
2 printf("O valor %d é maior que 50.\n", n);
3 }
4
5 if (n < 50) {
6 printf("O valor %d é menor que 50.\n", n);
7 }
8
9 if (n == 50) {
10 printf("A variável é igual a 50.\n"); 11 }
O algoritmo acima é um pouco repetitivo e extenso; pode ser simplificado ao ser agregado em apenas um teste sequencial como seguinte:
1 if (n == 50) {
2 printf("A variável é igual a 50.\n"); //A
3 } else if (n < 50) {
4 printf("O valor %d é menor que 50.\n", n); //B
5 } else {
6 printf("O valor %d é maior que 50.\n", n); //C
7 }
Podemos “traduzir” o código anterior para uma linguagem corrente da seguinte forma: Se n for igual a 50; então faz A, ou se n for menor que 50 faz B; caso contrário faz C.
4.2
Estrutura while
Outra estrutura para controlar o fluxo que é muito importante é a estrutura while, que em Português significa “enquanto”. Esta estrutura permite repetir um determinado trecho de código enquanto uma condição for verdadeira.
Sintaxe
1 while(condição) {
2 //Algo acontece
3 }
Ora vejamos um exemplo: precisa imprimir todos os números entre 0 e 100 (inclusive). Para isso não é necessário utilizar o comando printf 101 vezes, bastando utilizar a repetição while. Ora veja: 1 #include <stdio.h> 2 3 int main() { 4 int num = 0; 5
4.3 Estrutura switch 35 6 while(num <= 100) { 7 num++; 8 printf("%d\n", num); 9 } 10 11 return 0; 12 }
Pode-se traduzir o trecho anterior para uma linguagem corrente da seguinte forma: Enquanto num for menor ou igual a 100, imprime a variável num e incrementa-lhe um valor.
4.3
Estrutura switch
A estrutura switch está presente na maioria das linguagens de programação, que numa tradução literal para Português significa “interruptor”. Esta estrutura é deveras útil quando temos que executar uma ação dependendo do valor de uma variável.
A estrutura de controlo switch pode ser utilizada como forma de abreviar um teste lógico if elselongo. Sintaxe 1 switch(variavel) { 2 case "valorUm": 3 //Código da operação 4 break; 5 case "valorDois": 6 //Código da operação 7 break; 8 9 //... 10 11 default:
12 //Código executado caso não seja nenhuma das opções anteriores
13 break;
14 }
Imagine que tem que pedir ao utilizador um valor e que vai executar uma ação dependendo o valor que o utilizador escolheu. Esse menu tem 5 opções. Poderia resolver este problema da seguinte forma: 1 #include <stdio.h> 2 3 int main() { 4 int opcao; 5
6 printf("Insira a opção:\n");
7 scanf("%d", &opcao);
8
9 switch(opcao) { 10 case 1:
11 printf("Escolheu a opção 1");
12 break;
13 case 2:
14 printf("Escolheu a opção 2"); 15 break;
16 case 3:
17 printf("Escolheu a opção 3");
18 break; 19 case 4:
20 printf("Escolheu a opção 4");
21 break;
22 case 5:
23 printf("Escolheu a opção 5"); 24 break;
4.4 Estrutura do/while 36
26 printf("Opção inexistente.");
27 break;
28 }
29
30 return 0;
31 }
O código acima faz: em primeiro lugar, tudo depende do valor da variável opcao. Caso seja 1, será imprimida a mensagem Escolheu a opção 1 e por aí a diante. Caso a opção inserida não exista no código, o código contido em default irá ser executado.
Mais à frente iremos falar mais sobre o break. Por agora não lhe dê muita importância, mas coloque-o sempre.
O algoritmo anteriormente reproduzido pode também tomar a forma de uma sequência de if else, embora com uma menor legibilidade. Ora veja:
1 #include <stdio.h> 2
3 int main() {
4 int option;
5
6 printf("Insira a opção:\n"); 7 scanf("%d", &option);
8
9 if (option == 1) {
10 printf("Escolheu a opção 1");
11 } else if (option == 2) {
12 printf("Escolheu a opção 2");
13 } else if (option == 3) {
14 printf("Escolheu a opção 3");
15 } else if (option == 4) {
16 printf("Escolheu a opção 4"); 17 } else if (option == 5) {
18 printf("Escolheu a opção 5");
19 } else {
20 printf("Opção inexistente.");
21 } 22
23 return 0;
24 }
4.4
Estrutura do/while
Outra forma de controlar o fluxo a abordar é a estrutura do while, que tem um nome semelhante à já abordada while. A diferença existente entre essas duas estruturas é pequena, mas importante. Ao contrário do que acontece na estrutura while, no do while, o código é executado pri- meiro e só depois é que a condição é testada. Se a condição for verdadeira, o código é executado novamente. Podemos concluir que esta estrutura obriga o código a ser executado pelo menos uma vez.
Sintaxe
1 do
2 {
3 //código a ser repetido
4 } while (condição);
Imagine agora que precisa criar uma pequena calculadora (ainda em linha de comandos) que receba dois número e que, posteriormente, efetua uma soma, subtração, multiplicação ou divisão. Esta calculadora, após cada cálculo deverá pedir ao utilizador para inserir se quer continuar a realizar cálculos ou não. Poderíamos proceder da seguinte forma:
1 #include <stdio.h> 2
4.5 Estrutura for 37 4 int calcular; 5 6 do { 7 8 char operacao; 9 float num1, 10 num2; 11
12 // limpeza do buffer. ou __fpurge(stdin); em linux 13 fflush(stdin);
14
15 printf("Escolha a operação [+ - * / ]: ");
16 scanf("%c", &operacao);
17
18 printf("Insira o primeiro número: ");
19 scanf("%f", &num1);
20
21 printf("Insira o segundo número: ");
22 scanf("%f", &num2); 23
24 switch(operacao) {
25 case '+':
26 printf("%.2f + %.2f = %.2f\n", num1, num2, num1 + num2);
27 break; 28 case '-':
29 printf("%.2f - %.2f = %.2f\n", num1, num2, num1 - num2);
30 break;
31 case '*':
32 printf("%.2f * %.2f = %.2f\n", num1, num2, num1 * num2); 33 break;
34 case '/':
35 printf("%.2f / %.2f = %.2f\n", num1, num2, num1 / num2);
36 break;
37 default:
38 printf("Digitou uma operação inválida.\n"); 39 break;
40 }
41
42 printf("Insira 0 para sair ou 1 para continuar: "); 43 scanf("%d", &calcular);
44
45 /* Verifica-se o valor da variável calcular. Se for 0 é considerado falso
46 e o código não é executado mais vez nenhuma. Caso seja um número diferente
47 de 0, a condição retornará um valor que representa true (todos os números 48 exceto 0) e continuar-se-à a executar o código. */
49 } while (calcular); 50 51 return 0; 52 53 }
4.5
Estrutura for
A última estrutura de controlo de fluxo a abordar, mas não o menos importante, é a estrutura for. Esta estrutura loop é um pouco mais complexa que as anteriores, mas muito útil e permite reutilizar código.
Definição 23. O termo inglês loop refere-se a todas as estruturas que efetuam repetição: while,
do whilee for.
Sintaxe
1 for(inicio_do_loop ; condição ; termino_de_cada_iteração) {
2 //código a ser executado
3 }
4.6 Interrupção do fluxo 38
• inicio_do_loop → uma ação que é executada no início do ciclo das repetições; • condição → a condição para que o código seja executado;
• termino_de_cada_iteração → uma ação a executar no final de cada iteração.
Imagine agora que precisa de imprimir todos os números pares de 0 a 1000. Para isso poderia recorrer à estrutura while e a uma condição if da seguinte forma:
1 #include <stdio.h> 2 3 int main() { 4 int num = 0; 5 6 while (num <= 1000) { 7 if (num % 2 == 0) { 8 printf("%d\n", num); 9 } 10 11 num++; 12 } 13 14 return 0; 15 }
Utilizando a estrutura for, o algoritmo acima poderia ser reduzido ao seguinte:
1 #include <stdio.h> 2
3 int main() {
4 for(int num = 0; num <= 1000; num++) {
5 if (num % 2 = 0) { 6 printf("%d\n", num); 7 } 8 } 9 10 return 0; 11 }
4.6
Interrupção do fluxo
As estruturas de controlo de fluxo são muito importantes, mas aprender como se as interrompe também o é. Por vezes é necessário interromper uma determinada repetição dependendo de um teste lógico interno à repetição.