Ferramentas de Usuário

Ferramentas de Site


dev_geral:c:alguns_comandos_em_c

FIXME Rever o texto, e se necessário corrigir alguns pormenores

Alguns comandos em C

O comando If

Sua forma geral é:

if (condição) declaração;

A expressão, na condição, será avaliada. Se ela for zero, ou tiver um valor booleano falso, a declaração não será executada. Caso contrário, a declaração será executada. Aqui apresentamos o exemplo de um uso do comando if:

#include <stdio.h>
#include <stdlib.h>
int main ()
{
	int num;
	printf ("Digite um numero: ");
	scanf ("%d",&num);
	if (num>10)
   		printf ("nnO numero e maior que 10");
	if (num==10)
        {
        	printf ("nnVoce acertou!n");
        	printf ("O numero e igual a 10.");
        }
	if (num<10)
   		printf ("nnO 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;

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 quem pelo menos 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 secção anterior:

#include <stdio.h>
#include <stdlib.h>
int main ()
{
	int num;
	printf ("Digite um numero: ");
	scanf ("%d",&num);
	if (num==10)
      	{
      		printf ("nnVoce acertou!n");
      		printf ("O numero e igual a 10.n");
      	}
	else 
      	{
      		printf ("nnVoce 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; 

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 <stdlib.h>
#include <stdio.h>
int main ()
{
	int num;
	printf ("Digite um numero: ");
	scanf ("%d",&num);
	if (num>10)
     		printf ("nnO numero e maior que 10");
	else if (num==10)
        {
        	printf ("nnVoce acertou!n");
        	printf ("O numero e igual a 10.");
        }
     	else if (num<10) 
             printf ("nnO numero e menor que 10");
 
return(0);
}

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) ....

é equivalente a:

int num;

if (num) ....

if (!num) ....

Isto quer dizer que podemos simplificar algumas expressões de modo a ficarem mais simples.

ifs aninhados

Um if aninhado é simplesmente um if dentro da declaração de um outro if externo. O único cuidado que devemos ter é o de saber exactamente a qual if um determinado else está ligado. Vejamos um exemplo:

#include <stdlib.h>
#include <stdio.h>
int main ()
{
 
int num;
	printf ("Digite um numero: ");
	scanf ("%d",&num);
	if (num==10)
        {
        	printf ("nnVoce 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 Comando switch

O comando if-else e o comando switch são os dois comandos de tomada de decisão. 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; 

}

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 é preciso cuidado. Veremos agora um exemplo do comando switch:

#include <stdlib.h>
#include <stdio.h>
int main ()
{
 
int num;
	printf ("Digite um numero: ");
	scanf ("%d",&num);
	switch (num)
        {
        	case 9:
                	printf ("nnO numero e igual a 9.n");
        	break;
        	case 10:
                	printf ("nnO numero e igual a 10.n");
        	break;
        	case 11:
                	printf ("nnO numero e igual a 11.n");
        	break;
        	default:
                	printf ("nnO numero nao e nem 9 nem 10 nem 11.n");
        }
 
return(0);
}

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 <stdlib.h>
#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 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') 
       {
        	Ch = getch();
       }
	return(0);
}

O Comando do-while

A terceira estrutura de repetição que veremos é o do-while de forma geral:

do 

{ 

declaraçã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"

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 <stdlib.h>
#include <stdio.h>
int main ()
{
 
	int  i;
	do
        {
        	printf ("nnEscolha a fruta pelo numero:nn");
        	printf ("t(1)...Mamaon");
        	printf ("t(2)...Abacaxin");
        	printf ("t(3)...Laranjann");
        	scanf("%d", &i); 
        } while ((i<1)||(i>3));
 
	switch (i)
        {
        	case 1:
                	printf ("ttVoce escolheu Mamao.n");
        	break;
        	case 2:
                	printf ("ttVoce escolheu Abacaxi.n");
        	break;
        	case 3:
                	printf ("ttVoce escolheu Laranja.n");
        	break;
        }
 
return(0);
 
}

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ção é o fato que um break usado dentro de uma declaração 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 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 <stdlib.h>
#include <stdio.h>
int main ()
{
 
  	int opcao;
	while (opcao != 5)
       	{
       		printf("nn 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; 

}

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 <stdlib.h>
#include <stdio.h>
int main ()
{
 
	int opcao;
	while (opcao != 5)
       	{
		REFAZ: printf("nn 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 opção..");
          		break; 
          		case 5: 
               			printf("n --> Abandonando..");
          		break; 
          	} 
       	}
 
return(0);
 
}

gets

A função gets() lê uma string do teclado. Sua forma geral é:

 gets (nome_da_string);

O programa abaixo demonstra o funcionamento da função gets():

#include <stdio.h>
int main ()
{
	char string[100];
	printf ("Digite o seu nome: ");
	gets (string);
	printf ("nn Ola %s",string);
	return(0);
}

Repare que é válido passar para a função printf() o nome da string. Você verá mais adiante porque isto é válido. Como o primeiro argumento da função printf() é uma string também é válido fazer:

printf (string);

isto simplesmente imprimirá a string.

strcpy

Sua forma geral é:

strcpy (string_destino,string_origem);

A função strcpy() copia a string-origem para a string- destino. Seu funcionamento é semelhante ao da rotina apresentada na seção anterior. As funções apresentadas nestas seções estão no arquivo cabeçalho string.h. A seguir apresentamos um exemplo de uso da função strcpy():

#include <stdio.h>
#include <string.h>
int main ()
{
	char str1[100],str2[100],str3[100];
	printf ("Entre com uma string: ");
	gets (str1);
	strcpy (str2,str1);	/* Copia str1 em str2 */
	strcpy (str3,"Voce digitou a string "); /* Copia "Voce digitou a string" em str3 */
	printf ("nn%s%s",str3,str2);
	return(0);
}

strcat

A função strcat() tem a seguinte forma geral:

strcat (string_destino,string_origem);

A string de origem permanecerá inalterada e será anexada ao fim da string de destino. Um exemplo:

#include <stdio.h>
#include <string.h>
int main ()
{
	char str1[100],str2[100];
	printf ("Entre com uma string: ");
	gets (str1);
	strcpy (str2,"Voce digitou a string ");
	strcat (str2,str1);	/* str2 armazenara' Voce digitou a string + o conteudo de str1 */
	printf ("nn%s",str2);
	return(0);
}

strlen

Sua forma geral é:

strlen (string);

A função strlen() retorna o comprimento da string fornecida. O terminador nulo não é contado. Isto quer dizer que, de fato, o comprimento do vetor da string deve ser um a mais que o inteiro retornado por strlen(). Um exemplo do seu uso:

#include <stdio.h>
#include <string.h>
int main ()
{
	int size;
	char str[100];
	printf ("Entre com uma string: ");
	gets (str);
	size=strlen (str);
	printf ("nnA string que voce digitou tem tamanho %d",size);
	return(0);
}

strcmp

Sua forma geral é:

strcmp (string1,string2);

A função strcmp() compara a string 1 com a string 2. Se as duas forem idênticas a função retorna zero. Se elas forem diferentes a função retorna não-zero. Um exemplo da sua utilização:

#include <stdio.h>
#include <string.h>
int main ()
{
	char str1[100],str2[100];
	printf ("Entre com uma string: ");
	gets (str1);
	printf ("nnEntre com outra string: ");
	gets (str2);
	if (strcmp(str1,str2))
        	printf ("nnAs duas strings são diferentes.");
	else printf ("nnAs duas strings são iguais.");
	return(0);
}
 

O Comando return

O comando return tem a seguinte forma geral:

return valor_de_retorno; ou return;

Digamos que uma função está sendo executada. Quando se chega a uma declaração return a função é encerrada imediatamente e, se o valor de retorno é informado, a função retorna este valor. É importante lembrar que o valor de retorno fornecido tem que ser compatível com o tipo de retorno declarado para a função. Uma função pode ter mais de uma declaração return. Isto se torna claro quando pensamos que a função é terminada quando o programa chega à primeira declaração return. Abaixo estão dois exemplos de uso do return:

 
#include <stdio.h>
int Square (int a)
{
	return (a*a);
}
int main ()
{
	int num;
	printf ("Entre com um numero: ");
	scanf ("%d",&num);
	num=Square(num);
	printf ("nnO seu quadrado vale: %dn",num);
	return 0;
}
 
#include <stdio.h>
int EPar (int a)
{
	if (a%2)           /* Verifica se a e divisivel por dois */
          return 0;        /* Retorna 0 se nao for divisivel */
	else
          return 1;        /* Retorna 1 se for divisivel */
}
int main ()
{
	int num;
	printf ("Entre com numero: ");
	scanf ("%d",&num);
	if (EPar(num))
        	printf ("nnO numero e par.n");
	else
        	printf ("nnO numero e impar.n");
	return 0;
}
 
 

É importante notar que, como as funções retornam valores, podemos aproveitá-los para fazer atribuições, ou mesmo para que estes valores participem de expressões. Mas não podemos fazer:

  
  func(a,b)=x;    /* Errado! */ 

No segundo exemplo vemos o uso de mais de um return em uma função. Fato importante: se uma função retorna um valor você não precisa aproveitar este valor. Se você não fizer nada com o valor de retorno de uma função ele será descartado. Por exemplo, a função printf() retorna um inteiro que nós nunca usamos para nada. Ele é descartado.

dev_geral/c/alguns_comandos_em_c.txt · Última modificação em: 2018/05/14 21:37 (edição externa)