Baixe Introdução à Linguagem C no Curso Superior de Tecnologia em Manutenção Industrial e outras Notas de estudo em PDF para Engenharia de Manutenção, somente na Docsity!
MINISTÉRIO
(^) DA EDUCAÇÃO
UNIVERSIDADE
TECNOLÓGICA
FEDERAL
(^) DO (^) PARANÁ
CAMPUS
PATO
BRANCO
CURSO
SUPERIOR
(^) DE TECNOLOGIA
(^) EM (^) MANUTENÇÃO
INDUSTRIAL
IA34M - I
NFORMÁTICA
A
PLICADA
- L
INGUAGEM
C -
PROF
. C
ARLOS
M
ARCELO (^) DE
OLIVEIRA
STEIN
FEVEREIRO
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
2
Neste material são passados os conceitos básicos da linguagem de programação C, que tem seINTRODUÇÃO
gerando os programas executáveis com o seu compilador. Quando utilizamosque o aluno realmente use o máximo possível dos exemplos, problemas e exercícios apresentados,outras Ciências, etc. Estudaremos a estrutura do ANSI C, o C padronizado pela ANSI. Sugere-seassistido por computador, programas para a solução de problemas da Engenharia, Física, Química eprogramas para a automação industrial, gerenciadores de bancos de dados, programas de projetoprocessadores de texto, planilhas eletrônicas, sistemas operacionais, programas de comunicação,uma linguagem de programação genérica que é utilizada para a criação de programas diversos comovantagens do C é que ele possui tanto características de "alto nível" quanto de "baixo nível". O C étornado cada dia mais popular, devido à sua versatilidade e ao seu poder. Uma das grandes
(^) o compilador
aprendemos a lidar com mensagens de aviso, mensagens de erro,
(^) bugs , etc. Apenas ler os exemplos
compilador e experiência em acharestruturas e funções. O C exige, além do domínio da linguagem em si, uma familiaridade com onão basta. O conhecimento de uma linguagem de programação transcende o conhecimento de
(^) bugs (^) nos programas. É importante então que o aluno digite,
2 compile e execute os exemplos apresentados.
LINGUAGEM
C – P
RIMEIROS
PASSOS
Vamos começar ressaltando um ponto de suma importância: o C é "^ O C é "Case Sensitive"
Case Sensitive
", isto é,
maiúsculas e minúsculas fazem diferença
. Se uma variável for declarada com o nome
(^) var , ela será
diferente de
(^) Var , (^) VAR , (^) VaR (^) ou (^) vAr
. Da mesma maneira, os comandos do C devem ser escritos da
2.2 forma correta para o compilador interpretá-los como comandos. Vejamos um primeiro programa em C:^ O Primeiro Programa }return(0);printf ("Informática Aplicada – Primeiro Programa\n");{int main () /* Um Primeiro Programa */ #include <stdio.h>
Compilando e executando este programa você verá que ele coloca a mensagem
(^) Informática
Aplicada – Primeiro Programa
(^) na tela.
Como compilar programas usando o DevC++? Uma vez instalado o compilador, você pode
criar um novo programa através da opção:
(^) Arquivo (^) / (^) Novo / Arquivo Fonte
, ou utilizando as teclas
de atalho (^) Ctrl+N , ou ainda, utilizando o botão correspondente na barra de ferramentas. Na janela
lo através da opção:que você pode apagar, se quiser. Uma vez digitado o seu programa, você pode compilá-lo e executá-que aparece, você digita o seu programa. Veja que o DevC++ oferece para você um programa inicial
(^) Executar / Compilar & Executar
, ou pressionando diretamente
F
, ou
utilizando o botão
(^) Compilar & Executar
(^) na barra de ferramentas. Note que se você fizer isto para
pode modificar seus programas incluindo as linhas:fechada. Com isto, você não conseguirá ver a saída do programa. Para evitar que isto aconteça, vocêserá executado, terminará sua execução, e a janela onde ele está executando será automaticamenteum programa que não espera nenhuma entrada do usuário, como o exemplo anterior, o programa
#include <stdlib.h>
no início do programa
system("pause");
(^) antes do final do programa
Fazendo-se estas alterações no primeiro programa, tem-se:
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
3
{int main () /* Um Primeiro Programa */#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("Informática Aplicada – Primeiro Programa\n"); }
A linha^ Analisando o programa por partes (^) #include <stdio.h>
(^) diz ao compilador que ele deve incluir o arquivo de biblioteca de
comandos
(^) stdio.h
. Neste arquivo existem declarações de funções úteis para entrada e saída de dados
C possui diversas bibliotecas de comandos.padronizadas). Toda vez que você quiser usar uma destas funções deve-se incluir este comando. O(std = standard, padrão em inglês; io = Input/Output, entrada e saída ==> stdio = Entrada e saída Quando fazemos um programa, é uma boa idéia usar comentários que ajudem a elucidar o
funcionamento do mesmo. No caso acima temos um comentário:
(^) / Um Primeiro Programa /
. O
compilador C desconsidera qualquer coisa que esteja começando com
e terminando com
A linha (^) int main()
(^) define uma função de nome
(^) main
. Todos os programas em C têm que ter
uma função
(^) main , pois é esta função que será chamada quando o programa for executado. O
conteúdo da função é delimitado por chaves
. O código que estiver dentro das chaves será
executado sequencialmente quando a função for chamada. A palavra
(^) int (^) indica que esta função
retorna um número inteiro. A única coisa que este programa
(^) realmente
(^) faz é chamar a função
(^) printf() , passando o texto
"Informática Aplicada – Primeiro Programa\n"
(^) como argumento. É por causa do uso da função
printf() (^) que a biblioteca
(^) stdio.h (^) foi incluída. A função
(^) printf() (^) neste caso irá apenas colocar o texto
na tela do computador. A
(^) \n (^) é uma constante chamada de
(^) constante barra invertida de nova linha
que é interpretado como um comando de mudança de linha, isto é, após imprimir
(^) Informática
Aplicada – Primeiro Programa
(^) o cursor passará para a próxima linha. É importante observar
também que os
(^) comandos
(^) do C terminam com
O compilador ignora os comentários existentes no código fonte, ou seja, eles não interferem^ Comentários
entender. Existem basicamente duas formas de inserir comentários: com o comandono programa executável. O uso de comentários torna o código do programa mais fácil de se
e com o
comando (^) / /. O primeiro é utilizado para comentar o restante da linha (após
(^) // ), e o segundo para
comentar tudo entre
e (^) */
. Um comentário pode, desta forma, ter mais de uma linha.
As variáveis no C podem ter qualquer nome se algumas condições forem satisfeitas: o nome^ Nomes de Variáveis
2.5 "case sensitive" e, portanto deve-se prestar atenção às maiúsculas e minúsculas.C. Variáveis de até 32 caracteres são aceitas. Mais uma coisa: é bom sempre lembrar que o C éreservada, nem igual ao nome de uma função declarada pelo programador, ou pelas bibliotecas donúmeros ou sublinhado. Além disso, o nome de uma variável não pode ser igual a uma palavradeve começar com uma letra ou sublinhado (_) e os caracteres subsequentes podem ser letras, Todas as linguagens de programação têm palavras reservadas. As palavras reservadas não^ Palavras Reservadas do C
declarar uma variávelpodem ser usadas a não ser para seus propósitos originais. Como o C é "case sensitive" podemos
(^) For , apesar de haver uma palavra reservada
(^) for , mas isto não é uma coisa
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
4
do ANSI C. recomendável de se fazer, pois pode gerar confusão. Apresentamos a seguir as palavras reservadas continueconstcharcasebreak auto
externenumelsedoubledodefault
longintifgotoforfloat
staticsizeofsignedshortreturnregister
voidunsigneduniontypedefswitchstruct
whilevolatile
O C tem tipos básicos:^ Os Tipos do C
(^) char (^) (um caracter),
(^) int (^) (um número inteiro),
(^) float (^) (um número com
ponto flutuante) e
(^) double (^) (ponto flutuante de precisão dupla). 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 podem ser aplicados a inteiros. A intenção é que
(^) short (^) e long (^) devam prover tamanhos
diferentes de inteiros onde isto for prático.
(^) int (^) normalmente terá o tamanho natural para uma
determinada máquina. Assim, em uma máquina de 16 bits,
(^) int (^) provavelmente terá 16 bits e em uma
o seu próprio hardware, com a única restrição de quemáquina de 32, 32 bits. Na verdade, cada compilador é livre para escolher tamanhos adequados para
(^) short (^) e (^) int (^) devem ocupar pelo menos 16 bits,
long (^) pelo menos 32 bits, e
(^) short (^) não pode ser maior que
(^) int , que não pode ser maior que
(^) long
. A
compilador típico para um hardware de 16 bits:seguir estão listados os tipos de dados permitidos e seus valores máximos e mínimos em um
Tipo
Número de bits
Intervalo
Inicio
Fim
char
(^8)
127
unsigned char
(^8)
(^0)
255
signed char
(^8)
127
int
(^16)
-32.
unsigned int
(^16)
(^0)
signed int
(^16)
-32.
short int
(^16)
-32.
unsigned short int
(^16)
(^0)
signed short int
(^16)
-32.
long int
(^32)
-2.147.483.
2.147.483.
signed long int
(^32)
-2.147.483.
2.147.483.
unsigned long int
(^32)
(^0)
4.294.967.
float
(^32)
3,4E-
3.4E+
double
(^64)
1,7E-
1,7E+
long double
(^80)
3,4E-
3,4E+
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
2.7 números podem assumir valores tanto positivos quanto negativos. As variáveis no C devem ser declaradas antes de serem usadas. A forma geral da declaração^ Declaração e Inicialização de Variáveis
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 (^) (padrão) 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
long cont; char ch, letra;
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
7
Os caracteres são um tipo de dado: o^ Caracteres
(^) char
. O C trata os caracteres como sendo variáveis de
um (^) byte (^) ( bit s). Um
(^) bit (^) é a menor unidade de armazenamento de informações em um computador.
Na linguagem C, também podemos usar um
(^) char (^) para armazenar valores numéricos inteiros, além
Veja um exemplo de programa que usa caracteres:de usá-lo para armazenar caracteres de texto. Para indicar um caractere de texto usamos apóstrofos.
{int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("%c",Ch);Ch='D';char Ch;
}
No programa acima,
(^) %c (^) indica que
(^) printf() (^) deve colocar um caractere na tela. Como dito
anteriormente, um
(^) char (^) também é usado para armazenar um número inteiro. Este número é
conhecido como o código ASCII correspondente ao caractere. Veja o programa abaixo:
{int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("%d",Ch); /* Imprime o caracter como inteiro */Ch='D';char Ch; }
Este programa vai imprimir o número 68 na tela, que é o código ASCII correspondente ao
2.11.1 Exercício: caractere 'D' (d maiúsculo). Escreva um programa que leia um caractere digitado pelo usuário, imprima o caractere
2.12 digitado e o código ASCII correspondente a este caractere. Muitas vezes queremos ler um caractere fornecido pelo usuário. Para isto pode-se utilizar as^ As Funções getch e getche
funções (^) getch() (^) ou (^) getche()
. Ambas retornam o caractere pressionado, sendo que
(^) getche() (^) imprime
o caractere na tela antes de retorná-lo e
(^) getch() (^) apenas retorna o caractere pressionado sem imprimi-
lo na tela. Ambas as funções podem ser encontradas na biblioteca
(^) conio.h
. Eis um exemplo que usa
a função (^) getch( ):
{int main ()#include <conio.h>#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("Voce pressionou a tecla %c\n",Ch);Ch=getch();char Ch;
}
Equivalente para o programa acima, sem usar
(^) getch() :
#include <stdio.h>
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
8
{int main () #include <stdlib.h> return(0);system("pause");printf ("Voce pressionou a tecla %c\n",Ch);scanf("%c", &Ch);char Ch;
}
A principal diferença da versão que utiliza
(^) getch() (^) para a versão que não utiliza
(^) getch() (^) é que
você quiser manter a portabilidade de seus programas, não deve utilizar as funçõespressionada. No segundo caso, é necessário apertar também a tecla . Lembre-se que, seno primeiro caso o usuário simplesmente aperta a tecla e o sistema lê diretamente a tecla
(^) getch (^) e (^) getche
,
2.13 pois estas não fazem parte do padrão ANSI C. No C uma^ Strings
(^) string (^) é um vetor de caracteres terminado com um caractere nulo. O caracter nulo é
ser escrito usando a convenção de barra invertida do C como sendoum caractere com valor inteiro igual a zero (código ASCII igual a 0). O caractere nulo também pode
(^) \0. Para declarar uma string
podemos usar o seguinte formato geral:
char nome_da_string[tamanho];
Isto declara um vetor de caracteres (uma
(^) string ) com número de posições igual a
(^) tamanho
.
palavra Texto nela. Teremos:pretendemos armazenar. Vamos supor que declaremos uma string de 8 posições e coloquemos acomprimento da string como sendo, no mínimo, um caractere maior que a maior string queNote que, como temos que reservar um espaço para o caractere nulo, temos que declarar o
T
e x t o
... ...
No caso acima, as duas células não usadas têm valores indeterminados. Isto acontece porque o
C (^) não (^) inicializa variáveis, cabendo ao programador esta tarefa. Se quisermos ler uma string
fornecida pelo usuário podemos usar a função
(^) gets()
. Um exemplo do uso desta função é
apresentado abaixo. A função
(^) gets() (^) coloca o terminador nulo na string, quando você aperta a tecla
"Enter".
}return(0);system("pause");printf ("\n\nVoce digitou %s.\n",string);gets (string);printf ("Digite uma string: ");char string[100];{int main ()#include <stdlib.h> #include <stdio.h>
Neste programa, o tamanho máximo da string que você pode entrar é de 99 caracteres. Se
ser desastrosos.você entrar com uma string de comprimento maior, o programa irá aceitar, mas os resultados podem Como as strings são vetores de caracteres, para se acessar um determinado caracter de uma
string, basta usar um índice para acessar o caracter desejado. Suponha uma string chamada
(^) str .
Podemos acessar a
(^) segunda (^) letra de (^) str (^) da seguinte forma:
str[1] = 'a';
Observe que na linguagem C o índice
(^) começa em zero.
(^) Assim, a primeira letra da string
sempre estará na posição 0. A segunda letra sempre estará na posição 1 e assim sucessivamente.
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
9
ele mudará esta letra e apresentará a nova string no final. Segue um exemplo que imprimirá a terceira letra da string "Texto", apresentada acima. Em seguida,
}return(0);system("pause");printf("\n\nString resultante: %s\n", str);printf("\nAgora a terceira letra eh: %c", str[2]);str[2] = 'n';printf("\nTerceira letra: %c", str[2]);printf("\n\nString: %s", str);char str[10] = "Texto";{int main()#include <stdlib.h> #include <stdio.h>
Nesta string, o terminador nulo está na posição 5. Das posições 0 a 5, sabemos que temos
caracteres válidos, e portanto podemos escrevê-los. Note a forma como inicializamos a string
(^) str
2.13.1 Exercício: armazenado, como de fato fizemos.modificados. Já a string str é uma string variável, pois podemos modificar o que nela estáconstante, isto é, uma cadeia de caracteres que está pré-carregada com valores que não podem serposteriormente que "Texto" (uma cadeia de caracteres entre aspas) é o que chamamos de string com os caracteres 'T' 'e' 'x' 't' 'o' e '\0' simplesmente declarando char str[10] = "Texto". Veremos, Escreva um programa que leia duas strings e as coloque na tela. Imprima também a segunda
2.14 letra de cada string. Uma função é um bloco de código que pode ser usado diversas vezes na execução de um^ Funções
verdade, um programa em C consiste de várias funções colocadas juntas. Aprograma. O uso de funções permite que o programa fique mais legível, e melhor estruturado. Na
(^) forma geral de uma
função é:
}código_da_função { tipo_de_retorno nome_da_função (lista_de_argumentos)
Abaixo o tipo mais simples de função: void mensagem ()#include <stdlib.h> #include <stdio.h>
(^) // Função simples: só imprime o texto
{ printf ("Informática "); {main ()} system("pause");printf ("Aplicada\n");mensagem(); }
Este programa terá o mesmo resultado que o primeiro exemplo visto. O que ele faz é definir
uma função
(^) mensagem()
(^) que coloca uma string na tela e não retorna nada (
void ). Depois esta
função é chamada a partir de
(^) main() (^) (que também é uma função).
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
10
2.14.1 Argumentos Argumentos são as entradas que a função recebe. É através dos argumentos que passamos
parâmetros
(^) para a função. Já vimos funções com argumentos. As funções
(^) printf() (^) e scanf() (^) são
funções que recebem argumentos. Vamos ver um exemplo simples de função com argumentos:
void quad(int x)#include <stdlib.h> #include <stdio.h>
(^) // Calcula o quadrado de x
}system("pause");quad(num);printf ("\n\n");scanf ("%d",&num);printf ("Entre com um numero: ");int num;{main ()}printf ("O quadrado e %d",(x*x));{
Na definição de
(^) quad() (^) dizemos que a função receberá um argumento inteiro
(^) x. Quando
fazemos a chamada à função, o inteiro
(^) num (^) é passado como argumento. Há alguns pontos a
da variável que se passa como argumento, ou seja, a variávelque o C faz automaticamente, é importante ficar atento. Em segundo lugar, não é importante o nomequantidade de argumentos quando a chamamos. Apesar de existirem algumas conversões de tipoobservar. Em primeiro lugar temos de satisfazer aos requisitos da função quanto ao tipo e a
(^) num , ao ser passada como argumento
para (^) quad() (^) é copiada para a variável
(^) x. Dentro de
(^) quad() (^) trabalha-se apenas com
(^) x. Se mudarmos
o valor de
(^) x (^) dentro de
(^) quad() (^) o valor de
(^) num (^) na função
(^) main() (^) permanece inalterado.
Vamos ver um exemplo de função com mais de uma variável. Repare que, neste caso, os
variáveis, porque serão copiados para a variável de entrada da função.um a um. Note também que não é necessário que todos os argumentos passados para a função sejamargumentos são separados por vírgula e que deve ser explicitado o tipo de cada um dos argumentos,
void mult (float a, float b, float c)#include <stdlib.h> #include <stdio.h>
// Multiplica 3 números
}system("pause");mult (x,y,3.87);y=12.9;x=23.5;float x,y;{main ()}printf ("%f",abc);{
2.14.2 Retornando valores Muitas vezes é necessário fazer com que uma função retorne um valor. As funções que vimos
até aqui não retornam nada, pois especificamos um retorno
(^) void
. Podemos especificar um tipo de
retorno indicando-o antes do nome da função. Mas para dizer ao C
(^) o que (^) vamos retornar precisamos
da palavra reservada
(^) return
. Assim fica fácil fazer uma função para multiplicar dois inteiros e que
retorna o resultado da multiplicação. Veja:
#include <stdio.h>
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
13
{ if (num==10) printf ("O numero e igual a 10.\n");printf ("\n\nVoce acertou!\n");
{else} printf ("O numero e diferente de 10.\n");printf ("\n\nVoce errou!\n");
return(0);system("pause");}
}
A estrutura^ O if-else-if
(^) if-else-if
(^) é apenas uma extensão da estrutura
(^) if-else
. Sua forma geral pode ser
escrita como sendo:
else if (condição_2) declaração_2; if (condição_1) declaração_1; else if (condição_3) declaração_3; else if (condição_n) declaração_n;... else declaração_default;
Esta estrutura funciona da seguinte maneira: o programa testa as condições até encontrar uma
expressão
(^) que (^) seja (^) satisfeita.
(^) 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 for satisfeita. A última declaração (
default ) será executada no caso de nenhuma condição ser
satisfeita, e é opcional. Um exemplo desta estrutura:
{int main ()#include <stdlib.h> #include <stdio.h> if (num>10)scanf ("%d",&num);printf ("Digite um numero: ");int num; printf ("\n\nO numero e maior que 10");
else if (num==10) { printf ("O numero e igual a 10.");printf ("\n\nVoce acertou!\n");
else if (num<10)}
printf ("\n\nO numero e menor que 10");
return(0);system("pause");
}
Quando o compilador avalia uma condição, ele quer um valor de retorno para poder tomar a^ A expressão condicional
variável sozinha pode ser umadecisão. Mas esta expressão não necessita ser uma expressão no sentido convencional. Uma
(^) expressão
(^) e esta retorna o seu próprio valor. Assim, as seguintes
expressões:
if (num==0) ....if (num!=0) .... int num;
equivalem a if (num) .... int num;
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
14
if (!num) ....
O^ ifs aninhados 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:
{int main ()#include <stdlib.h> #include <stdio.h> {if (num==10)scanf ("%d",&num);printf ("Digite um numero: ");int num; printf ("O numero e igual a 10.\n");printf ("\n\nVoce acertou!\n");
{else} {if (num>10) printf ("O numero e maior que 10.");
{else} printf ("O numero e menor que 10.");
}
return(0);system("pause");}
}
De uma maneira geral, expressões do tipo:^ O Operador? if (condição) expressão_1;
else expressão_2;
podem ser simplificada usando-se o operador
(^)? (^) da seguinte maneira:
condição?expressão_1:expressão_2;
Assim, uma expressão como: b=150;elseb=-150;^ if (a>0)
pode ser simplificada por: b=a>0?-150:150;
O operador
(^)? (^) é limitado (não atende a uma gama muito grande de casos) mas pode ser usado
o exemplo:para simplificar expressões complicadas. Uma aplicação interessante é a do contador circular. Veja
{int main()#include <stdlib.h> #include <stdio.h> int index = 0, contador;
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
15
{for (contador=0; contador < 1000; contador=contador+1) char letras[6] = "Texto"; index=(index==5)? index=0: index=index+1;printf("\n%c",letras[index]);
}
}system("pause");
A palavra
(^) Texto (^) é escrita verticalmente na tela até a variável contador determinar o término do
3.1.6 programa. Enquanto isto a variável index assume os valores 0, 1, 2, 3, 4, 0, 1, ... progressivamente. a) Altere o último exemplo para que ele escreva cada letra 5 vezes seguidas. Para isto, use um^ Exercícios:
if (^) para testar se o contador é divisível por cinco (utilize o operador
) e só então realizar a
3.2 atualização em index. O comando^ O Comando switch
(^) 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. O
comando (^) switch (^) é próprio (^) para (^) se (^) testar (^) uma (^) variável
(^) em relação
(^) a diversos (^) valores (^) pré-
estabelecidos. Sua forma geral é:
case constante_1:{ switch (variável) break;declaração_1; case constante_2: break;declaração_2; case constante_n:... break;declaração_n; 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
recomenda-se cuidado. Veremos agora um exemplo do comando
(^) switch :
{int main ()#include <stdlib.h> #include <stdio.h> {switch (num)scanf ("%d",&num);printf ("Digite um numero: ");int num; case 10: printf ("\n\nO numero e igual a 10.\n");break;case 9: printf ("\n\nO numero e igual a 9.\n");
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
16
default: printf ("\n\nNao e 9 nem 10 nem 11.\n");break;case 11: printf ("\n\nO numero e igual a 11.\n"); break;
return(0);system("pause");}
}
O^ O Comando for (^) for (^) é a primeira de uma série de três estruturas para se trabalhar com
(^) loops (^) (laços) de
repetição. As outras são
(^) while (^) e (^) do
. As três compõem a segunda família de comandos de controle
comandode fluxo. Podemos pensar nesta família como sendo a das estruturas de repetição controlada. O (^) for (^) é usado para repetir um comando (ou bloco de comandos) diversas vezes, de maneira
que se possa ter um bom controle sobre o laço. Sua forma geral é:
for (inicialização;condição;incremento) declaração;
A declaração no comando
(^) for (^) também pode ser um bloco ({ }) e neste caso o
; é omitido. O
melhor modo de se entender o
(^) for (^) é ver de que maneira ele funciona. O
(^) for (^) é equivalente a se fazer
o seguinte:
}"Volte para o comando if"incremento;declaração;{if (condição) inicialização;
Podemos ver, então, que o
(^) for (^) executa a inicialização e testa a condição. Se a condição for
vemos um programa que coloca os primeiros 100 números inteiros na tela:e volta a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa. Abaixofalsa ele não faz mais nada. Se a condição for verdadeira ele executa a declaração, faz o incremento
{int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");for (cont=1;cont<=100;cont=cont+1) printf ("%d ",cont);int cont;
}
Outro exemplo interessante é mostrado a seguir: o programa lê uma string e conta quantos dos
caracteres desta string são iguais à letra 'c'
{for (i=0; string[i] != '\0'; i=i+1)cont = 0;printf("\n\nFrase digitada:\n%s", string);gets(string); /* Le a string /printf("\n\nDigite uma frase: ");int i, cont;char string[100]; / String, ate' 99 caracteres */{int main ()#include <stdlib.h>^ #include <stdio.h> if ( string[i] == 'c' )
(^) /* Se for a letra 'c' */
cont = cont +1;
/* Incrementa o contador */
system("pause");printf("\nNumero de caracteres c = %d", cont);}
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
19
{ {while (Ch!='q')Ch='\0';char Ch; Ch = getch();
return(0);system("pause");}
}
Refaça o programa anterior. Use o comando^ Exercícios
(^) while (^) para fechar o loop.
A terceira estrutura de repetição que veremos é o^ O Comando do-while
(^) 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
do-while ponto-e-vírgula final é obrigatório. Vamos, como anteriormente, ver o funcionamento da estrutura
if (condição) "Volta para a declaração" 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 estrutura
(^) do-while
(^) é em menus, nos quais você quer garantir que o valor
digitado pelo usuário seja válido, conforme apresentado abaixo:
{int main ()#include <stdlib.h> #include <stdio.h> {doint i; scanf("%d", &i);printf ("\t(3)...Laranja\n\n");printf ("\t(2)...Abacaxi\n");printf ("\t(1)...Mamao\n");printf ("\n\nEscolha a fruta pelo numero:\n\n");
{switch (i)while ((i<1)||(i>3));} break;case 3: printf ("\t\tVoce escolheu Laranja.\n");break;case 2: printf ("\t\tVoce escolheu Abacaxi.\n");break;case 1: printf ("\t\tVoce escolheu Mamao.\n");
return(0);system("pause");}
}
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
20
Nós já vimos dois usos para o comando^ O Comando break
(^) 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
(^) laço (^) ( for , (^) while (^) ou (^) do while
). O
break (^) faz com que a execução do programa continue na primeira linha seguinte ao laço 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) {for(;;)cont=1; if(cont==10) break;cont = cont + 1;printf("%d", cont);
}
}
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 não qualquer outro laço em que o
(^) switch (^) estiver.
O comando^ O Comando continue
(^) continue
(^) pode ser visto como sendo o oposto do
(^) break
. Ele só funciona dentro de
um laço. Quando o comando
(^) continue
(^) é encontrado, o laço pula para a próxima iteração, sem o
abandono do laço. O programa abaixo exemplifica o uso do
(^) continue
:
{int main()#include <stdlib.h> #include <stdio.h>
if ((opcao > 5)||(opcao <1)) continue;scanf("%d", &opcao);printf("\n\n Escolha uma opcao entre 1 e 5: ");{while (opcao != 5)int opcao;
/* Opcao invalida: volta ao inicio do loop */
{switch (opcao) break;case 5: printf("\n --> Abandonando..");break;case 4: printf("\n --> Quarta opcao..");break;case 3: printf("\n --> Terceira opcao..");break;case 2: printf("\n --> Segunda opcao..");break;case 1: printf("\n --> Primeira opcao..");
return(0);system("pause");}}
}
O programa acima ilustra uma aplicação simples para o
(^) continue
. Ele recebe uma opção do
usuário. Se esta opção for inválida, o
(^) continue
(^) faz com que o fluxo seja desviado de volta ao início
do laço. Caso a opção escolhida seja válida o programa segue normalmente.
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
21
Vamos mencionar o^ O Comando goto
(^) goto (^) apenas para que você saiba que ele existe. Ele pertence a uma classe
à parte: a dos comandos de salto incondicional. O
(^) goto (^) realiza um salto para um local especificado.
Você dá o nome que quiser a esta marca. Podemos tentar escrever uma forma geral:Este local é determinado por um rótulo. Um rótulo, na linguagem C, é uma marca no programa.
nome_do_rótulo: ....goto nome_do_rótulo;....
Devemos declarar o nome do rótulo, seguido de
(^) : , na posição para a qual vamos dar o salto. O
goto (^) pode saltar para um rótulo que esteja para 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 :
inicio: inicialização; {if (condição) goto inicio;incremento;declaração;
}
O comando
(^) goto (^) deve ser utilizado com contenção, 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. Um caso em que ele pode ser útil é quando temos vários laços e
(^) if s aninhados
e se queira, por algum motivo, sair dos laços e
(^) if s de uma vez. Neste caso, um
(^) goto (^) resolve o
problema mais elegantemente que vários
(^) break s, sem contar que os
(^) break s exigiriam muito mais
testes. Ou seja, neste caso o
(^) goto (^) é mais elegante e mais rápido. O exemplo anterior pode ser
reescrito usando-se o
(^) goto :
{int main()#include <stdlib.h> #include <stdio.h>
if ((opcao > 5)||(opcao <1)) goto REFAZ;scanf("%d", &opcao);printf("\n\n Escolha uma opcao entre 1 e 5: ");REFAZ:{while (opcao != 5)int opcao;
/* Opcao invalida: volta ao rotulo REFAZ */
{switch (opcao) break;case 5: printf("\n --> Abandonando..");break;case 4: printf("\n --> Quarta opcao..");break;case 3: printf("\n --> Terceira opcao..");break;case 2: printf("\n --> Segunda opcao..");break;case 1: printf("\n --> Primeira opcao..");
return(0);system("pause");}}
}
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
22
Escreva um programa que peça três inteiros, correspondentes a dia, mês e ano. Peça os^ Exercício
exceto para os anos divisíveis por 400, que também são bissextos.Comente seu programa. PS: Um ano é bissexto se for divisível por 4 e não for divisível por 100,anos bissextos). Se estiver tudo certo, imprima o número que aquele dia corresponde no ano.entre 1900 e 2100). Verifique se o mês e o número de dias estão coerentes (incluindo verificação denúmeros até conseguir valores que estejam na faixa correta (dia entre 1 e 31, mês entre 1 e 12 e ano
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
25
variáveloperandos são inteiros). Somente depois de efetuada a divisão é que o resultado é atribuído a uma5.0. Note que na linha correspondente a z2, primeiramente é feita uma divisão inteira (pois os dois ao final da execução destas linhas, os valores calculados seriam: x = 5, y = 2, z1 = 5.666666 e z2 = (^) float .
Os operadores de incremento e decremento são unários que alteram a variável sobre a qual
aplicados, de 1. Entãoestão aplicados. O que eles fazem é incrementar ou decrementar, a variável sobre a qual estã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é-
eles retornam o valor da variável sem o incremento e depois incrementam a variável. Então, emfixados eles incrementam e retornam o valor da variável já incrementada. Quando são pós-fixados
y=x++; x=23;
teremos, no final,
(^) y= (^) e (^) x=
. Em
y=++x; x=23;
teremos, no final,
(^) y= (^) e (^) x=
. Uma curiosidade: a linguagem de programação C++ tem este
C só que com extensões que permitem a programação orientada a objeto, o que é um recurso extra.nome pois ela seria um "incremento" da linguagem C padrão. A linguagem C++ é igual a linguagem O operador de atribuição do C é o
(^) =. O que ele faz é pegar o valor à direita e atribuir à
expressões sejam válidas:variável da esquerda. Além disto ele retorna o valor que ele atribuiu. Isto faz com que as seguintes
if (k=w) ... /* Expressao 2 / x=y=z=1.5; / Expressao 1 */
A expressão 1 é válida, pois quando fazemos
(^) z=1. (^) ela retorna 1.5, que é passado adiante. A
expressão dois 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.
a) Diga o resultado das variáveis x, y e z depois da seguinte seqüência de operações:^ Exercícios x=x+y-(z--);y++;x=-x;z=++x;x=y=10; int x,y,z;
Os operadores relacionais do C realizam^ Operadores Relacionais e Lógicos
(^) 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
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
26
!= 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.
{int main()#include <stdlib.h>#include <stdio.h>*/ return(0);system("pause");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);scanf("%d%d", &i, &j);printf("\nEntre com dois números inteiros: ");int i, j;
}
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
q p AND q
p OR q
falso
falso
falso
falso
falso
verdadeiro
falso
verdadeiro
verdadeiro
falso
falso
verdadeiro
verdadeiro
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:
{int main()#include <stdlib.h> #include <stdio.h> system("pause");printf("NOT %d é %d\n", i, !i);printf("%d OR %d é %d\n", i, j, i || j);printf("%d AND %d é %d\n", i, j, i && j);scanf("%d%d", &i, &j);printf("informe dois números(cada um sendo 0 ou 1): ");int i, j;
}
Exemplo: No trecho de programa abaixo a operação j++ será executada, pois o resultado da
expressão lógica é verdadeiro:
if ( (i > 3) && ( j <= 7) && ( i != j) ) j++; int i = 5, j =7;
V AND V AND V = V
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
27
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:
{int main()#include <stdlib.h>#include <stdio.h> /* Imprime os números pares entre 1 e 100. / for(i=1; i<=100; i++)int i; system("pause");if(!(i%2)) printf("%d ",i); / o operador de resto */
/* usada com número par. // dará falso (zero) quando */
}
/* Esse resultado é invertido pelo! */
O C permite que se faça^ Operadores Lógicos Bit a Bit
(^) operações lógicas "bit-a-bit"
(^) em números. Ou seja, neste caso, o
número inteiro de 16 bits, a variávelnúmero é representado por sua forma binária e as operações são feitas em cada bit dele. Imagine um
(^) i , armazenando o valor 2. A representação binária de
(^) i , será:
do número (operação binária NOT, ou operador binário ~ em C), isto é,Poderemos fazer operações em cada um dos bits deste número. Por exemplo, se fizermos a negação0000000000000010 (quinze zeros e um único 1 na segunda posição da direita para a esquerda).
i , o número se
nos tipostrabalhar com o computador em "baixo nível". As operações lógicas bit a bit só podem ser usadastransformará em 1111111111111101. As operações binárias ajudam programadores que queiram (^) char , (^) int (^) e (^) long int
Operador. Os operadores são:
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
4.2.2 armazenado em i passa a ser igual a 16. Diga se as seguintes expressões serão verdadeiras ou falsas:^ Exercícios (!(5==6)&&(5!=6)&&((2>1)||(5<=4))) ((10>5)||(5>10))
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. Exemplos de expressões: i = i+3; Anos=Dias/365.25;
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
28
c= a(b+d)/e; c= ab + d/e;
Quando o C avalia expressões onde temos variáveis de tipos diferentes o compilador verifica^ Conversão de tipos em expressões
erro. Se as conversões forem possíveis ele as faz, seguindo as regras abaixo:se as conversões são possíveis. Se não são, ele não compilará o programa, dando uma mensagem de
Todos os (^) char s e short int
s são convertidos para
(^) int s. Todos os
(^) float s são convertidos
para (^) double s.
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
.
O C admite as seguintes equivalências, que podem ser usadas para simplificar expressões ou^ - Expressões que Podem ser Abreviadas
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^ Encadeando expressões: o operador ,
(^) , (^) determina uma lista de expressões que devem ser executadas seqüencialmente.
seqüência. O valor retornado por uma expressão com o operadorEm síntese, a vírgula diz ao compilador: execute as duas expressões separadas pela vírgula, em
(^) , (^) é 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 :
{int main()#include <stdlib.h> #include<stdio.h> for(x=0 , y=0 ;int x, y;
(^) 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 */
system("pause");
}
Esta é a tabela de precedência dos operadores em C. Alguns (poucos) operadores ainda não^ Tabela de Precedências do C
foram estudados, e serão apresentados em aulas posteriores.
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
31
Strings são vetores de^ Strings
(^) char s. Nada mais e nada menos. As strings são o uso mais comum para
como umos vetores. Devemos apenas ficar atentos para o fato de que as strings têm o seu último elemento
char nome_da_string [tamanho];^ \0. A declaração geral para uma string é:
Devemos lembrar que o tamanho da string deve incluir o
\
(^) final. A biblioteca padrão do C
exemplo, igualar duas strings:possui diversas funções que manipulam strings. Estas funções são úteis, pois não se pode, por
string1=string2; /* NAO faca isto */
Fazer isto é um desastre. Quando você terminar de ler a seção que trata de ponteiros você
entenderá porquê. As strings devem ser igualadas elemento a elemento. Quando vamos fazer programas que tratam de string muitas vezes podemos fazer bom
proveito do fato de que uma string termina com
\
(isto é, o número inteiro 0). Veja, por exemplo, o
vetor da outra):programa abaixo que serve para igualar duas strings (isto é, copia os caracteres de uma string para o
{int main ()#include <stdlib.h> #include <stdio.h> .... /* Aqui o programa continua /str2[count]='\0';str2[count]=str1[count];for (count=0;str1[count];count++)..../ Aqui o programa le str1 que sera copiada para str2 */char str1[100],str2[100];int count;
}
A condição no
(^) loop (^) for (^) acima é baseada no fato de que a string que está sendo copiada
termina com
(^) \0. Quando o elemento encontrado em
(^) str1[count]
(^) é o (^) \0 , o valor retornado para o teste
continuamente, torna-se falsa.condicional é falso (nulo). Desta forma a expressão que vinha sendo verdadeira (não zero) Vamos ver agora algumas funções básicas para manipulação de strings.
A função^ gets (^) gets() (^) lê uma string do teclado. Sua forma geral é:
gets (nome_da_string);
O programa abaixo demonstra o funcionamento da função
(^) gets() :
{int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("\n\n Ola %s",string);gets (string);printf ("Digite o seu nome: ");char string[100];
}
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:
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
32
printf (string);
isto simplesmente imprimirá a string.
Sua forma geral é:^ strcpy strcpy (string_destino,string_origem);
A
função (^) strcpy()
(^) copia (^) a string-origem
(^) para (^) a string-destino.
(^) Seu (^) funcionamento
(^) é
no arquivo cabeçalhosemelhante ao da rotina apresentada na seção anterior. As funções apresentadas nestas seções estão
(^) string.h
. A seguir apresentamos um exemplo de uso da função
(^) strcpy() :
{int main ()#include <stdlib.h>#include <string.h> #include <stdio.h> strcpy (str2,str1);gets (str1);printf ("Entre com uma string: ");char str1[100],str2[100],str3[100];
/* Copia str1 em str2 */
strcpy (str3,"Voce digitou a string "); /* Copia "Voce
digitou a string" em str3 */
return(0);system("pause");printf ("\n\n%s%s",str3,str2);
}
A função^ strcat (^) 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:
{int main ()#include <stdlib.h>#include <string.h> #include <stdio.h> strcat (str2,str1);strcpy (str2,"Voce digitou a string ");gets (str1);printf ("Entre com uma string: ");char str1[100],str2[100];
string + o conteudo de str1 // str2 armazenara' Voce digitou a
return(0);system("pause");printf ("\n\n%s",str2);
}
Sua forma geral é:^ strlen strlen (string);
A função
(^) strlen() (^) retorna o comprimento da string fornecida. O terminador nulo não é
inteiro retornado porcontado. Isto quer dizer que, de fato, o comprimento do vetor da string deve ser um a mais que o
(^) strlen()
. Um exemplo do seu uso:
#include <stdlib.h>#include <string.h> #include <stdio.h>
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
33
{ int main () return(0);printf ("\n\nA string que voce digitou tem tamanho %d",size);size=strlen (str);gets (str);printf ("Entre com uma string: ");char str[100];int size;
}
Sua forma geral é:^ strcmp 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:
{int main ()#include <stdlib.h>#include <string.h> #include <stdio.h> return(0);system("pause");else printf ("\n\nAs duas strings são iguais.");printf ("\n\nAs duas strings são diferentes.");if (strcmp(str1,str2))gets (str2);printf ("\n\nEntre com outra string: ");gets (str1);printf ("Entre com uma string: ");char str1[100],str2[100];
}
Faça um programa que leia quatro palavras pelo teclado, e armazene cada palavra em uma^ Exercícios
5.3 resultado ao final do programa.string. Depois, concatene todas as strings lidas numa única string. Por fim apresente esta como (^) Matrizes
Já vimos como declarar matrizes unidimensionais (vetores). Vamos tratar agora de matrizes^ Matrizes bidimensionais
declaração de um vetor:bidimensionais. A forma geral da declaração de uma matriz bidimensional é muito parecida com a
tipo_da_variável nome_da_variável [altura][largura];
É muito importante ressaltar que, nesta estrutura, o índice da esquerda indexa as linhas e o da
do uso de uma matriz:usuário. Manter os índices na faixa permitida é tarefa do programador. Abaixo damos um exemploos índices variam de zero ao valor declarado, menos um; mas o C não vai verificar isto para ovaria mais rapidamente que o índice à esquerda. Mais uma vez é bom lembrar que, na linguagem C,direita indexa as colunas. Quando vamos preencher ou ler uma matriz no C o índice mais à direita
int mtrx [20][10];{int main ()#include <stdlib.h> #include <stdio.h>
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
34
for (i=0;i<20;i++)count=1; int i,j,count; {for (j=0;j<10;j++) count++;mtrx[i][j]=count;
return(0);system("pause");}
}
No exemplo acima, a matriz
(^) mtrx (^) é preenchida, sequencialmente por linhas, com os números
5.3.2 de 1 a 200. Você deve entender o funcionamento do programa acima antes de prosseguir. Matrizes de strings são matrizes bidimensionais. Imagine uma string. Ela é um vetor. Se^ Matrizes de strings
bidimensional defizermos um vetor de strings estaremos fazendo uma lista de vetores. Esta estrutura é uma matriz
(^) char s. Podemos ver a forma geral de uma matriz de strings como sendo:
char nome_da_variável [num_de_strings][compr_das_strings];
Aí surge a pergunta: como acessar uma string individual? Fácil. É só usar apenas o primeiro
índice. Então, para acessar uma determinada string faça:
nome_da_variável [índice]
Aqui está um exemplo de um programa que lê 5
(^) strings (^) e as exibe na tela:
{int main ()#include <stdlib.h> #include <stdio.h> {for (count=0;count<5;count++)int count;char strings [5][100]; gets (strings[count]);printf ("\n\nDigite uma string: ");
for (count=0;count<5;count++)printf ("\n\n\nAs strings que voce digitou foram:\n\n");} printf ("%s\n",strings[count]);
return(0);system("pause");
}
O uso de matrizes multidimensionais na linguagem C é simples. Sua forma geral é:^ Matrizes multidimensionais tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];
Uma matriz N-dimensional funciona basicamente como outros tipos de matrizes. Basta
5.3.4 lembrar que o índice que varia mais rapidamente é o índice mais à direita. Podemos inicializar matrizes, assim como podemos inicializar variáveis. A forma geral de^ Inicialização
uma matriz com inicialização é:
tipo_da_variável
nome_da_variável
[tam1][tam2]
... [tamN]
=
{lista_de_valores};
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
37
operador (^) & , que é o operador
(^) *****. No exemplo acima, uma vez que fizemos
(^) pt=&count
(^) a expressão
*pt (^) é equivalente ao próprio
(^) count
. Isto significa que, se quisermos mudar o valor de
(^) count (^) para 12,
basta fazer
(^) *pt= .
Vamos fazer uma pausa e voltar à nossa analogia para ver o que está acontecendo.
(^) Digamos
papel à firma com o operadorfirma e pede o seu endereço, o qual você vai anotar no papel. Isto é equivalente, no C, a associar oonde vai anotar o endereço da firma. O papel é um ponteiro do tipo firma. Você então liga para aque exista uma firma. Ela é como uma variável que já foi declarada. Você tem um papel em branco
. Ou seja, o operador
aplicado à firma é equivalente a você ligar
exemplo, fazer uma visita à firma. No C você faz uma visita à firma aplicando o operadorpara a mesma e pedir o endereço. Uma vez de posse do endereço no papel você poderia, por
ao
papel. Uma vez dentro da firma você pode copiar seu conteúdo ou modificá-lo. Uma observação importante: apesar do símbolo ser o mesmo, o operador
(multiplicação)
não é o mesmo operador que o
(referência de ponteiros). Para começar, o primeiro é binário, e o
segundo é unário pré-fixado. Aqui vão dois exemplos de usos simples de ponteiros: {int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("Valor da variavel apontada: %d\n",p);printf ("Endereco para onde o ponteiro aponta: %p\n",p);printf ("\n\n%d\n",valor);valor=p;// Valor e igualado a num de uma maneira indiretap=# /* Pega o endereco de num */num=55;int *p;int num,valor;
{int main ()#include <stdlib.h>#include <stdio.h>} return(0);system("pause");printf ("\nValor final: %d\n",num);p=100; / Muda o valor de num de uma maneira indireta /printf ("\nValor inicial: %d\n",num);p=# / Pega o endereco de num /num=55;int num,p;
}
Nos exemplos acima vemos um primeiro exemplo do funcionamento dos ponteiros. No
primeiro exemplo, o código
(^) %p (^) usado na função
(^) printf() (^) indica à função que ela deve imprimir um
endereço. Podemos fazer algumas operações aritméticas com ponteiros. A primeira, e mais simples, é
igualar dois ponteiros. Se tivermos dois ponteiros
(^) p (^) e p podemos igualá-los fazendo
(^) p1=p .
Repare que estamos fazendo com que
(^) p (^) aponte para o mesmo lugar que
(^) p
. Se quisermos que a
variável apontada por
(^) p (^) tenha o mesmo conteúdo da variável apontada por
(^) p (^) devemos fazer
p1=p
. Basicamente, depois que se aprende a usar os dois operadores (
& (^) e (^) ***** ) fica fácil entender
operações com ponteiros. As próximas operações, também muito usadas, são o incremento e o decremento. Quando
incrementamos um ponteiro ele passa a apontar para o próximo valor do mesmo tipo para o qual o
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
38
ponteiro: se você incrementa um ponteiropara o próximo inteiro. Esta é mais uma razão pela qual o compilador precisa saber o tipo de um ponteiro aponta. Isto é, se temos um ponteiro para um inteiro e o incrementamos ele passa a apontar
(^) char* (^) ele anda 1 byte na memória e se você incrementa
um ponteiro
(^) double*
(^) ele anda 8 bytes na memória. O decremento funciona semelhantemente.
Supondo que
p--; p++; (^) p (^) é um ponteiro, as operações são escritas como:
Mais uma vez insiste-se. Estamos falando de operações com
(^) ponteiros
(^) e não de operações
conteúdo da variável apontada pelo ponteirocom o conteúdo das variáveis para as quais eles apontam. Por exemplo, para incrementar o
(^) p , faz-se:
(*p)++;
Outras operações aritméticas úteis são a soma e subtração de inteiros com ponteiros. Vamos
supor que você queira incrementar um ponteiro de 15. Basta fazer:
p=p+15; ou p+=15;
E se você quiser usar o conteúdo do ponteiro 15 posições adiante: *(p+15);
A subtração funciona da mesma maneira. Uma outra operação, às vezes útil, é a comparação
primeiro lugar, podemos saber se dois ponteiros são iguais ou diferentes (entre dois ponteiros. Mas que informação recebemos quando comparamos dois ponteiros? Bem, em
(^) e != ). No caso de
operações do tipo
(^) e (^) <= (^) estamos comparando qual ponteiro aponta para uma posição mais
alta (^) na memória
. Então uma comparação entre ponteiros pode nos dizer qual dos dois está "mais
duas variáveis quaisquer:adiante" na memória. A comparação entre dois ponteiros se escreve como a comparação entre outras
p1>p
Entretanto há operações que você
(^) não (^) pode efetuar num ponteiro. Você não pode dividir ou
multiplicar ponteiros, adicionar dois ponteiros, adicionar ou subtrair
(^) float s ou (^) double s de ponteiros.
a) Explique a diferença entre^ Exercícios p++; (*p)++; *(p++);
b) Qual o valor de y no final do programa? Tente primeiro descobrir e depois verifique noExplique o que você entendeu da comparação entre ponteiros O que quer dizer *(p+10);?
explicando o que ele faz e o valor da variável à esquerda do '=' após sua execução.computador o resultado. A seguir, escreva um /* comentário */ em cada comando de atribuição
{int main() #include <stdlib.h> return(0);system("pause");printf ("y = %d\n", y);(p) += x;x--;(p)++;x = 4;x = *p;p = &y;y = 0;int y, *p, x;
}
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
39
Veremos nestas seções que ponteiros e vetores têm uma ligação muito forte.^ Ponteiros e Vetores
Vamos dar agora uma idéia de como o C trata vetores. Quando você declara uma matriz da^ Vetores como ponteiros
seguinte forma:
tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];
o compilador C calcula o tamanho, em bytes, necessário para armazenar esta matriz. Este
tamanho é:
tam1 x tam2 x tam3 x ... x tamN x tamanho_do_tipo
O compilador então aloca este número de bytes em um espaço livre de memória. O
(^) nome da
variável (^) que você declarou é na verdade
(^) um ponteiro para o tipo da variável da matriz
. Este
nome da variável (que é um ponteiro) e aponta para oconceito é fundamental. Eis porque: Tendo alocado na memória o espaço para a matriz, ele toma o
(^) primeiro
(^) elemento da matriz. Mas aí surge a
pergunta: então como é que podemos usar a seguinte notação?
nome_da_variável[índice]
Isto (^) pode (^) ser (^) facilmente
(^) explicado
(^) desde (^) que (^) você (^) entenda
(^) que (^) a notação (^) acima (^) é
absolutamente equivalente
(^) a se fazer:
*(nome_da_variável+índice)
Agora podemos entender como é que funciona um vetor! Vamos ver o que podemos tirar de
É informação deste fato. Fica claro, por exemplo, porque é que, no C, a indexação começa com zero. porque, (^) ao (^) pegarmos
(^) o (^) valor (^) do (^) primeiro
(^) elemento
(^) de (^) um (^) vetor, (^) queremos,
(^) de (^) fato,
*nome_da_variável
(^) e então devemos ter um índice igual a zero. Então sabemos que:
*nome_da_variável é equivalente a nome_da_variável[0]
Outra coisa: apesar de, na maioria dos casos, não fazer muito sentido, poderíamos ter índices
C não verifica a validade dos índices. Elenegativos. Estaríamos pegando posições de memória antes do vetor. Isto explica também porque o
(^) não (^) sabe o tamanho do vetor. Ele apenas aloca a
encontra os elementos requisitados.memória, ajusta o ponteiro do nome do vetor para o início do mesmo e, quando você usa os índices, Vamos ver agora um dos usos mais importantes dos ponteiros: a varredura seqüencial de uma
programa para zerar uma matriz:podemos usar um ponteiro, o qual vamos incrementando. Qual a vantagem? Considere o seguintematriz. Quando temos que varrer todos os elementos de uma matriz de uma forma seqüencial,
{int main () #include <stdlib.h> return(0);system("pause");matrx[i][j]=0.0;for (j=0;j<50;j++)for (i=0;i<50;i++)int i,j;float matrx [50][50];
}
Podemos reescrevê-lo usando ponteiros: {int main () #include <stdlib.h> float *p;float matrx [50][50];
V 06 – 0306
INFORMÁTICA
(^) APLICADA (^) – L INGUAGEM (^) C
40
{for (count=0;count<2500;count++)p=matrx[0]; int count; p++;*p=0.0;
return(0);system("pause");}
}
No primeiro programa,
(^) cada (^) vez que se faz
(^) matrx[i][j]
(^) o programa tem que calcular o
incrementos em um ponteiro é muito mais rápido que calcular 2500 deslocamentos completos.segundo programa o único cálculo que deve ser feito é o de um incremento de ponteiro. Fazer 2500deslocamento para dar ao ponteiro. Ou seja, o programa tem que calcular 2500 deslocamentos. No Há uma diferença entre o nome de um vetor e um ponteiro que deve ser frisada: um ponteiro é
alterar o endereço que é apontado pelo "nome do vetor". Seja:uma variável, mas o nome de um vetor não é uma variável. Isto significa, que não se consegue
vetor++;vetor = vetor + 2; /* ERRADO: vetor nao e' variavel // as operacoes a seguir sao invalidas */ponteiro = &i;int *ponteiro, i; int vetor[10];
/* ERRADO: vetor nao e' variavel */
vetor = ponteiro;
(^) /* ERRADO: vetor nao e' variavel */
Teste as operações acima no seu compilador. Ele dará uma mensagem de erro. Alguns
atribuição.compiladores dirão que se tem "incompatible types in assignment", tipos incompatíveis em umaser colocado do lado esquerdo de uma expressão de atribuição, isto é, uma variável. Outroscompiladores dirão que vetor não é um Lvalue. Lvalue, significa "Left value", um símbolo que pode
ponteiro = vetor; /* as operacoes abaixo sao validas */
/* CERTO: ponteiro e' variavel */
ponteiro = vetor+2;
/* CERTO: ponteiro e' variavel */
O que você aprendeu nesta seção é de suma importância. Não siga adiante antes de entendê-la
6.3.2 bem. Sabemos agora que, na verdade, o nome de um vetor é um ponteiro constante. Sabemos^ Ponteiros como vetores
um ponteiro qualquer. O programa mostrado a seguir funciona perfeitamente:também que podemos indexar o nome de um vetor. Como conseqüência podemos também indexar
{int main ()#include <stdlib.h> #include <stdio.h> return(0);system("pause");printf ("O terceiro elemento do vetor e: %d",p[2]);p=matrx;int *p;int matrx [10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
}
Podemos ver que
(^) p[2] (^) equivale a
(^) *(p+2) .
Seguindo o raciocínio acima, nomes de strings, são do tipo^ Strings
(^) char*
. Isto nos permite escrever a
nossa função
(^) StrCpy()
, que funcionará de forma semelhante à função
(^) strcpy() (^) da biblioteca:
V 06 – 0306
