Programao em C/C++

Anexo II

ndice
Testes e Condies ............................................................................................................. 3 Introduo ........................................................................................................................ 3 Valores Lgicos Verdadeiro e Falso.............................................................................. 5 Operadores Relacionais ................................................................................................... 6 If-else ............................................................................................................................... 8 Bloco de Instrues ........................................................................................................ 13 Indentao ..................................................................................................................... 15 Instrues if-else encadeadas........................................................................................ 17 Bloco de Instrues ........................................................................................................ 21 Operadores Lgicos ....................................................................................................... 23 Resumo .......................................................................................................................... 25 Precedncia dos Operadores Lgicos e Relacionais ..................................................... 26 Operador Condicional - ? ............................................................................................... 28 switch ............................................................................................................................. 31 Funcionamento do Switch .............................................................................................. 31 break .............................................................................................................................. 34 Resumo ............................................................................................................................. 43 Exerccios .......................................................................................................................... 45 Bibliografia ......................................................................................................................... 50

Pgina 2

Testes e Condies
Introduo
At ao momento, os programas que fizemos esto particularmente adaptados a um mundo perfeito, sem erros, dvidas ou qualquer tipo de variaes. As instrues seguem-se umas s outras, seguindo sempre a mesma ordem de execuo quaisquer que sejam os valores de entrada. Com a matria apresentada at agora, podamos escrever um programa que tivesse por objectivo preparar uma pessoa para o seu dia de trabalho. Seria algo parecido a: Vestir Camisa Vestir Camisola Vestir Calas Calar Sapatos Pentear

No entanto basta pensar no nosso dia a dia, e verificar que mal nos levantamos uma das primeiras coisas que fazemos verificar qual o estado do tempo, de forma a decidir se devemos ir ou no mais agasalhados. No caso de nos encontrarmos em pleno Inverno, o programa anterior podia estar mais ou menos adaptado, no entanto, caso o sol brilhasse de forma abrasadora, talvez no fosse a melhor maneira de nos equiparmos para o trabalho, pois no faz qualquer sentido vestir camisolas durante o Vero.

Qual seria ento a soluo?

Se retirarmos a linha Vestir Camisola o programa fica adaptado ao Vero mas no ao Inverno. A soluo manter a linha Vestir Camisola no programa, e execut-la apenas quando a temperatura for suficientemente baixa.

Pgina 3

Ao contrrio dos programas anteriormente realizados, em que todas as instrues eram sempre executadas, podemos escrever programas que tenham a capacidade de tomar decises sobre que instrues executar.

Vestir Camisa Se estiver um frio de rachar ento Vestir Camisola Vestir Calas Calar Sapatos Pentear

No exemplo acima, a opo de Vestir Camisola, existe no programa mas s para dias de Inverno rigoroso. Este tipo de programao, no faz mais do que reflectir informaticamente a nossa actividade diria, sobre que produtos comprar, relao preo/qualidade, o que almoar, onde almoar, , um sem fim de opes que temos que tomar no dia a dia, e que vamos em seguida analisar como se pode implementar atravs da linguagem C.

Pgina 4

Valores Lgicos Verdadeiro e Falso

Como vimos no captulo anterior, a linguagem C possui apenas 4 tipos de dados (int, float, char e double), no existindo nenhum tipo que permita representar os valores lgicos (Verdade e Falso). Existem contudo linguagens que disponibilizam um tipo especfico para representar valores lgicos (Ex.: BOOLEAN em PASCAL, o qual pode receber os valores TRUE e FALSE). falsa.

Nota: Em C no existe nenhum tipo especfico de dados para armazenar valores lgicos. Nota: Em C o valor lgico FALSO representado por 0 (ZERO). Tudo aquilo que seja diferente de 0 (ZERO) representa o valor lgico VERDADEIRO

Exemplo: Falso: 0 Verdade : 2 , -3 , 123.45 , 0.000001

Nota: O valor lgico VERDADE em C no o valor 1, mas sim qualquer valor diferente de 0 (ZERO). O valor 1 apenas um dos valores possveis para representar VERDADE.

Os valores lgicos resultam, normalmente, de afirmaes que so analisadas e cuja avaliao determina se a afirmao verdadeira ou falsa.

Exemplos: A terra quadrada. (FALSO) O gelo apresenta-se no estado slido. (VERDADE) O valor 20 superior ao valor 14. (VERDADE) O valor 20 superior ao valor 34. (FALSO)

Pgina 5

Operadores Relacionais
Em C existe um conjunto de 6 operadores relacionais, os quais podem ser usados na avaliao de expresses. O seu objectivo consiste no estabelecimento de relaes entre os operandos.

Operador == > >= < <= !=

Nome Igualdade Maior que Maior ou Igual que Menor que Menor ou igual que Diferente de

Exemplo a == b a>b a >= b a<b a <= b a != b

Significado do Exemplo a igual a b? a maior que b? a maior ou igual que b? a menor que b? a menor ou igual que b? a diferente de b?

Nota: Uma expresso que contenha um operador relacional, devolve sempre como resultado o valor lgico VERDADE (1) ou FALSO (0).

Exemplo: Implementar um programa que solicite ao utilizador dois inteiros e, em seguida, aplique todos os operadores relacionais do C aos inteiros lidos.

prog0301.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int x, y; 6: printf (Introduza 2 inteiros: ); 7: scanf (%d%d, &x, &y); 8: printf (O resultado de %d == %d : %d\n, x, y, x==y); 9: printf (O resultado de %d > %d : %d\n, x, y, x>y); 10: printf (O resultado de %d >= %d : %d\n, x, y, x>=y); 11: printf (O resultado de %d < %d : %d\n, x, y, x<y); 12: printf (O resultado de %d <= %d : %d\n, x, y, x<=y); 13: printf (O resultado de %d != %d : %d\n, x, y, x!=y); 14: getch(); 15: } Pgina 6

$ prog0301 Introduza 2 inteiros: O resultado de 7 == O resultado de 7 > O resultado de 7 >= O resultado de 7 < O resultado de 7 <= O resultado de 7 != $ 5 5 5 5 5 5 7 : : : : : : 5 0 1 1 0 0 1

No exemplo anterior, as expresses so avaliadas e o resultado de cada avaliao escrito como inteiro, (0- Falso, 1- Verdade).

Exemplo: 4 >= 2 x <= y (x+y) < (x*2+y*(-4))

Nota: Um erro muito frequente em programao, a troca do operador == pelo operador =. O operador == verifica se duas expresses so iguais, enquanto o operador = utilizado para a atribuio de valores a variveis.

Pgina 7

If-else
A instruo if-else, uma das instrues de controlo de fluxo da linguagem C. Permite indicar quais as circunstncias em que determinada instruo ou conjunto de instrues deve ser executada.

A sua sintaxe : if (condio) instruo1; [ else instruo2; ]

Como se pode observar a componente else do if facultativa (parntesis rectos). Esta instruo permite a existncia de instrues que no sejam executadas num programa. Para tal basta que a condio necessria para a sua execuo, nunca se verifique.

A instruo if-else funciona da seguinte maneira: A condio avaliada; Se o resultado da condio for verdadeiro executa a instruo1; Se o resultado da condio for falso executa a instruo2 (caso exista o else).

Nota: A condio do if tem que estar sempre dentro de parntesis. Tanto a instruo1 como a instruo2 so seguidas de ponto e vrgula (;)

Exemplo: Implementar um programa que indique se um nmero positivo ou negativo.

Pgina 8

prog0302.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int x; 6: printf (Introduza um N ); 7: scanf (%d, &x); 8: if (x>=0) 9: printf (Nmero Positivo\n); 10: else 11: printf (Nmero Negativo\n); 12: getch(); 13: }

No exemplo anterior, solicitado e lido um inteiro (linhas 6: e 7:). Como se pretende indicar se o nmero lido positivo ou negativo, vamos testar se o nmero x maior ou igual a zero utilizando o operador relacional >= (linha 8:). Se o resultado da avaliao da expresso (x>=0) for Verdadeiro, ento invoca-se a funo printf com a string Nmero Positivo\n (linha 9:), caso contrrio, isto se a avaliao de (x>=0) devolver o valor Falso (zero), invoca-se a funo printf com a string Nmero Negativo\n (linha 11:). $ prog0302 Introduza um N 15 Nmero positivo $ prog0302 Introduza um N -15 Nmero Negativo

Pgina 9

Exemplo: Implementar um programa que indique se o inteiro lido zero ou no.

prog0303.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int x; 6: printf ( Introduza um N ); 7: scanf (%d, &x); 8: if (x!=0) 9: printf(%d no zero!!!\n,x); 10: else 11: printf(%d igual a zero!!!\n,x); 12: getch(); 13: }

Este programa semelhante ao anterior, s o tipo de teste que diferente, pois utiliza o operador != (diferente).

Repare-se agora no seguinte pormenor.

Quando o valor de x diferente de zero, o resultado da avaliao da expresso x!=0 devolve o valor Verdade. Ora como x diferente de zero (e como zero Falso e tudo o que diferente de zero representa Verdade), x representa por si s o valor lgico Verdade (pois diferente de zero). Por isso, escrever (x!=0) ou (x) exactamente a mesma coisa.

Exemplo: Valor de x 5 0 -5 Valor lgico representado por x Verdade Falso Verdade Valor lgico: x!=0 Verdade Falso Verdade

Pgina 10

Desta forma o programa anterior podia ter sido escrito da seguinte forma: prog0303.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int x; 6: printf ( Introduza um N ); 7: scanf (%d, &x); 8: if (x) /* em vez de if (x!=0) */ 9: printf(%d no zero!!!\n,x); 10: else 11: printf(%d igual a zero!!!\n,x); 12: getch(); 13: }

Como se pode verificar, existem mil e uma maneiras de escrever um programa correctamente. No entanto, nesta ltima verso perde-se legibilidade, uma vez que se aproveita o valor de uma varivel como valor lgico em vez de se usar x!=0, que representa o teste que na realidade pretendemos realizar.

Nota: Em C, o valor de uma varivel ou de uma constante, pode ser aproveitado pelo programador como valor lgico, utilizando-o como FALSO (caso 0) ou VERDADE (caso seja diferente de 0).

Em geral os programadores em C mais experientes gostam de escrever cdigo que mais ningum compreende, recorrendo a algumas caractersticas da prpria linguagem. No entanto, s vezes o cdigo por eles escrito de tal forma compacto ou confuso que at eles prprios muitas vezes tm dificuldades em o perceber.

Nota: Um programa deve estar escrito de tal maneira que um leve passar de olhos pelo cdigo indique ao leitor, sem sombra de dvidas, aquilo que a aplicao deve fazer. Exemplo: lmplementar um programa que adicione 5.00 ao salrio de um individuo, caso este seja inferior a 500.00. Pgina 11

prog0304.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario; 6: printf (Qual o Salrio ); 7: scanf (%f, &salario); 8: if (salario<500) 9: salario = salario+5; 10: printf (Salrio Final: %.2f\n,salario); 11: }

$ prog0304 Qual o Salrio 420 Salrio Final: 425.00 $ prog0304 Qual o Salrio 550 Salrio Final: 550.00 No programa prog0304.c, o salrio s adicionado em 5.00, caso o salrio seja inferior a 500.00. Neste caso, s nos interessa executar a linha 9: para os indivduos que estejam na condio de receberem menos de 500.00. Notar que embora o enunciado represente o valor como 500.00, este nmero informaticamente sempre representado por 500 ou 500.00. Aqueles que recebem 500.00 ou um valor superior ficam exactamente como esto, no havendo por isso necessidade de implementar um else.

Convm notar que a linha 10: printf (Salrio Final: %.2f\n,salario);

apresenta uma pequena novidade, que o formato de escrita do salrio.

Pgina 12

J sabamos que o formato de escrita de um float %f. Afim de evitar que este nos apresente um grande nmero de casas decimais, indicamos-lhe que a seguir ao ponto vm apenas dois dgitos (.2). Assim o real apresentado apresenta apenas 2 casas decimais mais significativas da sua parte fraccionria, no estando a parte inteira de algum modo limitada.

Bloco de Instrues
Como se pode observar pela sintaxe da instruo if-else, apenas UMA E UMA S INSTRUO pode seguir o if ou o else. Caso se deseje que um conjunto de instrues seja realizada quer no if quer no else, estas devem ser escritas entre { } de forma a que este conjunto de instrues forme apenas um nico Bloco de Instrues.

Um Bloco assim, um conjunto de duas ou mais instrues, delimitadas por chavetas.

Um Bloco pode ser colocado sem problemas num programa, no local em que possa estar uma instruo simples.

Nota: Depois de um Bloco no necessrio colocar ponto e vrgula (;)

Exemplo: Escrever um programa que leia dois nmeros e os apresente por ordem crescente.

Pgina 13

prog0305.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int x, y, tmp; 6: printf(lntroduza dois Numeros: ); 7: scanf(%d %d, &x, &y); 8: if (x >y) 9: { 10: tmp=x; 11: x=y; 12: y=tmp; 13: } 14: printf(%d %d\n,x, y); 15: getch(); 16: }

Convm reparar que, caso o valor de x seja maior que o valor de y, necessrio trocar os valores de x e y de forma que x tenha sempre o menor dos valores, evitando assim invocar duas vezes a funo printf para cada uma das situaes. A troca de dois valores sempre realizada em 3 passos, e necessita de uma varivel auxiliar. Suponhamos que queremos trocar o contedo de dois copos, um com sumo e outro com cerveja. Para tal, necessitamos de um copo adicional para nos ajudar a trocar os contedos sem os misturar.

Analogamente, para trocar quaisquer dois valores, sempre necessria uma 3 varivel do mesmo tipo, sendo a troca sempre realizada em trs passos. Como a troca est dependente do if e composta por 3 instrues, temos que as agrupar num nico bloco colocando chavetas volta. No caso da condio do if ser verdadeira, so executadas as 3 instrues do bloco. Caso contrrio, no executada nenhuma delas. O printf seguinte sempre executado, pois no depende da instruo if. Pgina 14

Indentao
Tal como vimos, nos captulos anteriores, um programa era sempre constitudo por um conjunto de instrues que era sempre completamente executado. Ao adicionarmos a instruo if-else, existem algumas instrues que podem vir ou no a ser executadas, dependendo das condies existentes ao longo do programa. Desta forma, algumas instrues esto dependentes da condio do if-else. comum aos programadores, indicarem a dependncia que certas instrues tm das instrues anteriores, colocando-as (n espaos ou um tab) mais frente do que as instrues de que dependem.

Verifique a diferena de escrita if (x!=0) printf(%d zero!!!\n, x); else printf(%d no zero!!!\n, x); else printf(%d no zero!!!\n, x); if (x!=0) printf(%d zero!!!\n, x);

Podemos observar, atravs de uma breve passagem com os olhos, no exemplo direita, que o primeiro printf depende do if e que o segundo printf depende do else, enquanto que no exemplo da esquerda temos alguma dificuldade em observar qual o encadeamento das instrues, pois esto todas colocadas ao mesmo nvel. a esta forma de organizao de cdigo, indicando visualmente as dependncias que as instrues tm umas das outras, que se chama Indentao. A indentao uma caracterstica pessoal de cada programador, no havendo nenhuma forma melhor que as outras. Exemplo A forma como eu indento os meus programas, no a forma como estes vulgarmente so apresentados em livros de C. Eu uso normalmente um tab ou dois espaos em branco, sempre que uma instruo depende de outra if (x>=0) printf(); Pgina 15

Sempre que necessrio a criao de um bloco, eu coloco o tab antes da chaveta que abre, e coloco o cdigo do bloco a dentro, ficando as chavetas { } ao mesmo nvel.

if (x>0) { printf (Um); printf(Dois); } else { printf(Dois); printf(Um); }

Assim, fcil de verificar quais as chavetas que abrem e quais as respectivas que fecham, pois esto sobre um mesmo plano vertical.

Mais uma vez, se repete, que o formato usado na indentao, uma caracterstica pessoal de cada programador. O que importante que o cdigo seja indentado e represente correctamente a hierarquia de instrues que se pretende executar.

O exemplo anteriormente apresentado, mostra a minha maneira pessoal de indentar um if com blocos. Em geral, os livros e programas publicados em C, apresentam uma outra forma de indentao.

if (x>0) { printf(Um); printf(Dois); } else { printf(Dois); printf(Um); } Neste caso, a abertura do bloco feita a seguir condio e o fecho do bloco fica indentado pela instruo que lhe deu origem (neste caso o if).

Nota: A indentao um processo que visa apresentar de forma visualmente simples, as dependncias exigentes num programa. O seu objectivo facilitar a vida ao programador ou a quem v ler o programa. A indentao no tem qualquer relevncia para o compilador. Este ignora simplesmente todos os espaos, linhas em branco e tabs que encontrar durante o processo de compilao. Pgina 16

Instrues if-else encadeadas

Existem situaes em que o teste de uma condio no suficiente para tomar uma deciso. Pode ser necessrio testar mais do que uma condio.

Exemplo: Escrever um programa que solicite um salrio ao utilizador e mostre o imposto a pagar. Se o salrio for negativo ou zero mostre o erro respectivo. Se o salrio for maior que 1000 paga 10% de imposto, seno paga apenas 5%. Para resolver este problema basta escrever o que foi dito antes, alterando os Se por ifelse.

prog0365.c (M implementao) 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario; 6: printf(Qual o salrio: ); 7: scanf(%f, &salario); 8: if (salario <= 0) 9: printf(Salrio: Valor Invlido\n); 10: if (salario > 1000) 11: printf(Imposto = %.2f\n, salario*0.10); 12: else 13: printf(Imposto = %.2f\n, salario*0.05); 14: getch(); 15: }

Pgina 17

Vejamos qual o resultado da execuo. $ prog0306 Qual o salrio: 2000 Imposto = 200.00 $ prog0306 Qual o salrio: 100 Imposto = 5.00 $ prog0306 Qual o salrio: -1000 salrio: Valor Invlido Imposto = -50.00

Como se pode observar, caso o valor do salrio seja positivo, os valores do correspondente imposto so apresentados correctamente (10% e 5%). No entanto, algo de estranho aparece quando o valor introduzido negativo. O que acontece no caso do salrio ser negativo (suponhamos -1000 como no exemplo), que o teste realizado na linha 8: devolve o valor Verdade (pois -1000 menor que zero), indo por isso escrever a mensagem de erro correspondente. A instruo if termina aqui. O programa vai passar prxima instruo que tambm um if, mas agora a condio (salario > 1000) devolve Falso. Como devolve Falso, no vai ser executada a instruo do if mas a que est escrita, relativa ao else e que corresponde ao valor do imposto a 5%.

O que que est errado?

Uma vez testado o primeiro if, e caso a resposta seja verdadeira, deve ser apresentada a correspondente mensagem de erro, no devendo ser realizado qualquer dos clculos de juros. Assim, o segundo if s deve ser executado caso o primeiro if devolva Falso. Deve ento comportar-se como o else do primeiro if, de forma a que s seja executado caso a condio (salario<=0) seja falsa.

Assim o programa prog0306.c deveria ser escrito da seguinte forma: Pgina 18

prog0306.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario; 6: printf(Qual o salrio: ); 7: scanf(%f, &salario); 8: if (salario<=0) 9: printf (Salrio: Valor Invlido\n); 10: else 11: if (salario > 1000) 12: printf(Imposto=%.2f\n, salario*0.10); 13: else 14: printf(Imposto = %.2f\n ,salario*0.05); 15: getch(); 16: }

$ prog0306 Qual osalrio: -1000 Salrio: Valor Invlido

Reparemos na indentao dos dois if-else. Notar que o if exterior no necessita de um bloco no else, porque o if interior uma nica instruo, apesar de conter um else.

Exemplo: Escrever um programa que calcule o Salrio Bruto, Salrio Lquido e Imposto a pagar, seguindo a seguinte regra:

Salrio <1000 >=1000 e <5000 >=5000

Taxa 5% 11 % 35 %

Pgina 19

prog0307.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario, taxa; 6: printf(Qual o salrio: ); 7: scanf(%f, &salario); 8: if (salario<1000) 9: taxa=.05; 10: else 11: if (salario < 5000) 12: taxa=.11; 13: else 14: taxa=.35; 15: printf (Salrio: %.2f Imposto: %.2f Lquido: %.2f\n, 16: salario, salario*taxa, salario*(1.0-taxa)); 17: getch(); 18: }

Convm reparar que aquilo que nos interessa descobrir qual a taxa a aplicar guardando esse valor na varivel taxa. Desta forma escrevemos apenas um printf qualquer que seja o salrio e qualquer que seja a taxa, evitando estar a escrever trs vezes o printf dentro de cada if para cada uma das trs taxas. Notar ainda que as condies escritas no cdigo do programa so mais simples do que as escritas no enunciado. Se algum apresentar um salrio de 3000, a primeira condio if(salario < 1000) devolve falso (linha 8:), entrando ento pelo primeiro else. Temos ento outro if e bastanos perguntar se o salrio menor que 5000 pois j temos a garantia que ele maior ou igual a mil, pois entrou pelo else do primeiro if.

Nota: necessrio ter algum cuidado com o clculo de taxas, pois a atribuio taxa=.05; no poderia ser substituda pela atribuio taxa=5/100, a qual iria devolver 0 (zero) pois trata-se de uma diviso inteira.

Pgina 20

Bloco de Instrues
Por vezes, as instrues if-else encadeadas podem causar alguns problemas se no forem utilizadas com cuidado.

Suponhamos o seguinte programa:

prog0308.c

(M indentao!!!)

1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: int a, b; 6: printf(lntroduza dois Numeros: ); 7: scanf(%d%d, &a, &b); 8: if (a >b) 9: if (b > 10) 10: printf(B muito grande\n); 11: else 12: printf(A tem um valor negativo\n); 13: getch(); 14: }

Como se pode observar pela indentao do programa, existe um if exterior que contm um else. Caso a condio do if exterior seja verdadeira vai executar o if interior. Ora, isto o que nos revela a indentao do programa, mas, como j foi atrs referido, a indentao serve unicamente para ajudar na leitura do cdigo, sendo completamente ignorada pelo compilador.

Nota: Sempre que existam instrues if-else encadeadas, cada componente else pertence sempre ao ltimo if (que ainda no tenha um else associado)

Pgina 21

if (cond1) if (cond2) if (cond3) instruo1 else instruo2 else instruo3 else instruo4

Assim, no programa anterior o else pertence ao if (b > 10) e no ao primeiro if, como nos era dado a perceber pela indentao do programa. Neste caso a indentao correcta seria: 8: 9: 10: 11: 12: else printf(A tem um valor negativo\n); if (a >= 0) if (b > 10) printf(B muito grande\n);

Mas este no era o nosso objectivo.

O nosso objectivo era que o else pertencesse ao primeiro if (exterior) e no ao segundo if (interior). Para resolver este problema, colocamos chavetas na instruo associada ao primeiro if. if (a >= 0) { if (b > 10) printf (B muito grande\n); } else printf(A tem um valor negativo\n); limitando assim o alcance do if interior ao bloco a que pertence.

Pgina 22

Nota: Se num conjunto de instrues if encadeadas, alguma delas no necessitar de else, deve-se colocar esta instruo entre chavetas para que o else de algum outro if mais exterior no seja associado erradamente a este if.

Operadores Lgicos
Existem circunstncias em que uma simples condio no chega para tomar uma deciso, sendo por isso necessrio a interligao de duas ou mais condies. Para tal, a maioria das linguagens coloca disposio um conjunto de operadores lgicos, os quais funcionam da mesma forma que os operadores aritmticos, mas aplicados a valores lgicos.

Operador && || !

Significado AND (E lgico) OR (OU lgico) NOT (Negao lgica)

Exemplo x>=1 && x<=19 x==1 || x==2 ! Continuar

Estes operadores permitem a combinao de duas ou mais expresses lgicas numa nica expresso, a qual devolve um nico valor lgico (Verdade ou Falso). Vejamos ento qual o resultado da aplicao destes operadores lgicos a duas condies:

Condio1 A terra redonda A terra redonda O carro um mamfero A terra redonda Representa Verdade Representa Falso

Operador && && && &&

Condio2 O homem um mamfero O carro um mamfero

Resultado

O homem um mamfero O carro um mamfero

Pgina 23

Como se pode observar, o resultado da aplicao do operador lgico && s igual a Verdade quando ambas as condies so verdadeiras, caso contrrio devolve sempre Falso. Normalmente os resultados destes operadores so apresentados em Tabelas de Verdade, em que se coloca numa coluna e numa linha os valores de Verdade e Falso. O resultado da aplicao do operador a cada um dos valores, pode ser obtido pela intercesso da linha e coluna pretendidas.

&& Verdade Falso

Verdade Verdade Falso

Falso Falso Falso

Resultado de Falso && Verdade

|| Verdade Falso

Verdade Verdade Verdade

Falso Verdade Falso

Resultado de Verdade || Falso

Verdade Falso

Falso Verdade

Resultado de ! Verdade

Nota: Os operadores lgicos && e || so operadores binrios, enquanto o operador relacional ! um operador unrio, sendo aplicado apenas a nica expresso ou condio.

Pgina 24

Nota: Na tabela anterior falamos de condies. No entanto, qualquer expresso em C pode ser utilizada como condio pois devolve um valor que pode ser utilizado como valor lgico. Nota: Embora (x==10 || 20) represente aquilo que ns dizemos quando queremos indicar que x tem que ser 10 ou 20, esta condio est informaticamente incorrecta. Aquilo que teremos de garantir que o valor de x seja 10 ou que o valor de x seja 20, devendo a respectiva condio ser (x==10 || x==20).

Resumo
Operador && II ! Exemplo (cond1 && cond2) (cond1 II cond2) (! cond) Resultado Verdade se ambas as condies forem verdadeiras, Falso caso contrrio. Verdade se alguma das condies for verdadeira, Falso se ambas forem falsas. Verdade se cond for falsa. Falso se cond for Verdadeira.

Notar que, no caso da expresso (x==10 || 20), o resultado desta avaliao sempre Verdade, independentemente do valor de x, pois realizado um OU com 20, que como diferente de zero representa o smbolo Verdade (verificar qual o resultado de um OU em que um dos operandos seja Verdade).

Exemplo: Escrever um programa que aplique uma taxa de imposto aos solteiros de 10% e 9% aos casados.

Pgina 25

prog0309.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario; 6: char est_civil; 7: printf (Qual o Salrio: ); 8: scanf ( %f , &salario); 9: printf (Qual o Est. Civil: ); 10: scanf ( %c ,&est_civil); 11: if (est_civil==C II est_civil==c) 12: printf(Imposto: %.2f\n,salario*0.09); 13: else 14: if (est_civil==S || est_civil==s) 15: printf(Imposto: %.2f\n,salario*0.10); 16: else 17: printf (Estado Civil Incorrecto!!!\n); 18: getch(); 19: }

Precedncia dos Operadores Lgicos e Relacionais

Em C, como na maioria das linguagens de programao, uma expresso nem sempre avaliada da esquerda para a direita. Por exemplo, a expresso 2+3*4 devolve o valor 14 e no 20 como seria de pensar se executasse (2+3)*4. Para definir a ordem pela qual as operaes so executadas, existe uma Tabela de Precedncias na qual est definida a precedncia de cada operador.

Operador < == && || ?: <= != > >=

Pgina 26

Nesta tabela esto indicados os operadores apresentados anteriormente. Convm reparar que eles ocupam patamares diferentes na hierarquia. A seta esquerda indica que, quanto mais elevado estiver um operador, maior a sua precedncia, isto , quando o compilador tem que decidir qual a ordem pela qual as operaes so realizadas, executa primeiro as operaes dos operadores com maior precedncia.

Suponhamos a seguinte expresso: if (x!=10 || y>1 && y<10)

O conjunto de operadores em competio : != , || , > , && , <

Pela tabela anteriormente apresentada, os operadores > e < so os que tm maior precedncia, por isso so realizadas as seguintes operaes: y>1 e y<10

Em seguida realizada a operao com o operador com a precedncia mais alta (!=), daquelas que ainda faltam realizar: x!=10

Ainda falta realizar as operaes || e &&. Convm reparar que em C o && tem maior precedncia que o ||.

Nota: Em C o operador && tem maior precedncia que o operador ||. Assim a operao AND (&&) vai ser realizada antes da operao OR (||). y>1 && y<10

E s ento que ao resultado desta operao realizado o OR (||) com x!=10. Resumidamente, podia-se representar a ordem das operaes atravs de parntesis if ((x!=10) || ((y>1) && (y <10))) Pgina 27

Operador Condicional - ?
Exemplo: Implementar um programa que calcule os aumentos de ordenado para o corrente ano. Se o ordenado for > 1000 deve ser aumentado 5%, seno deve ser aumentado 7%.

prog0310.c 1: #include <stdio.h> 2: #include <conio.h> 3: main() 4: { 5: float salario; 6: printf(Qual o Salrio: ); 7: scanf(%f,&salario); 8: if (salario > 1000) 9: salario = salario * 1.05; 10: else 11: salario = salario * 1.07; 12: printf(Novo Salrio: %.2f\n ,salario); 13: getch(); 14: }

Como se pode observar, o valor do novo salrio ir ser armazenado, em qualquer dos casos, dentro da mesma varivel. O que acontece que o novo valor a atribuir depende de uma determinada condio. Estamos perante um caso tpico, em que se deve usar um operador especial do C o Operador Condicional ?. O Operador Condicional ? o nico operador ternrio do C, o que indica que espera trs argumentos. A sua sintaxe :

condio ? expresso1 : expresso2

Funcionamento A condio avaliada. Se o resultado for Verdade, o resultado de toda a expresso o valor devolvido por expresso1. Se o resultado for Falso, o resultado de toda a expresso o valor devolvido por expresso2.

Pgina 28

O programa anterior poderia ser escrito da seguinte forma:

prog0310.c 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: #include <stdio.h> #include <conio.h> main() { float salario; printf (Qual o Salrio: ); scanf (%f ,&salario); salario=salario>1000 ? salario*1.05 : salario*1.07; printf(Novo Salrio: %.2f\n,salario); getch(); }

O operador ? devolve: o resultado de salario*1.05 se salario>1000 o resultado de salario*1.07, caso contrrio.

O resultado do operador ? ento atribudo varivel salario.

A linha 8: 8: salario=salario>1000 ? salario*1.05 : salario*1.07;

podia ter sido escrita de variadas formas: 8: salario=salario*(salario>1000) ? 1.05 : 1.07; 8: salario=salario*(1 + ((salario>1000) ? .05 : .07)); 8: salario=salario+salario*((salario>1000) ? .05 : .07);

Nota: Embora parecendo semelhantes, a instruo if-else e o operador ? no so iguais. O if-else indica quais as instrues a executar, enquanto o operador ? devolve sempre um resultado (coisa que o if no faz).

Exemplo: Implementar um programa que, dada uma letra, indique qual o estado civil de uma pessoa.

Pgina 29

prog0311.c 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: #include <stdio.h> #include <conio.h> main() { char Est_Civil; puts (Qual o Estado Civil: ); Est_Civil=getchar(); if (Est_Civil==S || Est_Civil==s) printf (Solteiro); else if (Est_Civil==C || Est_Civil==c) printf (Casado); else if (Est_Civil==D || Est_Civil==d) printf (Divorciado); else if (Est Civil==V || Est_Civil==v) printf (Vivo); else printf (Estado civil invlido); printf(\n); getch(); }

Como se pode facilmente observar, quando existem algumas condies diferentes possveis para o mesmo valor, torna-se impraticvel a utilizao da instruo if-else. O cdigo torna-se confuso e extenso. Para suprir este problema, o C fornece uma outra instruo que permite a seleco do cdigo a executar, a partir de um conjunto de valores possveis para uma determinada expresso Switch.

Pgina 30

switch
A instruo switch adapta-se particularmente tomada de decises em que o nmero de possibilidades elevada (em geral maior que 2, seno usa-se o if-else), de forma a reduzir a complexidade de if-else consecutivos e encadeados.

Sintaxe: switch (expresso) { case constante1: instrues1; case constante2: instrues2; ...... case constanten: instruesn; [default: instrues; ] }

Na sintaxe apresentada, expresso representa qualquer expresso cujo resultado seja um valor numrico dos tipos char, int ou long. A expresso avaliada, e em seguida o switch compara o resultado da expresso, com o valor de cada constantei que segue cada um dos case. O conjunto de todos os valores possveis para a expresso colocado entre chavetas.

Funcionamento do Switch
Se o valor da expresso for igual a alguma das constantes que seguem os vrios case, ento so executadas as instrues que seguem o case correspondente. Se o valor da expresso no for igual a nenhuma das constantes apresentadas pelos case, ento so executadas as instrues que seguem o default. Como se pode observar pela sintaxe, o default opcional. No caso do valor da expresso no ser igual a nenhum dos case, nada executado, terminando o switch. O programa continua na instruo a seguir ao switch.

Pgina 31

Nota: Em cada case do switch s pode estar presente para avaliao uma nica constante do tipo char, int ou long. Exemplo: Escrever um programa que indique qual o estado civil correspondente a um caracter introduzido em maisculas.

prog0312.c (M implementao!!!) 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: #include <stdio.h> #include <conio.h> main() { char Est_Civil; printf (Qual o estado Civil:); scanf( %c,&Est_Civil); /*ou Est_Civil = getchar();*/ switch (Est_Civil) { case C : printf(Casado\n); case S : printf(Solteiro\n); case D : printf ( Divorciado\n); case V : printf (Vivo\n); default : printf (Estado Civil Incorrecto\n); } getch(); }

No exemplo anterior, realizada a leitura de um caracter representativo do estado civil. o valor presente na varivel Est_Civil que teremos que estudar para saber que resultado colocar no ecr. Assim a varivel que vamos estudar a varivel Est_Civil (o que representado pela linha 8:) 8: switch (Est_Civil)

Os vrios valores que o Estado Civil pode conter so: C, S, D e V (respectivamente Casado, Solteiro, Divorciado e Vivo). Assim, para cada um dos vaIores possveis, deve existir um case.

Pgina 32

Notar que se est a trabalhar com caracteres, por isso devem ser colocados entre plicas simples. case C: printf(Casado\n); case S: printf(Solteiro\n); case D : printf(Divorciado\n); case V : printf(Vivo\n);

10: 11: 12: 13:

O default apresenta a mensagem a imprimir caso a varivel Est_Civil no seja igual a alguma das constantes presentes nos case. default : printf (Estado Civil Incorrecto\n);

14:

Depois dos dois pontos (:) de cada case, est colocada a instruo que queremos executar para esse case em particular.

Vamos ento testar o programa: $ prog0312 Qual o estado Civil: S Solteiro Divorciado Vivo Estado Civil Incorrecto $ prog0312 Qual o estado Civil: D Divorciado Vivo Estado Civil Incorrecto $ prog0312 Qual o estado civil: x Estado Civil Incorrecto Como se pode verificar, o programa tem um comportamento estranho, pois no indica qual o estado civil apropriado mas antes apresenta um conjunto de linhas que no eram esperadas. Pgina 33

Nota: Na instruo switch, quando a expresso igual a uma das constantes presentes num dos case, a instruo ou instrues associadas a esse case so executadas, bem como todas as instrues de todos os case que se encontrem a seguir ao case de entrada (default includo). Suponhamos que indicvamos D no estado civil. Caracter D 8: switch (Est_Civil) 9: { 10: case C : printf(Casado\n); 11: case S: printf(Solteiro\n); 12: case D: printf(Divorciado\n); 13: case V: printf(Vivo\n); 14: default : printf (Estado Civil Incorrecto\n); 15: } O switch vai realizar os testes e vai entrar no cdigo relativo ao case D: (linha 12:). A partir da vai executar todas as instrues que se encontrem associadas ao case de entrada ou a qualquer case que se siga (default includo) at chegar chaveta final do switch.

break
A instruo break permite parar a execuo dentro de um switch, continuando o programa na instruo imediatamente a seguir ao switch.

Nota: Sempre que existe coincidncia entre a expresso de um switch e uma das constantes possveis para essa expresso, so executadas todas as instrues associadas ao case correspondente e seguintes at que o switch termine ou seja encontrada a instruo break (ou seja encontrada a instruo return).

Apresenta-se agora o programa anterior correctamente escrito.

Pgina 34

prog0312.c 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: #include <stdio.h> #include <conio.h> main() { char Est_Civil; printf(Qual o estado Civil: ); scanf( %c ,&Est_Civil) ; /*ou Est_Civil = getchar();*/ switch (Est_Civil) { case C : printf(Casado\n); break; case S : printf(Solteiro\n); break; case D : printf(Divorciado\n); break; case V: printf(Vivo\n); break; default : printf(Estado Civil Incorrecto\n); } getch(); }

Como se pode observar, no necessrio a criao de um bloco { } a seguir a um case se este for constitudo por mais do que uma instruo, pois todas elas so executadas at se encontrar o break ou o final do switch.

$ prog0312 Qual o estado Civil: D Divorciado

Nota: O ltimo case ou o default de um switch no necessita de break, porque depois de executar as instrues associadas ao ltimo case, termina a instruo switch.

Exemplo: Alterar o programa anterior de maneira a funcionar com maisculas e minsculas.

Pgina 35

prog0313.c 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: #include <stdio.h> #include <conio.h> main() { char Est_Civil; printf (Qual o estado Civil: ); scanf( %c,&Est_Civil); /*ou Est_Civil = getchar();*/ switch(Est_Civil) { case c: case C: printf(Casado\n); break; case s: case S: printf(Solteiro\n); break; case d: case D : printf(Divorciado\n); break; case v: case V: printf(Vivo\n); break; default : printf (Estado Civil Incorrecto\n); } getch(); }

Repare-se que caso se escreva uma letra minscula (d por exemplo), o switch entra pelo case respectivo. Como as entradas relativas s letras minsculas no tm break, continua a executar o case seguinte (e que corresponde ao D) executando o printf respectivo. Em seguida encontra o break e termina a execuo do switch.

Exemplo: Escrever um programa que calcule o imposto pago por mulheres e por homens, sabendo que as mulheres pagam 10% de imposto e que os homens pagam mais 5% do que as mulheres.

prog314.c Pgina 36

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22:

#include <stdio.h> #include <conio.h> main() { float salario, imposto = 0.0; char sexo; printf(Introduza o Salrio: ); scanf(%f,&salario); printf(Qual o Sexo: ); scanf( %c,&sexo); switch (sexo) { case f: case F : imposto = 0.10; break; case m: case M : imposto = 0.15; break; } printf(Imposto %.2f \n ,salario*imposto); getch(); }

Esta a verso tradicional, usando a instruo break a seguir a cada uma das opes do switch.

Exemplo: Resolver este mesmo exerccio utilizando a instruo switch mas sem qualquer break.

Neste caso teremos que aproveitar a prpria estrutura do switch de forma a realizar os clculos correctamente. A leitura atenta do enunciado evidencia a seguinte frase sabendo que as mulheres pagam 10% de imposto e que os homens pagam mais 5% do que as mulheres.

Desta forma, os homens pagam aquilo que as mulheres pagam, acrescido de 5%.

Repare-se ento na resoluo:

prog315.c Pgina 37

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20:

#include <stdio.h> #include <conio.h> main() { float salario, imposto = 0.0; char sexo; printf(Introduza o Salrio: ); scanf(%f,&salario); printf(Qual o Sexo: ); scanf( %c,&sexo); switch (sexo) { case m : case M : imposto = imposto + 0.05; case f : case F: imposto = imposto + 0.10; } printf(Imposto %.2f \n ,salario*imposto); getch(); }

$ prog0314 Introduza o Salrio: 100 Qual o Sexo: m Imposto 15.00 $ prog0314 Introduza o Salrio: 100 Qual o Sexo: f Imposto 10.00

Como se pode observar, os valores apresentados esto correctos. Vamos ento tentar perceber qual a estratgia utilizada. Inicialmente a taxa de imposto colocada a 0.0. A varivel imposto vai servir de acumulador das taxas. Assim, se o utilizador for mulher, vamos entrar pelo case f ou F e a varivel imposto adicionada em 0.1 (0.0 + 0.10) que a taxa de imposto para as mulheres. Quanto aos homens, repare-se que eles tambm tm que pagar o mesmo imposto que as mulheres, mas tm que pagar ainda outros 5% adicionais. Assim, quando o switch detecta a entrada correspondente ao sexo masculino, adiciona a taxa de 5% (0.0 + 0.05) que o diferencial dos homens para as mulheres.

Pgina 38

Como no existe qualquer break, vo ser executadas todas as instrues presentes no switch e que so relativas s entradas f e F que adicionam os outros 10% varivel imposto, ficando esta correctamente inicializada. Obtm-se assim um acumulado que difere, caso se tenha entrado por f ou F (0.10) ou caso se tenha entrado por m ou M (0.15 = 0.05 + 0.10).

imposto a zero 5: float imposto = 0.0; ... 11: 12: 13: 14: 15: 16: 17: } switch (sexo) { case m: case M: imposto = imposto + 0.05; case f: case F : imposto = imposto + 0.10; imposto adicionado 10% imposto adicionado 5%

Imposto Total 10%

Imposto Total 15%

Exemplo: Escrever um programa que leia uma operao binria entre dois inteiros e apresente em seguida o resultado dessa operao sobre os dois inteiros.

Isto , o utilizador escreve uma expresso (por exemplo: 7+5) e o programa ter que ler os constituintes de uma expresso e escrever o seu resultado no ecr (7+5=12). No entanto, o utilizador pode representar a multiplicao como *, x ou X. A diviso pode ser representada pelos caracteres /, \ ou :

Pgina 39

prog0316.c (M Programao!!!) 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: #include <stdio.h> #include <conio.h> main() { int num1,num2; char op; printf(Escreva uma Expresso: ); scanf(%d %c %d ,&num1,&op,&num2); switch(op) { case + : printf(%d+%d=%d\n,num1,num2,num1+num2); break; case - : printf(%d-%d = %d\n,num1,num2,num1-num2); break; case * : /* Multiplicao */ case x : case X: printf(%d*%d = %d\n,num1,num2,num1*num2); break; case /: /* Diviso*/ case \\ : /* Caracter especial*/ case : : printf(%d / %d = %d\n,num1,num2,num1/num2); break; } getch(); }

Notar que o caracter \ um caracter especial, devendo ser precedido por uma outra \ para o representar. Embora o programa faa aquilo que foi solicitado, no est bem programado. Imaginemos que queramos alterar a forma como a expresso era escrita no ecr. Teramos assim que alterar todas as ocorrncias da funo printf dentro do switch.

O ideal seria alterar apenas uma vez. E assim se obtm o seguinte programa:

Pgina 40

prog0316.c 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: #include <stdio.h> #include <conio.h> main() { int num1, num2, res=0; char op; printf(Escreva uma Expresso: ); scanf(%d %c %d, &num1,&op,&num2); switch(op) { case + : res = num1+num2; break; case - : res = num1-num2; break; case *: case x: case X : res = num1*num2; break; case /: case \\: case : : res = num1/num2; break; } printf(%d %c %d = %d\n, num1, op, num2, res); getch(); }

Nesta nova verso, escrevemos o printf uma nica vez, pois no switch s nos interessa saber qual a operao que foi digitada afim de calcularmos o resultado correspondente. Primeiro calculamos o resultado atravs do switch. Depois de escolhido o case respectivo e guardado o valor da operao na varivel res, s nos resta sair do switch (atravs da instruo break) e invocar a funo printf com os valores respectivos.

Nota: O programa anteriormente apresentado, apresenta um pequeno defeito. Caso a operao seja invlida, apresenta-a mesma e coloca o resultado 0, facto que no acontecia na resoluo anterior.

Pgina 41

A Instruo switch (expresso) { case constante1: instrues1; break; case constante2: instrues2; break; case constanten: instruesn; break; [default: instrues] }

equivalente a if (expresso == constante1) instrues1; else if (expresso == constante2) instrues2; if (expresso == constanten) instruesn; else instrues; /* default */

Pgina 42

Resumo
Em C no existe um tipo especfico para armazenar valores lgicos. Estes so representados por 0-Falso e qualquer valor diferente de zero representa o valor Verdade. O contedo de uma varivel, ou o resultado de uma expresso, pode ser usado como valor lgico. Embora qualquer varivel ou expresso possa armazenar um valor lgico, totalmente desaconselhvel a utilizao de reais como valores lgicos devido aos erros de arredondamento. Por exemplo, uma varivel que seja sujeita a um conjunto de operaes que retorne 0 (zero) pode no representar o smbolo Falso mas sim Verdade por ter sido armazenado algum erro numrico, por menor que seja. Desta forma 0.000001 representa Verdade e no Falso. O teste de condies pode ser realizado atravs das instrues if-else e switch. Na instruo if-else, a condio avaliada e caso seja Verdadeira (isto , diferente de zero) executada a instruo associada ao if. A componente else executada quando a condio devolve o valor lgico Falso (zero). A componente else do if opcional. No caso de ser necessrio colocar mais do que uma instruo dentro de um if-else, tem que se criar uma instruo composta (uma instruo que composta por vrias instrues), colocando o conjunto de instrues entre chavetas. A esta estrutura chamase Bloco. Um Bloco no mais do que um conjunto de instrues organizada como um todo. Um Bloco pode ser sempre colocado no local em que uma instruo simples pode ocorrer. Em geral depois de um Bloco no necessrio colocar ponto e vrgula (;) . Uma caracterstica fundamental de qualquer programa correctamente escrito a Indentao. A indentao no tem qualquer efeito na compilao ou execuo do programa. Serve unicamente para representar as dependncias que algumas instrues tm de outras que as precedem. A indentao uma caracterstica pessoal de cada programador. possvel operar valores lgicos atravs dos operadores binrios && (AND) e || (OR) ou atravs do operador unrio ! (NOT). O operador && tem maior precedncia que o operador ||.

Pgina 43

Estes operadores permitem a combinao de duas ou mais expresses lgicas numa nica expresso, devolvendo um nico valor lgico como resultado da avaliao da expresso total. A instruo if-else pode ser evitada sempre que uma mesma varivel, dependendo de uma condio, possa receber dois valores diferentes. Neste caso, a instruo if-else pode ser substituda pelo operador condicional ?: . Afim de eliminar conjuntos extensos de instrues if-else encadeadas, o C coloca disposio dos programadores a instruo switch. Ao contrrio do if, que permite definir bandas de valores (x>=10 && x<=120), o switch s admite valores constantes predefinidos dos tipos char, int ou long. Depois da instruo switch verificar qual o case correspondente expresso avaliada, inicia a execuo na instruo associada a esse case, executando em seguida todas as instrues seguintes em cascata (incluindo as que pertenam a outros case) at terminar o switch ou at ser encontrada a instruo break. A instruo break permite parar a execuo de um conjunto de instrues dentro de um switch, continuando o programa na instruo imediatamente a seguir ao switch. Uma vez que o conjunto de instrues a executar dentro de um switch controlado pela instruo break, no necessrio o uso de chavetas para agrupar o conjunto de instrues associadas a um case.

Pgina 44

Exerccios
Grupo I
1. Escreva um programa que indique quantos segundos tem um determinado nmero de horas.

2. Altere o programa anterior de tal forma que permita indicar, a partir de um determinado n de Horas, quais os minutos, os segundos ou mesmo os dcimos de segundos, que esse n de horas contm.

3. Resolva o mesmo enunciado utilizando um switch.

4. Resolva o mesmo enunciado utilizando um switch mas sem qualquer break. Suponha que o n de horas est correctamente escrito.

Pgina 45

Grupo II
1. Porque razo no devem variveis do tipo float armazenar valores lgicos?

2. Indique quais das seguintes afirmaes so verdadeiras e quais so falsas: 2.1. O else de um if facultativo. 2.2. Num if so necessrios parntesis volta da condio. 2.3. O if pode conter a palavra then opcionalmente. 2.4. Tanto a componente if como a componente else s podem conter uma nica instruo. 2.5. O if tem que estar numa linha diferente do else. 2.6. Na condio do if pode ser colocada uma constante, uma varivel ou uma expresso.

3. Como consegue uma instruo if-else saber onde termina o if e comea o else ou se o if tem ou no else.

4. Um bloco pode ser constitudo por apenas uma instruo?

5. Depois de um bloco obrigatrio o uso de ; ?

6. Existe alguma diferena no funcionamento dos seguintes extractos? if(x = = 0) printf(X); else printf(Y); if(x=0) printf(X); else printf(Y);

7. A indentao facilita o processo de a) Compilao b) Linkagem c) Execuo d) Programao

Pgina 46

8. Um programa indentado em geral: a) Mais rpido a executar que outro que o no esteja. b) Mais lento a executar que outro que o no esteja. c) Mais legvel que outro que o no esteja. d) Menos legvel que outro que o no esteja.

9. Sempre que um compilador detecta cdigo mal indentado: a) Emite um erro. b) Emite um WARNING. c) Escreve o ficheiro correctamente indentado. d) Um compilador no faz qualquer tipo de verificao da indentao.

10. Indique duas vantagens e duas desvantagens do if-else em relao ao switch.

11. Ser que a instruo break, quando apresentada dentro de um if, passa a Execuo automaticamente para o else?

12. Qual o valor lgico que as seguintes expresses enviam para o if ? a) b) c) d) if (10 = =5) if ((2+3) = = - (-2 -3)) if (x = 5) if (x = 0)

13. Supondo x = 4, y = 6 e z = -1 a) b) c) d) if (x = =5) if (x = = 5 || z < 0) if (y x + z - 1) if (x = = 4 || y>=z && !(z) )

14. Escreva, utilizando um nico if, o seguinte cdigo.1 if (x = =0) if (y<=32) printf (Sucesso!!!);

Pgina 47

15. Identifique os erros de compilao que seriam detectados nos seguintes programas. 15.1 /* * Copyright: Asneira Suprema Software! ! ! */ #include <stdio.h> main () { int x; if (x = = 0) break; else printf(X no zero \n); }

15.2 /* * Copyright: Asneira Suprema Software! ! ! */ #include <stdio.h> main () { int x; if (x = = 0) then printf (X zero \n); else printf(X no zero \n); }

15.3 /* * Copyright: Asneira Suprema Software! ! ! */ #include <stdio.h> main () { int x; switch (x) { case 1: printf (um); break; case 2: printf (dois); break; else: printf (Nem um nem dois); } }

Pgina 48

16. Escreva um programa, de 4 formas distintas, que leia um inteiro e indique se esse inteiro ou no igual a zero.

17. Reescreva o programa anterior com um switch.

18. Escreva um programa que verifique se um ano bissexto ou no.

19. Escreva um programa que indique o n de dias que um ms tem (Fevereiro = 28 dias). 19.1 Usando apenas a instruo de teste if-else.

19.2 Usando o switch.

19.3 Usando o switch sem qualquer break.

20. Escreva um programa que leia uma data e verifique se esta vlida ou no.

Pgina 49

Bibliografia

Damas, Lus. Linguagem C 17 Edio. Lisboa: FCA Editora de Informtica

Pgina 50