AULA 3 - VARIÁVEIS, CONSTANTES, OPERADORES E EXPRESSÕES
Nomes de Variáveis
As variáveis no C podem ter qualquer nome se duas condições forem satisfeitas: o nome deve começar com uma letra ou sublinhado (_) e os caracteres subsequentes devem ser letras, números ou sublinhado (_). Há apenas mais duas restrições: o nome de uma variável não pode ser igual a uma palavra reservada, nem igual ao nome de uma função declarada pelo programador, ou pelas bibliotecas do C. Variáveis de até 32 caracteres são aceitas. Mais uma coisa: é bom sempre lembrar que o C é "case sensitive" e portanto deve-se prestar atenção às maiúsculas e minúsculas.
Dicas quanto aos nomes de variáveis...
- É uma prática tradicional do C, usar letras minúsculas para nomes de variáveis e maiúsculas para nomes de constantes. Isto facilita na hora da leitura do código;
- Quando se escreve código usando nomes de variáveis em português, evita-se possíveis conflitos com nomes de rotinas encontrados nas diversas bibliotecas, que são em sua maioria absoluta, palavras em inglês.
Os Tipos do C
O C tem 5 tipos básicos: char, int, float, void, double. Destes não vimos ainda os dois últimos: O double é o ponto flutuante duplo e pode ser visto como um ponto flutuante com muito mais precisão. O void é o tipo vazio, ou um "tipo sem tipo". A aplicação deste "tipo" será vista posteriormente.
Para cada um dos tipos de variáveis existem os modificadores de tipo. Os modificadores de tipo do C são quatro: signed, unsigned, long e short. Ao float não se pode aplicar nenhum e ao double pode-se aplicar apenas o long. Os quatro modificadores podem ser aplicados a inteiros. A intenção é que short e long devam prover tamanhos diferentes de inteiros onde isto for prático. Inteiros menores (short) ou maiores (long). int normalmente terá o tamanho natural para uma determinada máquina. Assim, numa máquina de 16 bits, int provavelmente terá 16 bits. Numa máquina de 32, int deverá ter 32 bits. Na verdade, cada compilador é livre para escolher tamanhos adequados para o seu próprio hardware, com a única restrição de que shorts ints e ints devem ocupar pelo menos 16 bits, longs ints pelo menos 32 bits, e short int não pode ser maior que int, que não pode ser maior que long int. O modificador unsigned serve para especificar variáveis sem sinal. Um unsigned int será um inteiro que assumirá apenas valores positivos. A seguir estão listados os tipos de dados permitidos e seu valores máximos e mínimos em um compilador típico para um hardware de 16 bits. Também nesta tabela está especificado o formato que deve ser utilizado para ler os tipos de dados com a função scanf():
| Tipo | Num de bits | Formato para leitura com scanf | Intervalo | |
| Inicio | Fim | |||
| char | 8 | %c | -128 | 127 |
| unsigned char | 8 | %c | 0 | 255 |
| signed char | 8 | %c | -128 | 127 |
| int | 16 | %i | -32.768 | 32.767 |
| unsigned int | 16 | %u | 0 | 65.535 |
| signed int | 16 | %i | -32.768 | 32.767 |
| short int | 16 | %hi | -32.768 | 32.767 |
| unsigned short int | 16 | %hu | 0 | 65.535 |
| signed short int | 16 | %hi | -32.768 | 32.767 |
| long int | 32 | %li | -2.147.483.648 | 2.147.483.647 |
| signed long int | 32 | %li | -2.147.483.648 | 2.147.483.647 |
| unsigned long int | 32 | %lu | 0 | 4.294.967.295 |
| float | 32 | %f | 3,4E-38 | 3.4E+38 |
| double | 64 | %lf | 1,7E-308 | 1,7E+308 |
| long double | 80 | %Lf | 3,4E-4932 | 3,4E+4932 |
O tipo long double é o tipo de ponto flutuante com maior precisão. É importante observar que os intervalos de ponto flutuante, na tabela acima, estão indicados em faixa de expoente, mas os números podem assumir valores tanto positivos quanto negativos.
Declaração e Inicialização de Variáveis
As variáveis no C devem ser declaradas antes de serem usadas. A forma geral da declaração de variáveis é:
tipo_da_variável lista_de_variáveis;
As variáveis da lista de variáveis terão todas o mesmo tipo e deverão ser separadas por vírgula. Como o tipo default do C é o int, quando vamos declarar variáveis int com algum dos modificadores de tipo, basta colocar o nome do modificador de tipo. Assim um long basta para declarar um long int.
Por exemplo, as declarações
char ch, letra;
long count;float pi;
declaram duas variáveis do tipo char (ch e letra), uma variavel long int (count) e um float pi.
Há três lugares nos quais podemos declarar variáveis. O primeiro é fora de todas as funções do programa. Estas variáveis são chamadas variáveis globais e podem ser usadas a partir de qualquer lugar no programa. Pode-se dizer que, como elas estão fora de todas as funções, todas as funções as vêem. O segundo lugar no qual se pode declarar variáveis é no início de um bloco de código. Estas variáveis são chamadas locais e só têm validade dentro do bloco no qual são declaradas, isto é, só a função à qual ela pertence sabe da existência desta variável, dentro do bloco no qual foram declaradas. O terceiro lugar onde se pode declarar variáveis é na lista de parâmetros de uma função. Mais uma vez, apesar de estas variáveis receberem valores externos, estas variáveis são conhecidas apenas pela função onde são declaradas.
Veja o programa abaixo:
#include <stdio.h>int contador;
int func1(int j) {/* aqui viria o código da funcao
...
*/ } int main() { char condicao; int i; for (i=0; i<100; i=i+1) { /* Bloco do for */ float f2;/* etc ...
... */ func1(i); } /* etc ... */ return(0);}
A variável contador é uma variável global, e é acessível de qualquer parte do programa. As variáveis condição e i, só existem dentro de main(), isto é são variáveis locais de main. A variável float f2 é um exemplo de uma variável de bloco, isto é, ela somente é conhecida dentro do bloco do for, pertencente à função main. A variável inteira j é um exemplo de declaração na lista de parâmetros de uma função (a função func1).
As regras que regem onde uma variável é válida chamam-se regras de escopo da variável. Há mais dois detalhes que devem ser ressaltados. Duas variáveis globais não podem ter o mesmo nome. O mesmo vale para duas variáveis locais de uma mesma função. Já duas variáveis locais, de funções diferentes, podem ter o mesmo nome sem perigo algum de conflito.
Podemos inicializar variáveis no momento de sua declaração. Para fazer isto podemos usar a forma geral
tipo_da_variável nome_da_variável = constante;
Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto significa que até que um primeiro valor seja atribuído à nova variável ela tem um valor indefinido e que não pode ser utilizado para nada. Nunca presuma que uma variável declarada vale zero ou qualquer outro valor. Exemplos de inicialização são dados abaixo :
char ch='D';int count=0;float pi=3.141;Ressalte-se novamente que, em C, uma variável tem que ser declarada no início de um bloco de código. Assim, o programa a seguir não é válido em C (embora seja válido em C++).
int main(){ int i; int j;j = 10;
int k = 20; /* Esta declaracao de variável não é válida, pois não está sendo feita no início do bloco */ return(0);}AUTO AVALIAÇÃO
Veja como você está:
Escreva um programa que declare uma variável inteira global e atribua o valor 10 a ela. Declare outras 5 variáveis inteiras locais ao programa principal e atribua os valores 20, 30, ..., 60 a elas. Declare 6 variáveis caracteres e atribua a elas as letras c, o, e, l, h, a . Finalmente, o programa deverá imprimir, usando todas as variáveis declaradas:
As variáveis inteiras contem os números: 10,20,30,40,50,60
O animal contido nas variáveis caracteres e' a coelha
Constantes são valores que são mantidos fixos pelo compilador. Já usamos constantes neste curso. São consideradas constantes, por exemplo, os números e caracteres como 45.65 ou 'n', etc...
Abaixo vemos as constantes relativas aos tipos básicos do C:
| Tipo de Dado | Exemplos de Constantes |
| char | 'b' '\n' '\0' |
| int | 2 32000 -130 |
| long int | 100000 -467 |
| short int | 100 -30 |
| unsigned int | 50000 35678 |
| float | 0.0 23.7 -12.3e-10 |
| double | 12546354334.0 -0.0000034236556 |
- Constantes hexadecimais e octais
Muitas vezes precisamos inserir constantes hexadecimais (base dezesseis) ou octais (base oito) no nosso programa. O C permite que se faça isto. As constantes hexadecimais começam com 0x. As constantes octais começam em 0.
Alguns exemplos:
| Constante | Tipo |
| 0xEF | Constante Hexadecimal (8 bits) |
| 0x12A4 | Constante Hexadecimal (16 bits) |
| 03212 | Constante Octal (12 bits) |
| 034215432 | Constante Octal (24 bits) |
Nunca escreva portanto 013 achando que o C vai compilar isto como se fosse 13. Na linguagem C 013 é diferente de 13!
- Constantes strings
Já mostramos como o C trata strings. Vamos agora alertar para o fato de que uma string "Joao" é na realidade uma constante string. Isto implica, por exemplo, no fato de que 't' é diferente de "t", pois 't' é um char enquanto que "t" é uma constante string com dois chars onde o primeiro é 't' e o segundo é '\0'.
O C utiliza, para nos facilitar a tarefa de programar, vários códigos chamados códigos de barra invertida. Estes são caracteres que podem ser usados como qualquer outro. Uma lista com alguns dos códigos de barra invertida é dada a seguir:
| Código | Significado |
| \b | Retrocesso ("back") |
| \f | Alimentação de formulário ("form feed") |
| \n | Nova linha ("new line") |
| \t | Tabulação horizontal ("tab") |
| \" | Aspas |
| \' | Apóstrofo |
| \0 | Nulo (0 em decimal) |
| \\ | Barra invertida |
| \v | Tabulação vertical |
| \a | Sinal sonoro ("beep") |
| \N | Constante octal (N é o valor da constante) |
| \xN | Constante hexadecimal (N é o valor da constante) |
Operadores Aritméticos e de Atribuição
Os operadores aritméticos são usados para desenvolver operações matemáticas. A seguir apresentamos a lista dos operadores aritméticos do C:
| Operador | Ação |
| + | Soma (inteira e ponto flutuante) |
| - | Subtração ou Troca de sinal (inteira e ponto flutuante) |
| * | Multiplicação (inteira e ponto flutuante) |
| / | Divisão (inteira e ponto flutuante) |
| % | Resto de divisão (de inteiros) |
| ++ | Incremento (inteiro e ponto flutuante) |
| -- | Decremento (inteiro e ponto flutuante) |
O C possui operadores unários e binários. Os unários agem sobre uma variável apenas, modificando ou não o seu valor, e retornam o valor final da variável. Os binários usam duas variáveis e retornam um terceiro valor, sem alterar as variáveis originais. A soma é um operador binário pois pega duas variáveis, soma seus valores, sem alterar as variáveis, e retorna esta soma. Outros operadores binários são os operadores - (subtração), *, / e %. O operador - como troca de sinal é um operador unário que não altera a variável sobre a qual é aplicado, pois ele retorna o valor da variável multiplicado por -1.
O operador / (divisão) quando aplicado a variáveis inteiras, nos fornece o resultado da divisão inteira; quando aplicado a variáveis em ponto flutuante nos fornece o resultado da divisão "real". O operador % fornece o resto da divisão de dois inteiros.
Assim seja o seguinte trecho de código:
int a = 17, b = 3;int x, y;
float z = 17. , z1, z2;
x = a / b;
y = a % b;
z1 = z / b;
z2 = a/b;
ao final da execução destas linhas, os valores calculados seriam x = 5, y = 2, z1 = 5.666666 e z2 = 5.0 . Note que, na linha correspondente a z2, primeiramente é feita uma divisão inteira (pois os dois operandos são inteiros). Somente após efetuada a divisão é que o resultado é atribuído a uma variável float.
Os operadores de incremento e decremento são unários que alteram a variável sobre a qual estão aplicados. O que eles fazem é incrementar ou decrementar, a variável sobre a qual estão aplicados, de 1. Então
x++; x--;são equivalentes a x=x+1;
x=x-1;
Estes operadores podem ser pré-fixados ou pós- fixados. A diferença é que quando são pré-fixados eles incrementam e retornam o valor da variável já incrementada. Quando são pós-fixados eles retornam o valor da variável sem o incremento e depois incrementam a variável. Então, em
x=23;y=x++;
teremos, no final, y=23 e x=24. Em
x=23;
y=++x;teremos, no final, y=24 e x=24. Uma curiosidade: a linguagem de programação C++ tem este nome pois ela seria um "incremento" da linguagem C padrão. A linguagem C++ é igual à linguagem C só que com extensões que permitem a programação orientada a objeto, o que é um recurso extra.
O operador de atribuição do C é o =. O que ele faz é pegar o valor à direita e atribuir à variável da esquerda. Além disto ele retorna o valor que ele atribuiu. Isto faz com que as seguintes expressões sejam válidas:
x=y=z=1.5; /* Expressao 1 */
if (k=w) ... /* Expressão 2 */
A expressão 1 é válida, pois quando fazemos z=1.5 ela retorna 1.5, que é passado adiante, fazendo y = 1.5 e posteriormente x = 1.5. A expressão 2 será verdadeira se w for diferente de zero, pois este será o valor retornado por k=w. Pense bem antes de usar a expressão dois, pois ela pode gerar erros de interpretação. Você não está comparando k e w. Você está atribuindo o valor de w a k e usando este valor para tomar a decisão.
AUTO AVALIAÇÃO
Veja como você está:
Diga o resultado das variáveis x, y e z depois da seguinte seqüência de operações:
int x,y,z;
x=y=10; z=++x;x=-x;
y++;x=x+y-(z--);
Operadores Relacionais e Lógicos
Os operadores relacionais do C realizam comparações entre variáveis.
São eles:
| Operador | Ação |
| > | Maior do que |
| >= | Maior ou igual a |
| < | Menor do que |
| <= | Menor ou igual a |
| == | Igual a |
| != | Diferente de |
Os operadores relacionais retornam verdadeiro (1) ou falso (0). Para verificar o funcionamento dos operadores relacionais, execute o programa abaixo:
/* Este programa ilustra o funcionamento dos operadores relacionais. */#include <stdio.h>int main(){ int i, j; printf("\nEntre com dois números inteiros: "); scanf("%d%d", &i, &j); printf("\n%d == %d é %d\n", i, j, i==j); printf("\n%d != %d é %d\n", i, j, i!=j); printf("\n%d <= %d é %d\n", i, j, i<=j); printf("\n%d >= %d é %d\n", i, j, i>=j); printf("\n%d < %d é %d\n", i, j, i<j); printf("\n%d > %d é %d\n", i, j, i>j); return(0);}Você pode notar que o resultado dos operadores relacionais é sempre igual a 0 (falso) ou 1 (verdadeiro).
Para fazer operações com valores lógicos (verdadeiro e falso) temos os operadores lógicos:
| Operador | Ação |
| && | AND (E) |
| || | OR (OU) |
| ! | NOT (NÃO) |
Usando os operadores relacionais e lógicos podemos realizar uma grande gama de testes. A tabela-verdade destes operadores é dada a seguir:
| p falso falso verdadeiro verdadeiro | q falso verdadeiro falso verdadeiro | p AND q falso falso falso verdadeiro | p OR q falso verdadeiro verdadeiro verdadeiro |
O programa a seguir ilustra o funcionamento dos operadores lógicos. Compile-o e faça testes com vários valores para i e j:
#include <stdio.h> int main(){ int i, j; printf("informe dois números(cada um sendo 0 ou 1): "); scanf("%d%d", &i, &j); printf("%d AND %d é %d\n", i, j, i && j); printf("%d OR %d é %d\n", i, j, i || j); printf("NOT %d é %d\n", i, !i);}Exemplo: No trecho de programa abaixo a operação j++ será executada, pois o resultado da expressão lógica é verdadeiro:
int i = 5, j =7;if ( (i > 3) && ( j <= 7) && ( i != j) ) j++;
V AND V AND V = V
Mais um exemplo. O programa abaixo, imprime na tela somente os números pares entre 1 e 100, apesar da variação de i ocorrer de 1 em 1:
/* Imprime os números pares entre 1 e 100. */
#include <stdio.h>int main(){ int i; for(i=1; i<=100; i++)if(!(i%2)) printf("%d ",i); /* o operador de resto dará falso (zero) */
} /* quando usada c/ número par. Esse resultado*/ /* é invertido pelo ! */- Operadores Lógicos Bit a Bit
O C permite que se faça operações lógicas "bit-a- bit" em números. Ou seja, neste caso, o número é representado por sua forma binária e as operações são feitas em cada bit dele. Imagine um número inteiro de 16 bits, a variável i, armazenando o valor 2. A representação binária de i, será: 0000000000000010 (quinze zeros e um único 1 na segunda posição da direita para a esquerda). Poderemos fazer operações em cada um dos bits deste número. Por exemplo, se fizermos a negação do número (operação binária NOT, ou operador binário ~ em C), isto é, ~i, o número se transformará em 1111111111111101. As operações binárias ajudam programadores que queiram trabalhar com o computador em "baixo nível". As operações lógicas bit a bit só podem ser usadas nos tipos char, int e long int. Os operadores são:
| Operador | Ação |
| & | AND |
| | | OR |
| ^ | XOR (OR exclusivo) |
| ~ | NOT |
| >> | Deslocamento de bits à direita |
| << | Deslocamento de bits à esquerda |
Os operadores &, |, ^ e ~ são as operações lógicas bit a bit. A forma geral dos operadores de deslocamento é:
valor>>número_de_deslocamentos
valor<<número_de_deslocamentos
O número_de_deslocamentos indica o quanto cada bit irá ser deslocado. Por exemplo, para a variável i anterior, armazenando o número 2:
i << 3; fará com que i agora tenha a representação binária: 0000000000010000, isto é, o valor armazenado em i passa a ser igual a 16.
AUTO AVALIAÇÃO
Veja como você está:
Diga se as seguintes expressões serão verdadeiras ou falsas:
-> ((10>5)||(5>10))
-> (!(5==6)&&(5!=6)&&((2>1)||(5<=4)))Expressões
Expressões são combinações de variáveis, constantes e operadores. Quando montamos expressões temos que levar em consideração a ordem com que os operadores são executados, conforme a tabela de precedências da linguagem C.
Exemplos de expressões:
Anos=Dias/365.25; i = i+3;
c= a*b + d/e;
c= a*(b+d)/e;
- Conversão de tipos em expressões
Quando o C avalia expressões onde temos variáveis de tipos diferentes o compilador verifica se as conversões são possíveis. Se não são, ele não compilará o programa, dando uma mensagem de erro. Se as conversões forem possíveis ele as faz, seguindo as regras abaixo:
- Todos os chars e short ints são convertidos para ints. Todos os floats são convertidos para doubles.
- Para pares de operandos de tipos diferentes: se um deles é long double o outro é convertido para long double; se um deles é double o outro é convertido para double; se um é long o outro é convertido para long; se um é unsigned o outro é convertido para unsigned.
- Expressões que Podem ser Abreviadas
O C admite as seguintes equivalências, que podem ser usadas para simplificar expressões ou para facilitar o entendimento de um programa:
| Expressão Original | Expressão Equivalente |
| x=x+k; | x+=k; |
| x=x-k; | x-=k; |
| x=x*k; | x*=k; |
| x=x/k; | x/=k; |
| x=x>>k; | x>>=k; |
| x=x<<k; | x<<=k; |
| x=x&k; | x&=k; |
| etc... | |
O operador , determina uma lista de expressões que devem ser executadas seqüencialmente. Em síntese, a vírgula diz ao compilador: execute as duas expressões separadas pela vírgula, em seqüência. O valor retornado por uma expressão com o operador , é sempre dado pela expressão mais à direita. No exemplo abaixo:
x=(y=2,y+3);o valor 2 vai ser atribuído a y, se somará 3 a y e o retorno (5) será atribuído à variável x . Pode-se encadear quantos operadores , forem necessários.
O exemplo a seguir mostra um outro uso para o operador , dentro de um for:
#include<stdio.h>int main(){ int x, y; for(x=0 , y=0 ; x+y < 100 ; ++x , y++) /* Duas variáveis de controle: x e y . Foi atribuído o valor zero a cada uma delas na inicialização do for e ambas são incrementadas na parte de incremento do for */ printf("\n%d ", x+y); /* o programa imprimirá os números pares de 2 a 98 */}- Tabela de Precedências do C
Esta é a tabela de precedência dos operadores em C. Alguns (poucos) operadores ainda não foram estudados, e serão apresentados em aulas posteriores.
| Maior precedência | () [] -> |
| | ! ~ ++ -- . -(unário) (cast) *(unário) &(unário) sizeof |
| | * / % |
| | + - |
| | << >> |
| | <<= >>= |
| | == != |
| | & |
| | ^ |
| | | |
| | && |
| | || |
| | ? |
| | = += -= *= /= |
| Menor precedência | , |
Uma dica aos iniciantes: Você não precisa saber toda a tabela de precedências de cor. É útil que você conheça as principais relações, mas é aconselhável que ao escrever o seu código, você tente isolar as expressões com parênteses, para tornar o seu programa mais legível.
Modeladores (Casts)
Um modelador é aplicado a uma expressão. Ele força a mesma a ser de um tipo especificado. Sua forma geral é:
(tipo)expressão
Um exemplo:
#include <stdio.h>
#include <stdio.h>
int main ()
{ int num; float f;num=10;
f=(float)num/7; /* Uso do modelador . Força a transformação de num em um float */ printf ("%f",f); return(0); }Se não tivéssemos usado o modelador no exemplo acima o C faria uma divisão inteira entre 10 e 7. O resultado seria 1 (um) e este seria depois convertido para float mas continuaria a ser 1.0. Com o modelador temos o resultado correto.
AUTO AVALIAÇÃO
Veja como você está:
Compile o exemplo acima sem usar o modelador, e verifique os resultados. Compile-o novamente usando o modelador e compare a saída com os resultados anteriores.
Aula 4 - ESTRUTURAS DE CONTROLE DE FLUXO
As estruturas de controle de fluxo são fundamentais para qualquer linguagem de programação. Sem elas só haveria uma maneira do programa ser executado: de cima para baixo comando por comando. Não haveria condições, repetições ou saltos. A linguagem C possui diversos comandos de controle de fluxo. É possível resolver todos os problemas sem utilizar todas elas, mas devemos nos lembrar que a elegância e facilidade de entendimento de um programa dependem do uso correto das estruturas no local certo.
O Comando if
Já introduzimos o comando if. Sua forma geral é:
if (condição) declaração;
A expressão, na condição, será avaliada. Se ela for zero, a declaração não será executada. Se a condição for diferente de zero a declaração será executada. Aqui reapresentamos o exemplo de um uso do comando if :
#include <stdio.h>int main (){ int num; printf ("Digite um numero: "); scanf ("%d",&num); if (num>10) printf ("\n\nO numero e maior que 10"); if (num==10) { printf ("\n\nVoce acertou!\n"); printf ("O numero e igual a 10."); } if (num<10) printf ("\n\nO numero e menor que 10"); return(0);}- O else
Podemos pensar no comando else como sendo um complemento do comando if. O comando if completo tem a seguinte forma geral:
if (condição) declaração_1;
else declaração_2;
else declaração_2;
A expressão da condição será avaliada. Se ela for diferente de zero a declaração 1 será executada. Se for zero a declaração 2 será executada. É importante nunca esquecer que, quando usamos a estrutura if-else, estamos garantindo que uma das duas declarações será executada. Nunca serão executadas as duas ou nenhuma delas. Abaixo está um exemplo do uso do if-else que deve funcionar como o programa da seção anterior.
#include <stdio.h>int main (){ int num; printf ("Digite um numero: "); scanf ("%d",&num); if (num==10) { printf ("\n\nVoce acertou!\n"); printf ("O numero e igual a 10.\n"); } else { printf ("\n\nVoce errou!\n"); printf ("O numero e diferente de 10.\n"); } return(0);}- O if-else-if
A estrutura if-else-if é apenas uma extensão da estrutura if-else. Sua forma geral pode ser escrita como sendo:
if (condição_1) declaração_1;
else if (condição_2) declaração_2;
else if (condição_3) declaração_3;
.
.
.
else if (condição_n) declaração_n;
else declaração_default;
else if (condição_2) declaração_2;
else if (condição_3) declaração_3;
.
.
.
else if (condição_n) declaração_n;
else declaração_default;
A estrutura acima funciona da seguinte maneira: o programa começa a testar as condições começando pela 1 e continua a testar até que ele ache uma expressão cujo resultado dê diferente de zero. Neste caso ele executa a declaração correspondente. Só uma declaração será executada, ou seja, só será executada a declaração equivalente à primeira condição que der diferente de zero. A última declaração (default) é a que será executada no caso de todas as condições darem zero e é opcional.
Um exemplo da estrutura acima:
#include <stdio.h>int main (){ int num; printf ("Digite um numero: "); scanf ("%d",&num); if (num>10) printf ("\n\nO numero e maior que 10"); else if (num==10) { printf ("\n\nVoce acertou!\n"); printf ("O numero e igual a 10."); } else if (num<10) printf ("\n\nO numero e menor que 10"); return(0);}- A expressão condicional
Quando o compilador avalia uma condição, ele quer um valor de retorno para poder tomar a decisão. Mas esta expressão não necessita ser uma expressão no sentido convencional. Uma variável sozinha pode ser uma "expressão" e esta retorna o seu próprio valor. Isto quer dizer que teremos as seguintes expressões:
int num;if (num!=0) ....
if (num==0) ....for (i = 0; string[i] != '\0'; i++)equivalem a
int num; if (num) .... if (!num) .... for (i = 0; string[i]; i++)Isto quer dizer que podemos simplificar algumas expressões simples. - ifs aninhados
O if aninhado é simplesmente um if dentro da declaração de um outro if externo. O único cuidado que devemos ter é o de saber exatamente a qual if um determinado else está ligado.
Vejamos um exemplo:
#include <stdio.h>int main (){ int num; printf ("Digite um numero: "); scanf ("%d",&num); if (num==10) { printf ("\n\nVoce acertou!\n"); printf ("O numero e igual a 10.\n"); } else { if (num>10) { printf ("O numero e maior que 10."); } else { printf ("O numero e menor que 10."); } } return(0);}- O Operador ?
Uma expressão como:
if (a>0) b=-150;else b=150;pode ser simplificada usando-se o operador ? da seguinte maneira: b=a>0?-150:150;De uma maneira geral expressões do tipo:
if (condição)
expressão_1;
else
expressão_2;
podem ser substituídas por: condição?expressão_1:expressão_2;
O operador ? é limitado (não atende a uma gama muito grande de casos) mas pode ser usado para simplificar expressões complicadas. Uma aplicação interessante é a do contador circular.
Veja o exemplo:
#include <stdio.h>int main(){ int index = 0, contador; char letras[5] = "Joao"; for (contador=0; contador < 1000; contador++) { printf("\n%c",letras[index]); (index==3) ? index=0: ++index; }} O nome Joao é escrito na tela verticalmente até a variável contador determinar o término do programa. Enquanto isto a variável index assume os valores 0, 1, 2, 3, , 0, 1, ... progressivamente.
AUTO-AVALIAÇÃOVeja como você está:
Altere o último exemplo para que ele escreva cada letra 5 vezes seguidas. Para isto, use um 'if' para testar se o contador é divisível por cinco (utilize o operador %) e só então realizar a atualização em index.
O Comando switch
O comando if-else e o comando switch são os dois comandos de tomada de decisão. Sem dúvida alguma o mais importante dos dois é o if, mas o comando switch tem aplicações valiosas. Mais uma vez vale lembrar que devemos usar o comando certo no local certo. Isto assegura um código limpo e de fácil entendimento. O comando switch é próprio para se testar uma variável em relação a diversos valores pré-estabelecidos. Sua forma geral é:
switch (variável){
case constante_1:
declaração_1;
break;
case constante_2:
declaração_2;
break;
.
.
.
case constante_n:
declaração_n;
break;
default
declaração_default;
}
declaração_1;
break;
case constante_2:
declaração_2;
break;
.
.
.
case constante_n:
declaração_n;
break;
default
declaração_default;
}
Podemos fazer uma analogia entre o switch e a estrutura if-else-if apresentada anteriormente. A diferença fundamental é que a estrutura switch não aceita expressões. Aceita apenas constantes. O switch testa a variável e executa a declaração cujo case corresponda ao valor atual da variável. A declaração default é opcional e será executada apenas se a variável, que está sendo testada, não for igual a nenhuma das constantes.
O comando break, faz com que o switch seja interrompido assim que uma das declarações seja executada. Mas ele não é essencial ao comando switch. Se após a execução da declaração não houver um break, o programa continuará executando. Isto pode ser útil em algumas situações, mas eu recomendo cuidado. Veremos agora um exemplo do comando switch:
#include <stdio.h>int main (){ int num; printf ("Digite um numero: "); scanf ("%d",&num); switch (num) { case 9: printf ("\n\nO numero e igual a 9.\n"); break; case 10: printf ("\n\nO numero e igual a 10.\n"); break; case 11: printf ("\n\nO numero e igual a 11.\n"); break; default: printf ("\n\nO numero nao e nem 9 nem 10 nem 11.\n"); } return(0);}AUTO AVALIAÇÃO
Veja como você está.
Escreva um programa que pede para o usuário entrar um número correspondente a um dia da semana e que então apresente na tela o nome do dia. utilizando o comando switch.
O Comando for
for é a primeira de uma série de três estruturas para se trabalhar com loops de repetição. As outras são while e do. As três compõem a segunda família de comandos de controle de fluxo. Podemos pensar nesta família como sendo a das estruturas de repetição controlada.
Como já foi dito, o loop for é usado para repetir um comando, ou bloco de comandos, diversas vezes, de maneira que se possa ter um bom controle sobre o loop. Sua forma geral é:
for (inicialização;condição;incremento) declaração;
O melhor modo de se entender o loop for é ver como ele funciona "por dentro". O loop for é equivalente a se fazer o seguinte:
inicialização;
if (condição)
{
declaração;
incremento;
"Volte para o comando if"
}
Podemos ver, então, que o for executa a inicialização incondicionalmente e testa a condição. Se a condição for falsa ele não faz mais nada. Se a condição for verdadeira ele executa a declaração, faz o incremento e volta a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa. Um ponto importante é que podemos omitir qualquer um dos elementos do for, isto é, se não quisermos uma inicialização poderemos omiti-la. Abaixo vemos um programa que coloca os primeiros 100 números inteiros na tela:
#include <stdio.h>int main (){ int count; for (count=1; count<=100; count++) printf ("%d ",count);return(0);
}Note que, no exemplo acima, há uma diferença em relação ao exemplo anterior. O incremento da variável count é feito usando o operador de incremento que nós agora já conhecemos. Esta é a forma usual de se fazer o incremento (ou decremento) em um loop for.
O for na linguagem C é bastante flexível. Temos acesso à inicialização, à condição e ao incremento. Qualquer uma destas partes do for pode ser uma expressão qualquer do C, desde que ela seja válida. Isto nos permite fazer o que quisermos com o comando. As três formas do for abaixo são válidas:
for ( count = 1; count < 100 ; count++) { ... }for (count = 1; count < NUMERO_DE_ELEMENTOS ; count++) { ... }for (count = 1; count < BusqueNumeroDeElementos() ; count+=2) { ... }etc ...Preste atenção ao último exemplo: o incremento está sendo feito de dois em dois. Além disto, no teste está sendo utilizada uma função (BusqueNumeroDeElementos() ) que retorna um valor que está sendo comparado com count.
- O loop infinito
O loop infinito tem a forma
for (inicialização; ;incremento) declaração;
Este loop chama-se loop infinito porque será executado para sempre (não existindo a condição, ela será sempre considerada verdadeira), a não ser que ele seja interrompido. Para interromper um loop como este usamos o comando break. O comando break vai quebrar o loop infinito e o programa continuará sua execução normalmente.
Como exemplo vamos ver um programa que faz a leitura de uma tecla e sua impressão na tela, até que o usuario aperte uma tecla sinalizadora de final (um FLAG). O nosso FLAG será a letra 'X'. Repare que tivemos que usar dois scanf() dentro do for. Um busca o caractere que foi digitado e o outro busca o outro caracter digitado na seqüência, que é o caractere correspondente ao <ENTER>.
#include <stdio.h>int main (){ int Count; char ch; printf(" Digite uma letra - <X para sair> ");for (Count=1;;Count++)
{ scanf("%c", &ch); if (ch == 'X') break; printf("\nLetra: %c \n",ch);scanf("%c", &ch);
} return(0);}- O loop sem conteúdo
Loop sem conteúdo é aquele no qual se omite a declaração. Sua forma geral é (atenção ao ponto e vírgula!):
for (inicialização;condição;incremento);
Uma das aplicações desta estrutura é gerar tempos de espera.
O programa
#include <stdio.h>int main (){ long int i;printf("\a"); /* Imprime o caracter de alerta (um beep) */
for (i=0; i<10000000; i++); /* Espera 10.000.000 de iteracoes */ printf("\a"); /* Imprime outro caracter de alerta */ return(0);}faz isto. AUTO AVALIAÇÃO
Veja como você está.
Faça um programa que inverta uma string: leia a string com gets e armazene-a invertida em outra string. Use o comando for para varrer a string até o seu final.
O Comando while
O comando while tem a seguinte forma geral:
while (condição) declaração;
Assim como fizemos para o comando for, vamos tentar mostrar como o while funciona fazendo uma analogia. Então o while seria equivalente a:
if (condição) {
declaração;
"Volte para o comando if"
}
Podemos ver que a estrutura while testa uma condição. Se esta for verdadeira a declaração é executada e faz-se o teste novamente, e assim por diante. Assim como no caso do for, podemos fazer um loop infinito. Para tanto basta colocar uma expressão eternamente verdadeira na condição. Pode-se também omitir a declaração e fazer um loop sem conteúdo. Vamos ver um exemplo do uso do while. O programa abaixo é executado enquanto i for menor que 100. Veja que ele seria implementado mais naturalmente com um for ...
#include <stdio.h>int main (){ int i = 0; while ( i < 100) { printf(" %d", i);i++;
} return(0);}O programa abaixo espera o usuário digitar a tecla 'q' e só depois finaliza:
#include <stdio.h>int main (){ char Ch; Ch='\0'; while (Ch!='q') { scanf("%c", &Ch);}
return(0);}
AUTO AVALIAÇÃO
Veja como você está:
Refaça o programa da página anterior. Use o comando while para fechar o loop.
O Comando do-while
A terceira estrutura de repetição que veremos é o do-while de forma geral:
do
{
declaração;
} while (condição);
} while (condição);
Mesmo que a declaração seja apenas um comando é uma boa prática deixar as chaves. O ponto-e- vírgula final é obrigatório. Vamos, como anteriormente, ver o funcionamento da estrutura do-while "por dentro":
declaração;
if (condição) "Volta para a declaração"
if (condição) "Volta para a declaração"
Vemos pela análise do bloco acima que a estrutura do-while executa a declaração, testa a condição e, se esta for verdadeira, volta para a declaração. A grande novidade no comando do-while é que ele, ao contrário do for e do while, garante que a declaração será executada pelo menos uma vez.
Um dos usos da extrutura do-while é em menus, nos quais você quer garantir que o valor digitado pelo usuário seja válido, conforme apresentado abaixo:
#include <stdio.h>int main (){ int i; do { printf ("\n\nEscolha a fruta pelo numero:\n\n"); printf ("\t(1)...Mamao\n"); printf ("\t(2)...Abacaxi\n"); printf ("\t(3)...Laranja\n\n");scanf("%d", &i);
} while ((i<1)||(i>3)); switch (i)
{ case 1: printf ("\t\tVoce escolheu Mamao.\n"); break; case 2: printf ("\t\tVoce escolheu Abacaxi.\n"); break; case 3: printf ("\t\tVoce escolheu Laranja.\n"); break; } return(0);}AUTO AVALIAÇÃO
Veja como você está.
Refaça o exercício da página c410.html utilizando o laço do-while para controlar o fluxo.
O Comando break
Nós já vimos dois usos para o comando break: interrompendo os comandos switch e for. Na verdade, estes são os dois usos do comando break: ele pode quebrar a execução de um comando (como no caso do switch) ou interromper a execução de qualquer loop (como no caso do for, do while ou do do while). O break faz com que a execução do programa continue na primeira linha seguinte ao loop ou bloco que está sendo interrompido.
Observe que um break causará uma saída somente do laço mais interno. Por exemplo:
for(t=0; t<100; ++t){ count=1; for(;;) { printf("%d", count);count++;
if(count==10) break; }}O código acima imprimirá os números de 1 a 10 cem vezes na tela. Toda vez que o break é encontrado, o controle é devolvido para o laço for externo.
Outra observaçao é o fato que um break usado dentro de uma declaraçao switch afetará somente os dados relacionados com o switch e nao qualquer outro laço em que o switch estiver.
O Comando continue
O Comando continue
O comando continue pode ser visto como sendo o oposto do break. Ele só funciona dentro de um loop. Quando o comando continue é encontrado, o loop pula para a próxima iteração, sem o abandono do loop, ao contrário do que acontecia no comando break. O programa abaixo exemplifica o uso do continue:
#include <stdio.h>
int main(){ int opcao;while (opcao != 5)
{
printf("\n\n Escolha uma opcao entre 1 e 5: ");
scanf("%d", &opcao);
if ((opcao > 5)||(opcao <1)) continue; /* Opcao invalida: volta ao inicio do loop */
switch (opcao)
{
case 1:
printf("\n --> Primeira opcao..");
break;
case 2:
printf("\n --> Segunda opcao..");
break;
case 3:
printf("\n --> Terceira opcao..");
break;
case 4: printf("\n --> Quarta opcao.."); break; case 5: printf("\n --> Abandonando..");
break;
}
}
return(0);
}
O programa acima ilustra uma aplicação simples para o continue. Ele recebe uma opção do usuario. Se esta opção for inválida, o continue faz com que o fluxo seja desviado de volta ao início do loop. Caso a opção escolhida seja válida o programa segue normalmente.
O Comando goto
Vamos mencionar o goto apenas para que você saiba que ele existe. O goto é o último comando de controle de fluxo. Ele pertence a uma classe à parte: a dos comandos de salto incondicional. O goto realiza um salto para um local especificado. Este local é determinado por um rótulo. Um rótulo, na linguagem C, é uma marca no programa. Você dá o nome que quiser a esta marca. Podemos tentar escrever uma forma geral:
nome_do_rótulo:
....
goto nome_do_rótulo;
....
Devemos declarar o nome do rótulo na posição para a qual vamos dar o salto seguido de :. O goto pode saltar para um rótulo que esteja mais à frente ou para trás no programa. Uma observação importante é que o rótulo e o goto devem estar dentro da mesma função. Como exemplo do uso do goto vamos reescrever o equivalente ao comando for apresentado na seção equivalente ao mesmo:
inicialização;
início_do_loop: if (condição)
{
declaração;
incremento;
goto início_do_loop;
}
declaração;
incremento;
goto início_do_loop;
}
O comando goto deve ser utilizado com parcimônia, pois o abuso no seu uso tende a tornar o código confuso. O goto não é um comando necessário, podendo sempre ser substituído por outras estruturas de controle. Recomendamos que o goto nunca seja usado.
Existem algumas situações muito específicas onde o comando goto pode tornar um código mais fácil de se entender se ele for bem empregado. Um caso em que ele pode ser útil é quando temos vários loops e ifs aninhados e se queira, por algum motivo, sair destes loops e ifs todos de uma vez. Neste caso um goto resolve o problema mais elegantemente que vários breaks, sem contar que os breaks exigiriam muito mais testes. Ou seja, neste caso o goto é mais elegante e mais rápido.
O exemplo da página anterior pode ser reescrito usando-se o goto:
#include <stdio.h>int main(){ int opcao; while (opcao != 5) { REFAZ: printf("\n\n Escolha uma opcao entre 1 e 5: "); scanf("%d", &opcao); if ((opcao > 5)||(opcao <1)) goto REFAZ; /* Opcao invalida: volta ao rotulo REFAZ */ switch (opcao) { case 1: printf("\n --> Primeira opcao.."); break; case 2: printf("\n --> Segunda opcao.."); break; case 3: printf("\n --> Terceira opcao..");break;
case 4: printf("\n --> Quarta opcao.."); break; case 5: printf("\n --> Abandonando..");
break; } } return(0);} AUTO AVALIAÇÃO
Escreva um programa que peça três inteiros, correspondentes a dia , mês e ano. Peça os números até conseguir valores que estejam na faixa correta (dias entre 1 e 31, mês entre 1 e 12 e ano entre 1900 e 2100). Verifique se o mês e o número de dias batem (incluindo verificação de anos bissextos). Se estiver tudo certo imprima o número que aquele dia corresponde no ano. Comente seu programa. PS: Um ano é bissexto se for divisível por 4 e não for divisível por 100, exceto para os anos divisíveis por 400, que também são bissextos.
Nenhum comentário:
Postar um comentário