Estrutura de Um Programa em C

1
Estrutura de um programa em C
-----------------------------
Capituto 1
Um programa em C tem a seguinte estrutura:
declaracao de pre'-processamento
declaracao de variaveis globais(=externas)
main() comando de inicio de programa em C. So' pode existe um no prog.
{ chave de abertura indicando inicio da funcao
declaracao de variaveis;
comandos;
funcoes;
} chave de fechamento encerrando a funcao
As declaracoes de pre'-processamento sao usadas para:
- definir constantes simbolicas para serem substituidas

- incluir arquivos padroes
- definir trechos de programas a serem incluidos, etc...
Esta declaracao pode ou nao existir no programa.
As declaracoes de variaveis globais (ou externas) podem ou nao existir

no programa e sao variaveis utilizadas ao longo de todo o programa, ou seja
todas as funcoes podem utilizar estas variaveis.
A funcao main() representa o inicio do programa em C. Ela tem que existir

sempre no programa em C.
Um funcao em C e' sempre definida entre um abre chave ({) e um fecha chave (}).
Portanto a funcao main(), por exemplo, tem um { e um } que define quais os
comandos ou funcoes que devem ser executados dentro dele.
As funcao main() pode chamar outras funcoes, que por sua vez podem chamar
a si mesma ou a outras. Em C, costumamos trabalhar sempre com funcoes pequenas
para facilitar a programacao e a compreenssao do programa.
Uma funcao generica em C tem os seguintes elementos:
tipo nome da funcao (parametros)

declaracao dos tipos dos parametros;
{
comandos;
funcoes;
}
tipo -------------------> E' o tipo do dado a ser retornado pela funcao.
nome da funcao ---------> E' o nome pelo qual a funcao sera' chamada.
parametros -------------> E' uma lista de variaveis que receberao os valores

passados como argumentos para a funcao. Estes parame-
tros sao recebidos posicionalmente.
tipos dos parametros ---> Se houver parametros, entao o tipo dos parametros
deve ser declarado.
declaracao de variaveis-> Declaracao dos tipos das variaveis que serao

utilizadas pela funcao.
comandos ---------------> E' o corpo da funcao. Contem as instrucoes que

realizam o processamento.
funcoes ----------------> Sao chamadas a outras funcoes ou a si mesma.
Para se documentar um programa em C devemos escrever os comentarios entre

"barra normal asterisco" e "asterisco barra normal". O exemplo disto e' o
proprio texto que voce esta' lendo. Isto e' um programa executavel em C.
Falta apenas mais um detalhe importante neste momento. As letras maiusculas

e minusculas sao intepretadas como label diferentes em C. Usualmente se
escreve tudo em letras minusculas pois as palavras-chaves sao em minusculas,
ja'as constantes escreve-se em letras maiusculas.
2
Exemplo:
loop, Loop, LOop, LOOP, sao 4 labels diferentes em C
*/
/*
Exemplo 1:*/
#define ex1 /* estas duas declaracoes com o simbolo # na frente sao

de pre'-processamento */
#ifdef ex1 /* observe como o comentario esta' escrito */
main()
{
printf("Este 1. programa em C contem somente a funcao main()\n");
/* a funcao printf e' definida na biblioteca padrao */

}
#endif /* esta tambem e' uma declaracao de pre'-processamento */

/*
Exemplo 2:
*/
#ifdef ex2
main()
{
printf("\nVoce esta' na funcao main()\n");
printf("Este exemplo simula como e' chamada uma funcao.\n\n");
funcao1(); /* a chamada de uma funcao e' atraves do nome da

funcao mais os parametros a serem passados. neste
caso nao existe parametros sendo passado.*/
printf("Voce esta' de volta a funcao main()\n");

printf("Fim do programa\n");
}
funcao1()
{
printf("\t Voce esta' na funcao 1\n");
printf("\t Bem vindo a funcao 1\n\n");
}
#endif
/*
Exemplo 3:
*/
#ifdef ex3
main()
{
printf("Este exemplo simula como a funcao 1 chama a funcao2.\n\n");
funcao1();

}
funcao1()
{
printf("\t Voce esta' na funcao 1\n");
printf("\t Bem vindo a funcao 1\n\n");
funcao2(); /* aqui a funcao 1 chama a funcao 2 */
printf("\t Voce esta' de volta a funcao 1\n\n");
funcao2()
{
printf("\t\t Voce esta' na funcao 2\n");
printf("\t\t Voce chegou a funcao 2 com sucesso. Parabens.\n\n");
}
#endif
3
Capituto 2
/**********************************************************************
FUNCOES DE BIBLIOTECA
**********************************************************************
1 - getchar() -> le um caracter da entrada padrao ate' um ENTER.
A forma geral da função getchar() e´:

variavel = getchar();
Exemplo:*/
#ifdef ex1
main()
{
char c;
clrscr();
printf("digite um caracter : ");
c = getchar();
printf("o caracter digitado e': %c",c);
}
#endif
/*
2 - putchar() -> imprime um caracter na saida padrao.
A forma geral da funcao putchar() e':

putchar(variavel);
Exemplo:*/
#ifdef ex2
main()
{
char c;
clrscr();
printf("digite um caracter : ");
c = getchar();
printf("o caracter digitado e': ");
putchar(c);
}
#endif
/*
3 - gets () -> le uma serie de caracteres da entrada padrao ate' um ENTER.
A forma geral da funcao gets() e':

gets(variavel);
Exemplo:*/
#ifdef ex3
main()
{
char c[128];
clrscr();
printf("digita um string via teclado : ");
gets(c);
printf("a string digitada e': %s",c);
}
#endif
/*
4 - puts() -> escreve uma serie de caracteres na saida padrao.
A forma geral da funcao puts() e´:

puts(variavel);
Exemplo:*/
#ifdef ex4
main()
{
char c[128];
clrscr();
puts("digita um string via teclado : ");
gets(c);
printf("a string digitada e': ");
puts(c);
4
}
#endif
/*
5 - printf() -> escreve caracteres formatados na saida padrao.(no caso video)
A forma geral da funcao printf() e´:

printf("<expressão de controle>", lista de argumentos);
A <expressao de controle> contem tanto caracteres para serem impressos na

tela como codigos de formatacao que especificam como apresentar o restante
dos argumentos. Esses codigos de formatacao tem a forma de um sinal de
porcentagem (%) seguido por uma letra.
Os codigos de formatacao sao os seguintes:
%c - exibe um caracter simples

%d - exibe um inteiro
%f - exibe um numero em ponto flutuante
%e - exibe um numero em notacao cientifica
%g - utiliza o mais curto de %e ou %f,
%o - exibe um numero em notacao octal
%s - exibe uma serie de caracteres (string)
%u - exibe um inteiro sem sinal
%x - exibe um numero em notacao hexadecimal
%% - exibe um sinal de %
Exemplos:*/
#ifdef ex5
main()
{
clrscr();
printf("exemplos dos codigos de formatacao\n");
printf("A letra e': %c\n\n", 'A');
printf("A letra e': %c\n\n", 65);
printf("A idade do usuario: %d peso: %d altura: %d\n\n", 41, 80 , 178);
printf("O preco do item e': %f\n\n", 572.34);
printf("A area do circulo e' %e\n\n", 2 * 3.14159 * 2.0031);
printf("Exibir 0.1234 resulta em %g\n\n", 0.1234);
printf("Exibir 0.00001234 resulta em %g\n\n", 0.00001234);
printf("O nome da minha faculdade e' %s\n\n","Fatec Baixada Santista");
printf("Exibindo 42000 como int sem sinal %u\n", 42000);
/*para o programa e espera uma tecla para ver o resultado na tela*/

puts("\n\naperte qualquer tecla");
getchar();
}
#endif
/*
E' possivel tambem indicar o tamanho do campo, justificacao (a direita ou
a esquerda) e o numero de casas decimais(precisao. Para isto usa-se codigos
colocados entre o % e a letra que indica o tipo de formatacao.
O formato geral e':
% <justificacao> <tamanho de campo> . numero de casas decimais <codigo de formatacao>
Exemplo:
%6d -> define a justificacao a direita e o tamanho de campo com 6 posicoes

%-6d -> define a justificacao a esquerda e o tamanho de campo com 6 posicoes
%15.2f -> define a justificacao a direita, o tamanho de campo com 15 posicoes

e 2 casas depois da virgula.
%-15.2f -> define a justificacao a esquerda, o tamanho de campo com 15 posicoes
e 2 casas depois da virgula.
%10s -> define a justificacao a direita e o tamanho de campo com 10 posicoes

%-10s -> define a justificacao a esquerda e o tamanho de campo com 10 posicoes
Exemplos:*/
#ifdef ex6
main()
{
clrscr();
printf("12345678901234567890 regua\n"); /* regua */
/* campos numericos */
5
printf("%d\n",512); /* sem justificacao e tamanho de campo*/
printf("%6d\n",512); /* justifica a direita c/ tam = 6 */
printf("%-6d\n",512); /* justifica a esquerda c/ tam = 6 */
printf("\n12345678901234567890 regua\n"); /* regua */

printf("%f\n",10.5473); /* sem justificacao, tamanho de campo e precisao*/
printf("%15.2f\n",10.5473); /* justifica pela direita c/ tam = 15 prec = 2*/
printf("%-15.2f\n",10.5473); /* justifica pela esquerda c/tam = 15 prec = 2*/
/* campos alfanumericos */
printf("\n12345678901234567890 regua\n"); /* regua */
printf("%s\n","FATEC"); /* sem justificacao e tamanho de campo*/
printf("%10s\n","FATEC"); /* justifica pela direita c/ tam = 10 */
printf("%-10s\n","FATEC");/* justifica pela esquerda c/ tam = 10 */

getchar();
}
#endif
/*
6 - scanf() -> le caracteres formatados da entrada padrao. (no caso teclado)
A forma geral da funcao scanf() e´:

scanf("<expressão de controle>", lista de argumentos);
A <expressao de controle> so pode conter os codigos de formatacao que

especificam como apresentar o restante dos argumentos.
Assim como no printf() esses codigos de formatacao tem a forma de um sinal
de porcentagem (%) seguido por uma letra.
Os codigos de formatacao sao os seguintes:
%c - leia um unico caracter simples

%d - leia um inteiro decimal
%f - leia um numero em ponto flutuante
%o - leia um inteiro octal
%s - leia uma serie de caracteres
%u - exibe um inteiro sem sinal
%x - leia um inteiro hexadecimal
%e - exibe um numero em notacao cientifica
%g - utiliza o mais curto de %e ou %f,
OBS.:
1 - A leitura do dado deve ser armazenada no endereço de memória que o
computador alocou para a variável declarada. Por isso o operador &
é utilizado nesta função, armazenando o valor informado pelo usuário
no correto endereço de memória onde tal variável foi criada pelo
computador.
2 - Nao pode ser usado mensagens na serie de controle apenas os codigos

de formatacao.
Exemplo: */
#ifdef ex7
main()
{
char letra;
clrscr();
printf("digite uma letra: ");
scanf("%c",&letra);
printf("a letra digitada e': %c",letra);
}
#endif
#ifdef ex8
main()
{
char a[255];
clrscr();
printf("digite uma string: \n");
scanf("%s",a);
printf("a string digitada e': %s",a);
}
#endif
6
#ifdef ex9
main()
{
int d;
float f;
unsigned u;
float e;
float g;
clrscr();
printf("digite um numero inteiro: ");
scanf("%d",&d);
printf("o numero digitada e': %d",d);
printf("\n\ndigite um numero real (123.123): ");

scanf("%f",&f);
printf("o numero digitada e': %f",f);
printf("\n\ndigite um numero inteiro positivo: ");

scanf("%u",&u);
printf("o numero digitada e': %u",u);
printf("\n\ndigite um numero no formato exponencial (1234e23): ");

scanf("%e",&e);
printf("o numero digitada e': %e",e);
printf("\n\ndigite um numero real no formato exponencial (1234e23) ou normal(123): ");

scanf("%g",&g);
printf("o numero digitada e': %g",g);

getchar();
getchar();
}
/**********************************************************************
EXERCICIOS
**********************************************************************
1 - Escreva um programa utilizando a funcao getchar e receba via teclado o

seu nome e imprima-o no video utilizando a funcao putchar.
2 - Escreva um programa utilizando a funcao gets e receba via teclado o

seu nome e imprima-o no video utilizando a funcao printf. Utilize a
funcao puts para imprimir as instrucoes.
3 - Escreva um programa utilizando as funcoes printf e scanf para receber um

nome via teclado e imprima-o no video no seguinte formato:
10 20 30 40 50
12345678901234567890123456789012345678901234567890
Rui Rui
Rui Rui
Rui
Capitulo 3
/**********************************************************************
TIPO DE VARIAVEIS EM C
**********************************************************************
1 - Tipos de variaveis
Os tipos de variaveis sao:
char ------> um unico byte, capaz de conter um caracter do conjunto de

caracteres ASCII.(variam no intervalo -128 a 127)
int -------> um inteiro, armazenado em 2 bytes, podem ser positivo ou
negativo variando em -32768 e 32767.
float -----> numeros reais em ponto flutuante, armazenado em 4 bytes.
(variam no intervalo -3.4E-38 a 3.4E+38).
double ----> numeros reais em ponto flutuante, porem armazenado em 8 bytes
permitindo maior precisao para os dados. (varia no intervalo
-1.7E-307 a 1.7E+308).
Exemplo:
*/
#ifdef ex1
main()
{
7
char a = 'z'; /* variavel tipo caracter */
int b = 3000; /* variavel tipo inteira */
float c = 1456.753; /* variavel tipo ponto flutuante */
double d = 9987.453; /* variavel tipo ponto flutuante dupla precisao */
clrscr();
printf("imprimi o conteudo das variavel tipo:\n");
printf("\tcaracter --------------------------> %c\n",a);
printf("\ttipo inteira ----------------------> %d\n",b);
printf("\tponto flutuante precisao simples --> %f\n",c);
printf("\tponto flutuante dupla precisao ----> %lf\n",d);
}
#endif
/*
2 - Qualificadores de variaveis
Os qualificadores sao utilizados nos tipos de variaveis acima. Sao eles:

short -> valores curtos. Tem o mesmo tamanho do inteiro
long -> valores longos. Sao armazenados em 4 bytes
unsigned -> valores sem sinal. Transforma os valores negativos
em positivos aumentando assim o intervalo de variacao dos
mesmos. Este qualificador tambem pode ser utilizado para
o tipo char.
Aplicando os qualificadores nas variaveis acima:
Inteiro curto -> short int ou short

faixa de valores -> -32768 a +32767
Inteiro longo -> long int ou long

faixa de valores -> - 2.147.483.648 a 2.147.483.647
caracter Sem sinal -> unsigned char

faixa de valores -> 0 a 255
inteiro Sem sinal -> unsigned int

Inteiro curto sem sinal -> unsigned short int ou unsigned short
Inteiro longo sem sinal -> unsigned long int ou unsigned long
faixa de valores -> 0 a 4.294.967.295
Obs.: Na funcao printf para imprimir um valor long utiliza-se a letra

"l" associada a letra "d" para inteiro e a letra "u" para sem
sinal. Para imprimir um valor short utiliza-se a letra "h".
Exemplo:
*/
#ifdef ex2
main()
{
short int a = 10000;
long int b = 100000;
unsigned char c = 112;

unsigned int d = 45000;
unsigned short e = 40000;
unsigned long f = 400000;
clrscr();
printf("imprimi o conteudo da variavel tipo inteiro com os qualificadores\n");
printf("\t inteiro curto ------------> %hd\n",a);
printf("\t inteiro longo ------------> %ld\n",b);
printf("\t caracter sem sinal -------> %u %c \n",c,c);
printf("\t inteiro sem sinal -------> %u\n",d);
printf("\t inteiro curto sem sinal --> %hu\n",e);
printf("\t inteiro longo sem sinal --> %lu\n",f);
}
#endif
/*
3 - Nomes de variaveis
O nome atribuido a uma variavel deve expressar o significado do seu

conteudo para facilitar o entendimento do programa e seu debug.
Existe 4 regras basicas para se dar um nome a uma variavel, sao elas:
a) Todo nome de variavel deve comecar por uma letra ou o caracter sublinha(_).
8
b) Os caracteres seguintes podem ser letras, numeros ou o caracter sublinha.
E' usual em C utilizar letras minusculas para nome de variaveis e letras
maiusculas para constantes simbolicas.
c) O numero de digitos que tem significado para o compilador sao 8, mas
o nome pode ter qualquer tamanho.
d) Existem certas palavras reservadas que formam a linguagem C que nao podem
ser utilizadas. Sao elas:
auto break case char continue default do

double else entry extern float for goto
if int long register return short sizeof
static struct switch typedef union unsigned while
4 - Declaracao de variaveis
O formato para declarar uma variavel e':

<tipo> < nome da variavel>;
As variaveis tem que ser declaradas sempre e sempre no inicio da funcao.
O nome de uma variavel nada tem a ver com seu tipo.
As variaveis sao declaradas em 3 locais em um programa C. Sao eles:

a) dentro das funcoes
b) fora das funcoes
c) na definicao dos parametros das funcoes
Exemplo:
*/
#ifdef ex3
int fora=10; /* variavel declarada fora da funcao (global) */
main()
{
int dentro = 20; /* variavel declarada dentro da funcao (local) */
int var = 30; /* variavel que sera' passada como informacao para a funcao*/
clrscr();
printf("imprimi a variavel fora %d\n",fora);
printf("imprimi a variavel dentro %d\n",dentro);
imp(var); /* variavel passada como parametro para a funcao imp */
puts("voce voltou a funcao main\n");

}
imp(var1)
int var1; /* variavel recebida como parametro na funcao imp */
{
puts("\t voce esta' na funcao imp que vai imprimir no video o conteudo da");
printf("\t variavel par recebida como parametro que e' %d\n",var1);
}
#endif
/*
Isto define a Classe de armazenamento de uma variavel.
5 - Classes de armazenamento de variaveis
Existem 4 classes de armazenamento. Sao elas:
a) Automaticas ou locais
sao variaveis declaradas dentro de uma funcao e sem especificao quanto
a classe de armazenamento. A palavra chave auto e' opcional. Elas so'
existem durante a execucao da funcao.
b) Externas ou globais
sao variaveis declaradas fora de qualquer funcao, o que torna seu valor
acessivel a todas as funcoes do modulo em que ocorre a sua definicao.
Elas existem durante todo o processamento.
c) Estaticas
As variaveis estaticas podem ser locais ou globais.
Estaticas locais -> sao declaradas dentro de uma funcao e tem sua memoria
alocada em tempo de compilacao. Estas tem o mesmo tempo de vida das externas
porem estao restritas a funcao na qual foram declaradas.
Estaticas globais -> Sao declaradas fora de qualquer funcao e sao visiveis
apenas no arquivo onde foram definidas, ficando inacessiveis aos outros
modulos que porventura venham a ser ligados a este. Uma funcao tambem pode
9
ser declarada estatica sendo visivel apenas ao arquivo onde se encontra.
d) Registradores
Sao variaveis declaradas dentro de uma funcao que quando possivel o
compilador coloca em registradores da CPU e nao em memoria. Normalmente
usamos estas declaracao em variaveis muito utiliza no programa.
Exemplo:
*/
#ifdef ex4
int fora = 25000;
static long fora1 = 2000000;
main()
{
unsigned dentro = 45000;
static long dentro1 = 4000000;
register int reg = 30000;
clrscr();
printf("imprime o conteudo da variavel fora %d\n",fora);
printf("imprime o conteudo da variavel static fora %ld\n",fora1);
printf("imprime o conteudo da variavel dentro %u\n",dentro);
printf("imprime o conteudo da variavel static dentro %ld\n",dentro1);
printf("imprime o conteudo da variavel register int reg %d\n",reg);
}
#endif
/*
6 - Constantes
Constantes em C referem-se a valores fixos que nao podem ser alterados pelo
programa. Elas podem ser de qualquer tipo e sao utilizados para inicializar
os varios tipos de variaveis vistos acima.
Exemplo: 's' constante tipo caracter (sempre entre apostrofes)

1 constante tipo inteiro
35000 constante tipo inteiro longo
33450000 constante tipo ponto flutuante
3.345E+7 constante tipo ponto flutuante (notacao cientifica)
"string" constante tipo vetor (sempre entre aspas)
Alguns caracteres especial foram criados em C para facilitar a portabilidade

dos programas. Sao eles:
\n nova linha (linefeed+carriage return)

\t tabulacao horizontal
\b retrocesso (backspace)
\f mudanca de pagina (form feed)
\r inicio de linha (carriage return)
\\ barra a invertida
\' apostrofe
\0 nulo (finalizador de string)
*/
#ifdef ex5
main()
{
int z = 20000;
int y = 25000;
clrscr();
printf("imprime o conteudo da variavel z \t %d\n",z);
printf("imprime o conteudo da variavel y %d \b\b\b",y);
getchar();
printf("imprime os caracteres especiais \\ e \'\r");
}
/**********************************************************************
EXERCICIOS
**********************************************************************
1 - Escreva um programa e inicialize as variaveis do tipo char, int short,

long, unsigned(char, int, short, long), float e double com seus valores
limites e imprima-os no video. Utilize variaveis globais para os valores
positivos e locais para os negativos.
2 - Escreva um programa que receba via teclado um n. inteiro short, long,

unsigned, float, double e um char e imprima-os no video no seguinte
formato:
10 20 30 40 50 60
12345678901234567890123456789012345678901234567890123456789012345 regua
10
short long unsigned
float double char
3 - Escreva um programa que tem como variaveis globais os valores 32800 e

64000 e como variaveis local os valores 10000 e 100000 e imprima-os no
video.
4 - Escreva um programa que recebe via teclado os valores limites sem sinal para
as variaveis do tipo char, int e long int e imprima-os no video.
5 - Escreva um programa que recebe via teclado os valores limites sem sinal para
as variaveis do tipo float e double e imprima-os no video.
Capitulo 4
/**********************************************************************
MATRIZES OU VETORES DE DADOS
**********************************************************************
1. Compreendendo o que sao matrizes ou vetores
Muitas vezes nos programas, e´ necessário que uma variavel contenha muitos valores.
Por exemplo, uma variavel nota pode controlar as "notas" obtidas por 100 alunos em
um exame. Da mesma maneira, uma variavel "salarios" pode controlar os salarios de
cada funcionario em uma empresa.
Uma vetor e´ um conjunto de dados que pode armazenar multiplos valores do mesmo
tipo. Por exemplo, pode-se criar uma vetor que contenha 100 valores do tipo int
e um segundo vetor com 25 valores do tipo float. O que fica claro e´ que todos
os valores que voce atribui a um vetor tem que ser do mesmo tipo.
2.Definicao
Vetores sao variaveis compostas que agrupam dados do mesmo tipo que sao
referenciadas atraves de um indice.
Em C, todos os vetores sao montados numa sequencia continua de memoria ou seja,

o endereco mais baixo corresponde ao primeiro elemento, e o endereco mais alto
ao ultimo elemento.
3.Declaracao de vetores
Para declarar um vetor, precisa-se especificar o tipo de dados desejado (tal como
int, float ou double), bem como o tamanho do vetor. Para especificar o tamanho de um
vetor,coloca-se o numero de elementos que o vetor pode armazenar dentro de
colchetes apos o nome do vetor.
O formato para declaracao de um vetor e':
tipo nome_variavel [tamanho];

onde:
tipo -> eúm tipo qualquer dados
nome_variavel -> eó nome pelo qual o vetor vai ser referenciado
tamanho -> eó número de elementos que o vetor vai conter
OBS.: O nome_variavel de um vetor deve expressar o seu significado, mas deve

obedecer as mesmas 4 regras para atribuicao de nomes das variaveis simples.
Exemplo:
*/
int notas [100]; /*declara um vetor de nome notas do tipo int que pode armazenar
100 notas de exame */
float salarios [50]; /*declara um vetor de nome salarios do tipo float, que pode
armazenar 50 salários */
/*
Outro detalhe importante e´que em C nao ha verificacao de limites nos vetores.
Isto significa que e´possivel ultrapassar o fim de um vetor e escrever em outras
variaveis, ou mesmo em trechos de codigo de programa. E´tarefa do programador
fazer com que os indices dos vetores estejam sempre dentro dos limites
estabelecidos pela declaracao de tamanho do vetor.
4. Refenciando um elemento do vetor
Cada um dos elementos de um vetor e´refenciado individualmente por meio de um

numero inteiro entre colchetes apos o nome do vetor. Este numero tem um
significado diferente quando referencia um elemento do vetor e na declaracao
do vetor,onde indica o seu tamanho.
Quando referenciamos um elemento do vetor, este numero especifica a posicao do

11
elemento no vetor
Exemplo:
notas [4]; referencia o 5. elemento do vetor notas
salarios [13]; referencia o 14. elemento do vetor salarios
/*
Observando os exemplos podemos notar que o n. do elemento eúm a mais que
a referencia entre colchetes. Isso acontece por que em C as refencias ou indices
comecam em 0 e a referencia do ultimo elemento eó tamanho do vetor -1.
5.Inicializacao de vetores
A inicialização de um vetor e´feita junto com na declaração da variavel com

valores iniciais prefixados.
Quando o vetor eínicializado temos 2 formatos:
1 - declarando o n. de elementos do vetor explicitamente.
exemplo: int notas [4] = {1,2,3,4};
2 - sem declarar o tamnhao do vetor. Neste caso, o tamanho sera´ preenchido

pelo pre-compilador que contara o n. de elementos da inicializacao. Os
colchetes sao declarados vazios neste caso.
exemplo: int notas [] = {1,2,3,4};
Observe nos exemplos acima que a inicializacao e´feita utilizando-se o abre

chave({) e o fecha chave(}) colocados depois do sinal de atribuicao(=) e
separados por virgulas.
Um vetor so' pode ser inicializado se declarado como uma variavel global
ou static.
Um vetor automatico ou local pode ser inicializado se for elemento por

elemento.
Exemplos de inicializacao de vetores:*/
#ifdef ex1
int f[10]={1,2,3,4,5,6,7,8,9,10}; /* variavel global do tipo inteira*/
/* tamanho declarado explicitamente */
main()
{
clrscr();
printf("Os numeros sao: ");
printf(" %d",f[0]);
printf(" %d",f[1]);
printf(" %d",f[2]);
printf(" %d",f[3]);
printf(" %d",f[4]);
printf(" %d",f[5]);
printf(" %d",f[6]);
printf(" %d",f[7]);
printf(" %d",f[8]);
printf(" %d",f[9]);
}
#endif
#ifdef ex2
main()
{
/* inicializacao como variavel local static sem declarado de tamanho */
static int f[]={10,20,30,40,50,60,70,80,90,100};
clrscr();
printf("Os numeros sao: ");
printf(" %d %d %d %d %d %d %d %d %d %d",f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],f[8],f[9]);
}
#endif
#ifdef ex3
main()
{
float f[10]; /* declara tamanho do vetor e tipo*/
12
f[0] = 11.1; /* inicializacao elemento por elemento*/

f[1] = 12.2;
f[2] = 13.3;
f[3] = 14.4;
f[4] = 15.5;
f[5] = 16.6;
f[6] = 17.7;
f[7] = 18.8;
f[8] = 19.9;
f[9] = 20.29;
clrscr();
printf("Os numeros sao: \n");
printf(" %f\n",f[0]);
}
#endif
/*
6. Vetores com mais de uma dimensao
Como foi visto, um vetor e´ uma variavel que pode armazenar multiplos valores
do mesmo tipo. Nos exemplos apresentados, os vetores consistiram de uma fileira
de dados. No entanto, a Linguagem C permite vetores bi, tri e multidimensionais.
O melhor modo de visualizar uma matriz bidimensional ećom uma tabela com linhas
e colunas. Se um vetor contem tres dimensoes, visualize-a como varias páginas,
cada uma das quais contendo uma tabela bidimensional.
Por exemplo, ao declarar-se um vetor bidimensional, o primeiro valor que for

especificado informara o numero de linhas, e o segundo valor, o numero de colunas:
Exemplo:
int tabela [2] [3]; vetor bidimensional
int tabela [2] [3] [4]; vetor tridimensional
Apesar de na linguagem C utilizar-se o conceito de "vetor multi dimensional" os

elementos destes vetores sao armazenados na memória de forma linear ou continua.
7. Inicializacao de vetores com mais de uma dimensao
Os vetores de mais de uma dimensao sao inicializados da mesma maneira que os de

dimensao unica, isto e´, os elementos sao colocados entre o abre chave({) e o
fecha chave(}) depois do sinal de atribuicao e separados por virgulas. Como seus
elementos tambem sao vetores, estes, por sua vez, tambem sao inicializados
com seus elementos entre chaves e separados por vírgulas.
Exemplo:
linhas colunas
int tabela [2] [3] = {{1,2,3}, {4,5,6}};
linha 1 linha 2
Exemplo:
*/
#ifdef ex4
int tabela [2] [3] = {{10,20,30}, {40,50,60}}; /* vetor bidimensional*/
main()
{
clrscr();
printf(" valor da linha 1 coluna 1-> %d\n",tabela[0] [0]);


}
#endif
13
#ifdef ex5
float valores[2][3][5] = {
{{1.0, 2.0, 3.0, 4.0, 5.0},
{6.0, 7.0, 8.0, 9.0, 10.0},
{11.0, 12.0, 13.0, 14.0, 15.0}},
{{16.0, 17.0, 18.0, 19.0, 20.0},

{21.0, 22.0, 23.0, 24.0, 25.0},
{26.0, 27.0, 28.0, 29.0, 30.0}}
}; /* vetor tridimensional*/
main()
{
clrscr();
printf("Valores do vetor 1\n");
printf(" linha 1 coluna 1-> %f\n",valores[0] [0] [0]);



printf(" linha 3 coluna 5-> %f\n\n",valores[0] [2] [4]);
printf("aperte a tecla enter para continuar");

getchar();
clrscr();
printf("Valores do vetor 2\n");



printf(" linha 3 coluna 5-> %f\n\n",valores[1] [2] [4]);
printf("aperte a tecla enter para finalizar");

getchar();
}
#endif
/*
8. Serie de caracteres ou strings
String eúm vetor do tipo char que armazena um serie de caracteres terminado
pelo carater finalizador \0. Traduzindo, string eúma serie de caracteres, onde
cada um deste caracteres ocupa um byte de memoria, sao armazenados em sequencia e com
o ultimo byte sendo o finalizador \0. Cada caracter e´ um elemento independente do
vetor e portanto pode ser acessado por meio de um indice.
Exemplo:
fatec loop Maria
9. Inicializando strings
Lembrando que qualquer vetor pode ser inicializado se for uma variavel global ou
static.Com as strings nao e´diferente. Podemos inicializar um vetor de strings de
2 formas:
1 - Inicializando letra por letra como nos vetores numerico. Neste caso, o finalizador
14
deve ser colocado explicitamente.
char nome [] = {'F','A','T','E','C'}; sem finalizador
char nome [] = {'F','A','T','E','C','\0'}; com finalizador
Exemplo:
*/
#ifdef ex6
char f[]={'A','B','C','D','E','F','G','H','I','J'};
/* variavel externa do tipo caracter, com inicializacao letra por letra
Aqui nao tem finalizador. Sem contar o n. de caracteres*/
main()
{
clrscr();
printf("As letras sao: \n");
printf(" %c",f[0]);
printf(" %c",f[1]);
printf(" %c",f[2]);
printf(" %c",f[3]);
printf(" %c",f[4]);
printf(" %c",f[5]);
printf(" %c",f[6]);
printf(" %c",f[7]);
printf(" %c",f[8]);
printf(" %c",f[9]);
}
#endif
#ifdef ex7
char f[10]={'Z','Y','X','W','V','U','T','S','R','Q'};
/* idem ao anterior. Contando o n. de elementos do vetor. */
main()
{
clrscr();
printf("As letras sao: \n");
printf(" %c %c %c %c %c %c %c %c %c %c",f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],f[8],f[9]);
}
#endif
/*
2 - Inicializando como string. Neste caso o finalizador ećolocado automaticamente.
Lembrando ainda que o finalizador tabem eúm caracter, portanto ocupa uma posicao
no vetor.
char nome [] = {"FATEC"}; sem contar os caracteres da string

(pre compilador conta)
char nome [6] = {"FATEC"}; contando os caracteres da string (5 letras + 1 do

finalizador
Exemplo:
*/
#ifdef ex8
main()
{
/* variavel static local do tipo caracter. Sem contar o n. de caracteres*/
static char f[]="abcdefghij";
clrscr();
printf(" As letras sao: \n");
printf(" %c",f[0]);
printf(" %c",f[1]);
printf(" %c",f[2]);
printf(" %c",f[3]);
printf(" %c",f[4]);
printf(" %c",f[5]);
printf(" %c",f[6]);
printf(" %c",f[7]);
printf(" %c",f[8]);
printf(" %c\n\n",f[9]);
printf("Acessando o vetor como string -> %s\n",f);

}
#endif
#ifdef ex9
15
char f[11]="zyxwvutsrq";
/* idem ao anteiror. Contando o n. de caracteres.*/
main()
{
clrscr();
printf(" As letras sao: \n");
printf(" %c",f[0]);
printf(" %c",f[1]);
printf(" %c",f[2]);
printf(" %c",f[3]);
printf(" %c",f[4]);
printf(" %c",f[5]);
printf(" %c",f[6]);
printf(" %c",f[7]);
printf(" %c",f[8]);
printf(" %c\n\n",f[9]);
printf("Acessando o vetor como string -> %s\n",f);

}
#endif
/*
10. Um vetor de strings
Anteriormente nos estudamos vetores com mais de uma dimensao. Uma string eúm vetor
unidimensional. Portanto, se juntarmos um conjunto de strings num unico vetor teremos
um vetor bidimensional.
Podemos ver a forma geral de uma vetor de strings como sendo:
char nome_da_variável [num_de_strings][compr_das_strings];
Exemplo:
char semana [7] [14]; vetor do tipo char com 7 linha(string) e 14 colunas(as
strings com no maximo 14 caracteres
11 - Acessando uma string no vetor de strings
Para aceesar uma string no vetor de strings usa-se apenas o primeiro índice do vetor.
A forma geral para acessar uma string e´:
nome_da_variável [num_de_strings];
Exemplo:
semana [0]; acessa o 1. string do vetor semana
Obs.: Pode-se acessar tambem qualquer caracter de qualquer uma das

strings, isto e´ feito utilizando os dois indices.
exemplo:
semana [0] [2]; acessa a 1. string e o 3 caracter desta.
12. inicializacao de um vetor de strings
Como um vetor de strings eúm vetor bidimensional inicializa-se colocando

o sinal de atribuicao, o abre chave ({) e o fecha chave (}) e as strings
entre aspas (") e separadas por virgula.
Exemplo:
char semana [7] [14] = { "Domingo" ,

"Segunda-feira",
"Terca-feira",
"Quarta-feira",
"Quinta-feira",
"Sexta-feira",
"Sabado",
};
*/
#ifdef ex10
"Segunda-feira",
"Terca-feira",
"Quarta-feira",
"Quinta-feira",
"Sexta-feira",
16
"Sabado",
};
main()
{
clrscr();
printf(" Dias da semana \n\n");

printf(" %s\n",semana [0]);
}
#endif
#ifdef ex11
"Segunda-feira",
"Terca-feira",
"Quarta-feira",
"Quinta-feira",
"Sexta-feira",
"Sabado",
};
main()
{
clrscr();
printf(" Acessando cada letra da string sabado \n\n");

printf(" %c",semana [6][0]);
printf("%c",semana [6][1]);
}
/**********************************************************************
EXERCICIOS
**********************************************************************1 - Escreva um
programa que tenha os vetores com as inicializacoes abaixo e
imprima-os no video.
valores -> 1,10,100,1000,10000,100000,1000000 -> variavel global

caracteres -> a ate i -> variavel local
string -> isto e' um teste de string dos alunos do 5. ciclo -> variavel local
2 - Escreva um programa para receber 3 strings de ate 10 caracteres cada via

teclado e imprimi-as no video no seguinte formato:
10 20 30 40 50 60
123456789012345678901234567890123456789012345678901234567890 regua
string1 string2 string3
3 - Escreva um programa para receber via teclado em vetores 3 int, 3 long,

3 unsigned, 3 float e 3 double e imprima-os no video no seguinte formato:
10 20 30 40 50
12345678901234567890123456789012345678901234567890 regua
int long unsigned
float double
int long unsigned
float double
int long unsigned
float double
4. Escreva um programa que receba via teclado 7 valores inteiros armazenando-os

em um vetor. Imprima no video o vetor mostrando o indice de cada posições e
seu respectivo valor.
5. Escreva um programa que inicialize uma vetor multidimensional de 2x3x3

de n. inteiros e inicialize-o com 0. Receba via teclado novos valores para
todos os elementos do vetor e imprima no video estes novos conteudos
17
Capitulo 5
/**********************************************************************
ESTRUTURA DE DADOS
**********************************************************************
1. Definicao
Estrutura e' uma variavel composta, formada por uma ou mais variaveis,
possilvelmente de tipos diferentes, colocadas juntas sob um unico nome.
2. Declaracao de estruturas
O formato geral para a declaracao de um estrutura e':
struct nome_estrutura -> aqui usamos a palavra-chave struct e definimos o

nome da estrutura (eópcional)
{ -> chave de abertura
lista de variaveis; -> onde declaramos o tipo e nome das variaveis
}; -> chave de fechamento
Observa-se que a declaracao termina com um ponto-e-vírgula. Temos ainda que, o

nome da estrutura, identifica essa estrutura de dados particular e junto com a
palavra reservado struct define um novo tipo da dado.
Somente com esta declaracao nenhuma variável foi criada ainda. Somente o tipo
do dado foi definido. Para declarar uma variável com essa estrutura, usa-se o
seguinte formato:
struct nome_estrutura nome_variavel; -> define o nome da variavel que tem a forma
da estrutura definida anteriormente.
O formato da declaracao de uma variavel simples e´:
tipo nome_variavel;
Exemplo:
int calendario;
Por analogia de sintaxe, temos a declaracao de uma variavel do tipo estrutura como:
Exemplo:
1 - se declara o tipo da variavel
struct data
{
int dia;
int mes;
int ano;
int dia_ano;
};
2 - se declara a variavel
struct data calendario;
3. Referencia aos membros de uma estrutura
Para nos referenciarmos a um membro dentro de uma estrutura usamos o operador

ponto(.) com o seguinte formato:
nome_variavel.membro
Exemplo:
calendario.dia
calendario.mes
calendario.ano
calendario.dia_ano
4. Inicializacao de estruturas
Uma estrutura so' pode ser inicializado se declarado como uma variavel global
ou static local.
Porem se a inicializacao for elemento por elemento, desta pode ser automatica
ou local.
Exemplos: */
18
#ifdef ex1
struct data {
int dia;
int mes;
int ano;
int dia_ano;
};
struct data calendario = {7,9,1822,250}; /* variavel global */
main()
{
clrscr();
printf("\nProclamacao da Independencia: ");
printf("%d/",calendario.dia);
printf("%d/",calendario.mes);
printf("%d, ",calendario.ano);
printf("%d\n",calendario.dia_ano);
}
#endif
#ifdef ex2
struct data {
int dia;
int mes;
int ano;
int dia_ano;
};
main()
{
static struct data calendario = {15,11,1889,319}; /*variavel static local*/
clrscr();
printf("\nProclamacao da republica: ");
}
#endif
#ifdef ex3
struct data {
int dia;
int mes;
int ano;
int dia_ano;
};
main()
{
struct data calendario; /*variavek local */
calendario.dia=26; /*inicializacao elemento por elemento */

calendario.mes=1;
calendario.ano=1839;
calendario.dia_ano=26;
clrscr();
printf("\nFundacao de Santos: ");
}
#endif
/*
5. Estruturas dentro de estruturas
Uma estrutura dentro de outra estrutura nada mais e' que uma variavel composta
dentro de outra variavel composta pois, as estruturas podem ser compostas por
qualquer tipo de variavel.
Quando uma estrutura é um elemento de outra estrutura, ela é chamada de estrutura

aninhada.
Para acessar os membros de uma estrutura dentro de outra estrutura usamos o mesmo
operador ponto(.) referenciando estes da esuqerda para a direita e do mais externo
19
para o mais interno no seguinte formato:
nome_variavel.nome_variavel.membro
Exemplo: calendario(variavel externa) .tempo variavel interna) .hora (elemento)
Para se inicializar uma estrutura dentro de outra estrutura tambem vale os mesmos
conceitos das estruturas simples.
Exemplo:*/
#ifdef ex4
struct relogio{
int hora;
int minutos;
int segundo;
};
struct data {
int dia;
int mes;
int ano;
int dia_ano;
struct relogio tempo; /* declaracao de uma variavel tipo estrutura de nome
"tempo" dentro de outra variavel tipo estrutura */
};
struct data calendario = {

7,9,1822,250,
{20,50,10}
};
/* inicializando "tempo" dentro da variavel calendario */
/*
struct data calendario = {7,9,1822,250,20,50,10};
outra forma para inicializar a variavel tipo estrutura de nome "tempo"
dentro da variavel calendario */
main()
{
clrscr();
printf("\nA data e': ");
printf("%d ",calendario.dia_ano);
printf("e a hora e': ");

printf("%d:%d:%d",calendario.tempo.hora,calendario.tempo.minutos,
calendario.tempo.segundo);
}
#endif
/*
6. Vetores como variavel dentro de uma estruturas
Uma estrutura e' composta de variaveis simples e variaveis compostas.

Neste caso podemos declarar um vetor dentro de uma estrutura. O formato e'
o mesmo da declaracao de vetor.
Exemplo:
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[9]; declara um matriz tipo caracter de nome "nome_mes"
com 9 elementos dentro de uma estrutura
};
Exemplo:*/
#ifdef ex5
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[9];
20
};
struct data calendario = {15,11,1889,319,"novembro"};
main()
{
clrscr();
printf("%d - ",calendario.dia_ano);
printf("%s\n",calendario.nome_mes); /* imprime nome_mes com string*/
printf("\nimprimindo o nome do mes letra a letra: %c%c%c%c%c%c%c%c",

calendario.nome_mes[0],
calendario.nome_mes[7]);
}
#endif
/*
7. Vetor de estruturas
Para declarar um vetor de estruturas, deve-se primeiro definir uma estrutura e,

entao, declarar uma variavel vetor daquele tipo.
Exemplo:
definicao da estrutura:
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[10];
};
declaracao do vetor
struct data calendario[3];
Aqui tambem para referenciarmos elementos de um vetor de estrutura usamos

o mesmo operador ponto(.) no seguinte formato:
nome_variavel [n. do elemento].elemento
Exemplo:
calendario[0].dia -> busca o elemento de indice 0 do vertor de
estrutura e o membro dia deste elemento
Para se inicializar um vetor de estruturas tambem vale os conceitos de

estruturas simples.
Exemplo: */
#ifdef ex6
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[10];
};
struct data calendario[3] = {7,9,1822,250,"setembro",

15,11,1889,319,"novembro",
26,1,1839,26,"janeiro"};
/* define tres conjuntos de variaveis do tipo estrutura de nome "calendario".

O vetor de estrutura pode ser declarado dentro ou fora de uma funcao
quando sem inicializacao. No caso e' inicializado como variavel externa */
main()
{
clrscr();
21
printf("%d/",calendario[0].dia);
printf("%d/",calendario[0].mes);
printf("%d, ",calendario[0].ano);
printf("%d - ",calendario[0].dia_ano);
printf("%s\n",calendario[0].nome_mes);

printf("\nFundacao de Santos: ");

}
#endif
/*
8. Typedef
A Linguagem C permite definir explicitamente novos nomes de tipos de dados
usando-se a palavra reservada typedef. Nao se cria um novo tipo de dado, mas,
ao contrario, define-se um novo nome para um tipo existente. Ele tambem
auxilia na documentacao do seu codigo por permitir nomes descritivos para
tipos de dados padroes.
O formato para e':
typedef tipo_antigo novo_nome_tipo;
Exemplo:
typedef int inteiro;
typedef float flutuante;
para o nosso exemplo:

typedef struct data data; declara que a estrutura de nome data
sera' chamada nao mais de struct data
e sim de data apenas.
Exemplo: */
#ifdef ex7
struct data{
int dia;
int mes;
int ano;
int dia_ano;
};
typedef struct data data;
data calendario = {7,9,1822,250};
main()
{
clrscr();
printf("%d ",calendario.ano);
}
/**********************************************************************
EXERCICIOS
**********************************************************************
1 - Escreva um programa que tem uma estrutura da dados com os membros
abaixo e inicialize-a com algum conteudo. Imprima estes conteudos no
video.
char int float double long int
unsigned char unsigned int unsigned long
2 - Com a estrutura de dados do exercicio anterior entre pelo teclado o

conteudo de cada um dos membros e imprima-os no video no seguinte
fomato.
10 20 30 40 50 60 70
1234567890123456789012345678901234567890123456789012345678901234567890
char int long int float double
unsigned char unsigned int unsigned long
22
3 - Escreva um programa que tem uma estrutura da dados com os membros

abaixo e inicialize-a com algum conteudo. Imprima estes conteudos no
video.
nome end cidade estado cep
4 - Crie outra estrutura de dados com os membros abaixo. Acrescente esta

nova estrutura a estrutura de dados do exercicio anterior como mais um
membro e inicialize-a com algum conteudo. Declare a variavel como local
e imprima estes conteudos no video. (estrutura dentro de estrutura)
tel cpf rg
5 - Com a estrutura de dados do exercicio anterior entre pelo teclado o

conteudo de cada um dos membros e imprima-os no video.
6 - Ainda com a estrutura do exercicio 3 de estruturas, defina um vetor de

estruturas de 3 elementos, receba os dados pelo teclado e imprima-os
no video. (vetor de estruturas)
Capitulo 6
/**********************************************************************
COMANDOS
**********************************************************************
Toda linguaguem de programacao para computador precisa oferecer um minimo de
tres formas basicas de controle:
1 - executar uma serie de instrucoes

2 - tomada decisoes para desviar a execucao do programa. (controle de fluxo)
3 - repetir uma sequencia de instrucoes ate que uma condicao seja satisfeita.
(controle de repeticao)
Os comandos de controle de fluxo sao aqueles que permitem ao programador alterar

a sequencia de execucao do programa. O comando são: if e switch.
1- if
O comando "if" representa uma tomada de decisao do tipo "SE isto ENTAO aquilo".
Avalia-se uma expressao para tomada de decisao e se a expressao e'

verdadeira(== 1) executa o comando, se falsa(== 0) nao executa o comando.
O corpo do "if" pode ter uma unica declaracao ou varias declaracoes entre chaves.
O formato geral para uma declaracao e':
- if (expressao)
declaracao;
O formato geral para mais de uma declaracao e':
- if (expressao)
{
declaracao;
declaracao;
}
Exemplo: */
#ifdef ex1
main()
{
char ch;
clrscr();

ch=getchar();
getchar();
if(ch == 'r')
printf("\nVoce digitou a tecla r");
printf("\nVoce nao digitou a tecla r");
getchar();
}
#endif
#ifdef ex2
main()
23
{
char ch;
clrscr();

ch=getchar();
getchar();
if(ch == 'r')
{
printf("\nparabens voce acertou");
}
getchar();
}
#endif
/*
2 - if - else
o comando "if-else" e' uma expansao do comando "if". No comando "if" so' se excuta
a declaracao ou declaracoes se a expressao for verdadeira(== 1). O comando "else"
permite executar outra declaracao ou declaracoes se a expressao for falsa(== 0).
Resumindo, se a expressao for verdadeira(== 1) executa-se as declaracoes antes do
"else", se a expressao for falsa(== 0) executa-se as declaracoes depois do "else".
- if (expressao)
declaracao1;
else
declaracao2;
- if (expressao)
{
declaracao1;
declaracao1;
}
else
{
declaracao2;
declaracao2;
}
Exemplo: */
#ifdef ex3
main()
{
char ch;
clrscr();

ch=getchar();
getchar();
if(ch == 'r')
else
getchar();
}
#endif
#ifdef ex4
main()
{
char ch;
clrscr();

ch=getchar();
24
getchar();
if(ch == 'r')
{
printf("\nparabens voce acertou");
}
else
{
printf("\nque azar voce errou");
}
getchar();
}
/*
3 - if-else aninhados ou encadeados
Uma construcao comum em programacao e' o encadeamento ou aninhamento

de "if-else-if". As expressoes condicionais serao avaliadas de cima para
baixo. Assim que uma condicao verdadeira e' encontrada, o bloco associado a
ela sera' executado,e o resto do encadeamento e'ignorado. Se nenhuma das
condicoes for verdadeira, entao o "else final" sera executado.
- if (expressao 1)
declaracao1;
else
if (expressao 2)
declaracao2;
else
declaracao3;
- if (expressao 1)
{
declaracao1;
declaracao1;
}
else
if(expressao 2)
{
declaracao2;
declaracao2;
}
else
{
declaracao3;
declaracao3;
}
Exemplo:*/
#ifdef ex5
main()
{
int opcao;
int valor;
clrscr();
printf ("Converter: \n");
printf ("1: decimal para hexadecimal\n");
printf ("2: hexadecimal para decimal\n");
printf ("\nInforme sua opcao: ");
scanf ("%d", &opcao);
if (opcao == 1)
{
printf ("\nInforme o valor em decimal: ");
scanf ("%d", &valor);
printf ("%d em hexadecimal e: %x", valor, valor);
}
else if (opcao == 2)
{
printf ("\nInforme o valor em hexadecimal: ");
scanf ("%x", &valor);
printf ("%x em decimal e: %d", valor, valor);
25
}
else
{
printf ("\nA opção escolhida e' invalida.");
}
getchar();
getchar();
}
#endif
/*
4 - switch
Pode muitas vezes substituir o comando "if" por um comando "switch". Mas sem
duvida alguma, o mais importante dos dois comando e' o "if", mas o comando
switch tem aplicacoes valiosas. Vale lembrar que devemos procurar usar o comando
certo no local certo. Isto assegura um codigo limpo e de facil entendimento.
No comando "switch", a variavel e' sucessivamente testada contra uma lista de

inteiros ou caractere constantes. Quando uma associacao e' encontrada, o conjunto
de declaracoes associado com a constante e' executado.
As constantes nao precisam sequer estar em qualquer ordem especial.
Sua forma geral e':
switch (variavel)
{
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;
}
A declaracao "default" e' opcional e sera executada apenas se a variavel, que

esta sendo testada, nao for igual a nenhuma das constantes.
Há três coisas importantes a saber sobre a declaração switch:
1) O comando “switch” difere do comando "if” porque “switch” so' pode testar
igualdade, enquanto “if” pode avaliar uma expressao logica ou relacional;
2) Duas constantes “case” no mesmo “switch” não podem ter valores iguais.
Porem, um comando “switch” incluído em outro “switch” mais externo pode
ter as mesmas constantes “case”.
3) Se caracteres constantes são usadas em um comando “swicth”, elas são

automaticamente convertidas para seus valores inteiros.
Na estrutura do comando "switch" usa-se o comando "break". Vejamos como funciona.
5 - break
O comando “break” que voce viu logo apos a linha de comando do “case”,e' chamado
de comando de desvio, onde ele realiza um desvio incondicional.O “case” sera'
executado ate' que o comando “break” ou o fim do “switch” seja alcançado.
Quando o comando “break” e' alcancado o programa salta para a declaracao seguinte
ao final do “switch” (o fecha chave }). Caso nao tivessemos inserido o “break” o
programa continuaria testando os demais “cases” e poderia causar um erro no
programa.
O comando "break" tem uma segunda aplicacao. Ele tambem e' utilizado com os comandos
de controle de repeticao que veremos mais adiante.
Exemplo:*/
#ifdef ex6
main()
{
int opcao;
int valor;
26
clrscr();
printf ("Converter: \n");
printf ("1: decimal para hexadecimal\n");
printf ("2: hexadecimal para decimal\n");
printf ("\nInforme sua opcao: ");
scanf ("%d", &opcao);
switch(opcao)
{
case 1 :
{
printf ("\nInforme o valor em decimal: ");
scanf ("%d", &valor);
printf ("%d em hexadecimal e': %x", valor, valor);
break;
}
case 2 :
{
printf ("\nInforme o valor em hexadecimal: ");
scanf ("%x", &valor);
printf ("%x em decimal e': %d", valor, valor);
break;
}
default:
{
printf ("\nA opcao escolhida e' invalida.");
}
}
getchar();
getchar();
}
#endif
#ifdef ex7
main()
{
char x;
clrscr();
printf("digite uma letra --> ");
x = getchar();
getchar();
switch(x)
{
case 'f' : printf("voce digitou a letra f\n\n");
case 'a' : printf("voce digitou a letra a\n\n");
case 't' : printf("voce digitou a letra t\n\n");
case 'e' : printf("voce digitou a letra e\n\n");
case 'c' : printf("voce digitou a letra c\n\n");
default : printf("esta letra nao existe\n\n");
}
getchar();
}
#endif
/*
6 - goto
O "goto" e' o ultimo comando de controle de fluxo. Ele pertence a uma classe
a parte: a dos comandos de salto incondicional. O 'goto" realiza um salto
para um local especificado. Este local é determinado por um label ou rotulo.
O comando "goto" deve ser utilizado com parcimonia, pois o abuso no seu uso
tende a tornar o codigo confuso. O "goto" nao e' um comando necessario, podendo
sempre ser substituído por outras estruturas de controle. Porém, em algumas
situacoes muito especificas o comando "goto" pode tornar um programa mais facil
de se entender se ele for bem empregado.
Sua forma geral e':
label:
goto label;
Exemplo: */
#ifdef ex8
main()
{
int conta = 1;
27
clrscr();
printf("imprime os numeros de 1 a 100\n\n");
rotulo:
printf("%d ", conta++);
if (conta <= 100)
goto rotulo;
getchar();
}
#endif
/**********************************************************************
Os comandos de controle de repeticao permite que um conjunto de instrucoes seja
executados ate que uma condicao seja encontrada. Os comandos sao: for, while e
do - while.
7 - for
O comando "for" repete uma declaracao ou um grupo de declaracoes, controlado por

uma variavel, por um numero finito de vezes.A sua sintaxe e' declarada toda na
mesma linha, o que facilita sua compreensao.
Sua forma geral para uma declaracao e':
for (expressao 1 ; expressao 2 ; expressao 3)
declaracao;
for (expressao 1 ; expressao 2 ; expressao 3)

{
declaracao;
declaracao;
}
Na expressao 1 incializa-se a variavel que controla o loop.
Na expressao 2 testa-se a variavel de controle normalmente usando um teste

logico. Enquanto o teste da variavel de controle for verdade(==1) o loop
continua a ser executado. Quando o teste se torna falso(==0), o controle do
programa passa para a declaracao seguinte ao loop.
Na expressao 3 controla-se o incremento ou decremento da variavel de controle

do loop.
Exemplo:*/
#ifdef ex9
main()
{
int x;
clrscr();
for (x = 1; x <= 23; x++)
printf ("este e' o valor da variavel de controle x: %d \n", x);
getchar();
}
#endif
#ifdef ex10
main()
{
int i;
clrscr();
for (i = 0; i <= 20; i++)
{
printf ("Este e' o valor de i: %d ", i);
printf (" e i ao quadrado e': %d\n", i * i);
}
getchar();
}
#endif
#ifdef ex11
/*
Imprime todos os primos entre 2 e 100
usa um for dentro de outro for
*/
main()
{
int i,n;
28
clrscr();
printf("imprime os n. primos de 2 a 100\n\n");
for(n = 2;n <= 100;++n)

{
for(i = 2;i < n;++i)
if(n % i == 0)
break;
if(i == n)
printf("%d\t",n);
}
getchar();
}
#endif
/*
8 - Laco infinito ou loop infinito
Um comando "for" sem a expressao 2 ou seja, sem teste logico, e' sempre verdade.
Isso caracteriza um loop infinito. Normalmente o loop infinito nao tem as 3
expressoes de controle.
Sua forma geral sem a expressao 2 e':
for (expressao 1 ;; expressao 3)
declaracao;
Sua forma geral sem as 3 expressao e':
for (;;)
declaracao;
Exemplo:*/
#ifdef ex12
main()
{
clrscr();
for ( ; ; )
printf ("Este laco sera' executado para sempre.\n");
}
#endif
/*
9 - break
Lembrando que ja' vimos o comanado "break" quando estudamos o comando "switch".
Aqui temos outra aplicacao do comando "break". Ele forca a saida incondicional
de um laco. Este laco pode ser infinito ou nao.
Exemplo:*/
#ifdef ex13
main()
{
char ch;
int cont = 0;
clrscr();
printf("digite uma letra ate' sair do loop\n");
for ( ; ; )
{
ch = getchar(); //lê um caractere
getchar();
if (ch == 'a' )
break; //sai do laço
cont = cont + 1;
}
printf ("\nVoce acertou que e'a letra 'a' depois de %d tentativas\n",cont);
getchar();
}
#endif
/*
10 - while
Em muitos casos, os programas precisam repetir uma ou mais declaracoes ate' que
o laco atenda a uma condicao especifica que nao envolva necessariamente uma
contagem.
Um dos comandos utilizados para este fim e' o comando "while".

Usa-se este comando quando queremos que uma tarefa seja executada enquanto
29
a condicao logica for verdadeira(==1). Quando falsa (==0) pula para a
declaracao seguinte ao laco.
O teste da condicao logica e' executado antes de entrar no laco. Portanto se
a condicao for falsa(==0) no primeiro teste a declaracao ou declaracoes que estao
dentro do laco nao serao executadas nenhuma vez.
while (condicao)
declaracao;
while (condicao)
{
declaracao;
declaracao;
}
Assim como no "for", o comando 'while" sem a condicao logica gera um loop
infinito, pois esta sera' sempre verdade.
while ()
declaracao;
Exemplo:*/
#ifdef ex14
main()
{
char ch;
clrscr();
printf("digite uma letra ate' sair do loop\n");
while (ch != 'a' )
ch = getchar(); //lê um caractere
printf ("\nVoce acertou que e'a letra 'a' \n");

getchar();
getchar();
}
#endif
#ifdef ex15
/* calcula o quadrado de um numero */
main()
{
double y,x;
double fat;
clrscr();
printf("digite um numero: ");
scanf("%lf",&x);
getchar();
fat = 1;
y = 1;
while (y < x)
{
y = y + 1;
fat = fat * y;
}
printf("O valor da fatorial e' = %g\n",fat);
getchar();
}
#endif
/*
11 - do - while
Este comando e' semelhante ao anterior. A diferenca esta' na avaliacao da

condicao logica que acontece apos a execucao da declaracao ou declaracoes pelo
menos uma vez, pois a condicao esta' no final do loop(apos o while). Em outras
palavras, a declaracao ou declaracoes sao executadas e depois avalia-se a
condicao logica. Se a condicao for verdadeira(==1) a declaracao e' executado
novamente. Se for falsa(==0) vai para a declaracao seguinte ao loop. Para este
30
comando e' necessario sempre se utiliza o {} entre o "do" e o "while".
Para este comando nao existe loop inifinito.
do
{
declaracao;
}while (condicao);
do
{
declaracao;
declaracao;
}while (condicao);
Exemplo:*/
#ifdef ex16
main()
{
int num;
clrscr();
printf("digite um numero para sair do loop \n");

do
{
scanf ("%d", &num);
}while(num < 20);
printf("\nparabens, voce saiu do loop");
getchar();
getchar();
}
#endif
#ifdef ex17
main()
{
double y,x;
double fat;
char tecla;
clrscr();
do
{
printf("\ndigite um numero: ");
scanf("%lf",&x);
getchar();
fat = 1;
y = 1;
while (y < x)
{
y = y + 1;
fat = fat * y;
}
printf("O valor da fatorial e' = %g\n",fat);
printf("\ndeseja continuar?(s/n) ");

tecla = getchar();
getchar();
}while ((tecla != 'n') && (tecla != 'N'));
}
#endif
/*
12 - continue
O comando "continue" age de certa forma, ao contrario do comando "break". Ele

so'funciona dentro de um loop. Quando o comando "continue" e' encontrado, o
loop pula para a proxima iteracao, sem abandonar o loop, ao contrario do que
acontece no comando "break" que sai do loop.
Resumindo o comando continue funciona assim:

31
- no "while" e no "do-while" significa va' testar a condicao logica
- no "for" significa va' para a expressao 3 (incrementa ou decrementa

a variavel de controle)
- "switch" nao pode ser usado
Exemplos:*/
#ifdef ex18
main()
{
int x,y;
y=0;
clrscr();
do
{
printf("\nTentativa %d \n- digite um numero: ",y+1);
scanf("%d",&x);
y = y + 1;
if (x % 2)
continue;
printf("\t\to numero %d e' par\n",x);
}while(y < 5);
printf("\n\nfim");
getchar();
getchar();
}
#endif
#ifdef ex19
main()
{
int x,y;
clrscr();
for(y = 1;y < 6;y++)
{
printf("\ntentativa %d \n- digite um numero: ",y);
scanf("%d",&x);
if (!(x % 2))
continue;
printf("\t\to numero %d e' impar\n",x);
}
printf("\n\nfim");
getchar();
getchar();
}
/**********************************************************************
EXERCICIOS
**********************************************************************
1 - Reescreva o programa do exercicio 1 de vetores utilizando os 3 comandos
de loop while, do-while e for para os 3 vetores. são 9 loops.
2 - Reescreva o programa do execicio 6 de estruturas utilizando um dos comandos

de loop. Teremos 2 loop, uma a entrada e outro para a saida de dados.
3 - Escreva um programa que receba via teclado numeros inteiros positivos.

Quando o numero digitado for negativo o programa deve parar e calcula a media
dos valores digitados.
4 - Escreva um programa para adivinhar um numero entre 1 e 99 que o usuario pensou.

Digite via teclado os simbolos =,> ou < a cada pergunta. Utilize o comando
if-else.
5 - Resecreva o programa do execicio anterior agora utilizando o comando switch.

Conte o n. de tentativas e imprima o resultado.
6 - Escreva um programa que conte o numero de caracteres e numeros de uma frase

digitada pelo usuario via teclado. (a tecla "enter" e' o carater 13). Imprima
no video a contagem de ambos.
7 - Considerando o alfabeto, escreva um programa para receber via teclado uma letra
e mostrar, com as mensagens "vogal minuscula", "vogal maiuscula","consoante
minuscula", "consoante maiuscula", em qual categoria ela se encaixa. Utilize o
comando switch.
32
Capitulo 7
/**********************************************************************
PONTEIROS OU APONTADORES
**********************************************************************
1. Como funciona os ponteiros?
Os ints guardam numeros inteiros. Os floats guardam numeros de ponto flutuante.

Os chars guardam caracteres. Ponteiros guardam enderecos de memoria.
Quando voce anota o endereco de um colega voce esta' criando um ponteiro. O

ponteiro e' este seu pedaco de papel. Ele tem anotado um endereço. Qual e' o
sentido disto? Simples. Quando voce anota o endereco de um colega, depois voce
vai usar este endereco para acha'-lo. O C funciona assim. Voce anota o endereco
de algo numa variavel ponteiro para depois usar.
Um ponteiro tambem tem tipo. Veja: quando voce anota o endereco de um amigo voce
o trata diferente de quando voce anota o endereco de uma empresa. Apesar do
endereco dos dois locais ter o mesmo formato (rua, umero, bairro, cidade, etc.)
eles indicam locais cujos conteudos são diferentes. Entao os dois enderecos sao
ponteiros de tipos diferentes.
p f
-------------------------------->
| |
-------------------------------------------------------------------
....| xxx | xxx | 308 | ...... | xxx | xxx | í´ | xxx | ....
-------------------------------------------------------------------
$100 $101 $102 $306 $307 $308 $309
Na figura acima, p e' um ponteiro para a variavel f. Ou seja, p contem o

endereco de memoria onde esta' armazenada a variável f.
2. Definicao
Ponteiro e' uma variavel que, diferentemente das outras, nao contem o valor
de um dado, mas aponta para o endereco de outra variavel que o contem.
3. Declaracao de ponteiros
No C quando declaramos ponteiros nos informamos ao compilador para que tipo

de variável vamos aponta'-lo. Um ponteiro int aponta para uma variavel do tipo
inteira, isto é, guarda o endereço de um inteiro.
O formato geral para a declaracao de um ponteiro para variaveis simples e':
tipo *nome_variavel;
onde "tipo" indica o tipo da variavel (int, char, estrutura, etc..)

e "nome_variavel" e' o nome da variavel ponteiro.
exemplos:
char *pc; declara um ponteiro do tipo char de nome pc
int *pi; declara um ponteiro do tipo int de nome pi
float *pfl; declara um ponteiro do tipo float de nome fl
unsigned *pu; declara um ponteiro do tipo unsigned de nome pd
4. Atribuindo o endereco de uma variavel a um ponteiros
Para atribuir-se diretamente os enderecos das variaveis apontadas, deve-se

utilizar o operador & (E comercial) antes do nome da variavel a ser apontada;
isto indicara' que queremos acessar o endereco da mesma e nao seu conteudo.
O formato geral e':
ponteiro = &nome_variavel;
Olhando a figura inicial temos:
p = &f; atribui ao ponteiro "p" o end. da variavel "f".

Em outras palavras atribui a "p" o endereco $308.
Exemplos:
declaracao de variaveis
char a = ´p´;
int b =700;
float c = 9.777;
unsigned d = 4000000007;
Atribuindo os enderecos aos ponteiros;

pc = &a; atribui ao ponteiro "pc" o end. da variavel "a".
pi = &b; atribui ao ponteiro "pi" o end. da variavel "b".
pf = &c; atribui ao ponteiro "pf" o end. da variavel "c".
pu = &d; atribui ao ponteiro "pu" o end. da variavel "d".
33
5. Buscando o dado guardado
Para se obter o valor armazenado numa variavel atraves do seu ponteiro,

utilizamos o operador * (asterisco), obtendo como resultado o conteudo
da mesma.
O formato geral e':
variavel = *ponteiro
Olhando a figura inicial temos:
k = *p; atribui a "k" o conteudo da variavel apontada por "p"

Em outras palavras atribui a "y" o conteudo de "f"
que e' a letra "i".
Exemplos:
Buscando os conteudos das variaveis atraves dos seus ponteiros.

w = *pc; atribui a "w" o conteudo da variavel "a" que e'"p"
x = *pi; atribui a "x" o conteudo da variavel "b" que e'"700"
y = *pf; atribui a "y" o conteudo da variavel "c" que e'"9.777"
z = *pu; atribui a "z" o conteudo da variavel "d" que e'"4000000007"
Exemplo com variaveis simples:*/
#ifdef ex1
main()
{
char *pc,w,a = 'p';
int *pi,x,b =700;
float *pf,y,c = 9.777;
unsigned *pu,z,d = 65007;
pc = &a; /*atribui ao ponteiro "pc" o end. da variavel "a".*/

pi = &b; /*atribui ao ponteiro "pi" o end. da variavel "b".*/
pf = &c; /*atribui ao ponteiro "fl" o end. da variavel "c".*/
pu = &d; /*atribui ao ponteiro "pd" o end. da variavel "d".*/
w = *pc; /*atribui a "w" o conteudo da variavel "a" que e'"p"*/

x = *pi; /*atribui a "x" o conteudo da variavel "b" que e'"700"*/
y = *pf; /*atribui a "y" o conteudo da variavel "c" que e'"9.777"*/
z = *pu; /*atribui a "z" o conteudo da variavel "d" que e'"4000000007"*/
clrscr();
printf("exibe o conteudo da variavel a '%c' \n",a);

printf("exibe o conteudo da variavel a '%d' \n",b);
printf("exibe o conteudo da variavel a '%f' \n",c);
printf("exibe o conteudo da variavel a '%u' \n\n",d);
printf("exibe o conteudo da variavel direto atraves do ponteiro '%c'\n",*pc);

printf("exibe o conteudo da variavel direto atraves do ponteiro '%d'\n",*pi);
printf("exibe o conteudo da variavel direto atraves do ponteiro '%f'\n",*pf);
printf("exibe o conteudo da variavel direto atraves do ponteiro '%u'\n\n",*pu);
printf("exibe o conteudo da variavel que recebeu o dado via ponteiro '%c'\n",w);

printf("exibe o conteudo da variavel que recebeu o dado via ponteiro '%d'\n",x);
printf("exibe o conteudo da variavel que recebeu o dado via ponteiro '%f'\n",y);
printf("exibe o conteudo da variavel que recebeu o dado via ponteiro '%u'\n",z);
getchar();
}
#endif
#ifdef ex2
main ()
{
int num;
int *p;
num = 55;
p = &num; /* atribui o endereco da variavel num ao ponteiro p*/
clrscr();
printf ("\nValor inicial: %d\n",num);
*p=100; /* atribui o valor 100 a variavel num atraves do ponteiro */
printf ("\nValor final: %d\n",num);

34
getchar();
}
#endif
#ifdef ex3
main()
{
int rx;
int *p;
rx = 200;
p = &rx; /* atribui o endereco da variavel num ao ponteiro p*/
clrscr();
printf ("\nValor inicial: %d\n",rx);
printf("digite um valor inteiro: ");
scanf("%d",p); /*recebe via teclado um numero inteiro usando o ponteiro*/

getchar();
printf ("\nValor recebido via teclado e': %d\n",rx);
getchar();
}
#endif
/*
6. Ponteiros para estruturas
Podemos utilizar ponteiros para estruturas assim como usamos para variaveis
simples(int,char,...). Uma estrutura e' um tipo de dado como os outros, por isso tambem
podemos utilizar ponteiros para elas.
Para declarar um ponteiro para uma estrutura usamos o seguinte formato:
struct nome da estrutura *nome do ponteiro;
Exemplo:
struct data *p; declaramos um ponteiro "p" para a estrutura de
nome data
Para atribuir-se o endereco a um ponteiro no caso de estruturas utilizamos

o seguinte formato:
ponteiro = &nome_variavel;
Exemplo:
p = &calendario;
Fazendo uma analogia com as variaveis simples, observamos que as 2 declaracoes acima sao
identicas. Vamos a um exemplo comparando as declaracoes.
variaveis simples
int *p, x, y;
p = &x;
estruturas
struct data *pc, calendario;
pc = &calendario;
A diferenca vem quando queremos buscar os dados da variavel. No caso das variaveis simples
buscamos assim:
y = *p;
Para os ponteiros utilizamos o mesmo operador ponto(.) assim:
y = (*p).dia;
O formato geral e':
(*ponteiro).elemento;
Lembrando mais uma vez a prioridade dos operadores.
Exemplo:*/
#ifdef ex4
struct data {
int dia;
35
int mes;
int ano;
int dia_ano;
char nome_mes[9];
};
struct data calendario = {7,9,1822,250,"setembro"};
main()
{
struct data *p;
clrscr();
p=&calendario; /*atribui o endereco da variavel calendario ao ponteiro p*/

printf("%d/",(*p).dia);
printf("%d/",(*p).mes);
printf("%d - ",(*p).ano);
printf("%d - ",(*p).dia_ano);
printf("%s\n",(*p).nome_mes);
getchar();
}
#endif
/*
Mas raramente encontramos referencias feitas a um campo de uma estrutura com
uso explicito do operador *. O acesso a um campo de uma estrutura por meio de
um ponteiro para a dada estrutura e' tão comum, que um operador especial foi definido pela
Linguagem C realiza esta tarefa. Ele é o ->, chamada de operador seta. Ele e' formado
utilizando-se o sinal de menos(-) seguido por um sinal de maior que(>). O operador seta e'
usada no lugar do operador ponto, quando se acessa um campo da estrutura utilizando-se um
ponteiro para a variavel estrutura.
No nosso exemplo:
y = p -> dia;
O formato geral e':
ponteiro -> elemento;
Exemplo:*/
#ifdef ex5
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[9];
};
main()
{
struct data *p;
static struct data calendario = {15,11,1889,319,"novembro"};
clrscr();
p=&calendario;

printf("%d/",p->dia);
printf("%d/",p->mes);
printf("%d - ",p->ano);
printf("%d - ",p->dia_ano);
printf("%s\n",p->nome_mes);
getchar();
}
#endif
/*
7. Aritmetica de ponteiros
Com ponteiros podemos executar um n. limitado de operacao sao elas:
- Igualar 2 ponteiros
36
Se temos dois ponteiros p1 e p2 podemos iguala'-los fazendo p1=p2. Repare que
estamos fazendo com que p1 aponte para o mesmo lugar que p2.
Se quisermos que a variavel apontada por p1 tenha o mesmo conteudo da variavel

apontada por p2 devemos fazer *p1=*p2.
- Incrementar ou decrementar um ponteiro
Quando incrementamos um ponteiro ele passa a apontar para o proximo valor do

mesmo tipo para o qual o ponteiro aponta. Isto e', se temos um ponteiro para um numero
inteiro e o incrementamos ele passa a apontar para o próximo numero inteiro. Esta e' a
razao pela qual o compilador precisa saber o tipo do ponteiro.
Se voce incrementa um ponteiro do tipo char* ele anda 1 byte na memoria (lembrete:
char ocupa 1 byte na memoria) e se voce incrementa um ponteiro
do tipo double* ele anda 8 bytes na memoria(lembrete: double ocupa 8 bytes na memoria). O
decremento funciona semelhantemente. Supondo que p é um ponteiro, as operações são escritas
como:
p = p + 1; ou p++; ou ++p; soma 1 ao ponteiro
p = p - 1; ou p--; ou --p; subtari 1 do ponteiro
Lembrando que estamos falando de operacoes com ponteiros e nao de operacoes com o
conteúdo das variaveis para as quais eles apontam.
Se quisermos incrementar ou decrementar o conteudo da variavel apontada pelo ponteiro p,

escrevemos assim:
(*p) + 1; ou (*p)++; ou ++(*p); soma 1 ao conteudo aponta por p
(*p) - 1; ou (*p)--; ou --(*p); subtari 1 do conteudo aponta por p
Obs.: porque usamos o operador parenteses? por que tanto o operador soma quando o operador
incrementa tem prioridade maior que o operador conteudo (*).
Exemplo:
*/
#ifdef ex6
main()
{
static int z[5]={5,10,15,20,25};
int *p;
int b;
clrscr();
for(b=0;b <5 ;b++)

{
p=&z[b];
printf("soma 1 ao elemento %d do vetor z = %d\n",b+1,(*p)+1);
printf("soma 1 ao elemento %d do vetor z = %d\n",b+1,++(*p));
printf("subtrai 1 ao elemento %d do vetor z = %d\n",b+1,(*p)-1);
printf("subtrai 1 ao elemento %d do vetor z = %d\n",b+1,--(*p));
}
getchar();
}
#endif
/*
- Somar ou subtrar valores inteiros dos ponteiros
Quando incrementamos ou decrementamos ponteiros, como viamos acima, acessamos a proxima ou

anterior posicao de memoria que o ponteiro esta' aopontado levando em consideracao o seu
tipo. Lembrando mais uma vez, o tipo do ponteiro tem que ser o mesmo do dado que ela
apontada.
Assim, quando se soma ou subtrai uma valor inteiro a um ponteiro, equivale a

multiplicarmos o valor inteiro pelo tamanho do tipo de ponteiro e somarmos ao ponteiro.
Exemplo:
int *px,*py; ponteiros do tipo inteiro
py = px+5 atribui ao ponteiro py o endereco de px + (5*2)

Exemplo:
*/
#ifdef ex7
main()
{
static int z[5]={5,10,15,20,25};
int *p,*p1;
37
int b;
clrscr();
p=&z[0];
for(b=0;b <5 ;b++)

{
p1 = p + b;
printf("exibe o elemento %d do vetor z = %d\n",b+1,*p1);
}
getchar();
}
#endif
/*
-Podemos ainda atribuir um end. de memoria determinado direto a um ponteiro.
Isto porem e' perigoso quando nao se conhece o hardware e firmware da maquina
que se esta utilizando.
exemplo:
px=0xf853; o ponteiro "px" aponta para o end. f853(hexa) da memoria
/*
8. Ponteiros e vetores
O relacionamento entre ponteiros e vetores e' tao estreito que deveriam ser
tratados juntos.
E'importante lembra que um vetor e' um conjunto de posicoes contiguas de memoria ocupando
varios bytes, ao passo que um ponteiro e' constituido normalmente de 2 ou 4 bytes que servem
para armazenar o end. da variavel apontada.
Para atribuir-se o endereco a um ponteiro no caso de vetores, utilizamos o seguinte formato:
ponteiro = &nome_variavel [n._elemento]
exemplo:
int z[20]; declara um vetor "z" com 20 posicoes
int *p; declara um ponteiro para uma variavel tipo inteira
p = &z[0]; o ponteiro "p" apontara' para a 1. posicao

do vetor "z", ou o elemento de indice[0] do vetor "z"
A declaracao p = &z[0] aponta para o elemento de indice[0] do vetor "z". Ora

o elemento de indice[0] do vetor tem o mesmo endereco do vetor "z", que por
sua vez tambem e' um endereco. Portanto podemos declarar que p = z.
Podemos afirmar entao que estas declaracoes sao equivalentes:

p = &z[0]; equivale a p = z;
Para se obter o conteudo de um dos elementos do vetor atraves de seu ponteiro

tambem utilizamos o operador *(asterisco).
Podemos acessar os elementos de um vetor usando a aritmetica de ponteiro somando um numero

inteiro ao ponteiro. Neste caso e' usual se atribuir o endereco do 1. elemento do vetor ou
elemento de indice 0 ao ponteiro que sera' utilizado como refencia para acessar aos demais
elementos.
O formato para acessar os elementos do vetor como vimos no capitulo de vetores e':
nome da variavel[indice];
O formato para acessar o mesmo elemento utilizando o ponteiro e aritmetica de ponteiros e':
*(ponteiro + indice);
E temos mais uma forma para acessar o mesmo elemento que equivale a:
ponteiro[indice];
Esta forma e' possivel por que se o ponteiro aponta para um elemento no vetor e o indice
soma o numero de elementos para o qual se quer aponta, lembrando que o ponteiro leva em
conta o tipo de variavel apontada, entao esta expressão e' equivale a expresao da
aritmetica de ponteiro.
Exemplo de ponteiros em vetores:*/
#ifdef ex8
main()
{
static int z[5]={1,2,3,4,5}; /* declara um vetor de 5 elementos*/
int *p; /* declara um ponteiro int */
int b;
38
clrscr();
p=&z[0]; /* p aponta para o elemento de indice[0] de z ou

p contem o end. de z[0] */
b=*p; /* o conteudo apontado por prtz e' atribuido a b */
printf("imprime o conteudo de b = %d\n",b);

getchar();
}
#endif
#ifdef ex9
main()
{
int b;
clrscr();
p = z; /* usando o conceito da igualdade de end. */
b = *p; /* se o conceito da igualdade de end. for verdade,

entao o resultado sera' o mesmo */
printf("imprime o conteudo de b = %d\n",b);

getchar();
}
#endif
#ifdef ex10
main()
{
int b;
clrscr();
for(b=0;b <5 ;b++)
{
p=&z[b]; /* atribui ao ponteiro "p" o end. de cada
um dos elementos do vetor "z" */
printf("exibe o conteudo do %d. elemento do vetor z = %d\n",b+1,*p);
}
getchar();
}
#endif
#ifdef ex11
main()
{
int b;
clrscr();
p=&z[0]; /* atribui ao ponteiro "p" o end. do 1. elemento do vetor "z"*/
for(b=0;b <5 ;b++)

{
printf("exibe o conteudo do %d. elemento do vetor z = %d\n",b+1,*(p+b));
}
getchar();
}
#endif
#ifdef ex12
main()
{
static int z[5]={6000,7000,8000,9000,10000};
int *p;
int b;
clrscr();
for(b=0;b <5 ;b++)

{
printf("exibe o conteudo do %d. elemento do vetor z = %d\n",b+1,p[b]);
}
getchar();
}
39
#endif
#ifdef ex13
main()
{
static char z[16]="teste de string";
char *p;
int b;
clrscr();
for(b=0;b <15 ;b++)

{
printf("exibe o conteudo do %d. elemento do vetor z = %c\n",b+1,*(p+b));
}
printf("\noutra forma de exibir a string: %s \n",p);
getchar();
}
#endif
#ifdef ex14
main()
{
static char *p ="string com ponteiro";
int b;
clrscr();
for(b=0; p[b] != '\0' ;b++)

{
printf("exibe o conteudo do %d. elemento do vetor z = %c\n",b+1,*(p+b));
}
printf("\noutra forma de exibir a string: %s \n",p);
getchar();
}
#endif
/*
9. Vetor de ponteiros
Como ponteiros sao variaveis podemos montar vetores de ponteiros. Este

tipo de construcao normalmente e' usada para enderecar string. O ponteiro
aponta para o end. inicial da string.
O vetor de ponteiros e' util quando se trabalha com informacoes de tamanho

diferente.
O formato para declaracao de um vetor de ponteiros e':
tipo *nome_variavel[n._elementos];
onde "tipo" indica o tipo da variavel (int, char, estrutura, etc..)

e "nome_variavel" contem os ponteiros (enderecos) do vetor apontado, com o
tamanho definido por "n._elementos".
exemplos:
char *pc[5]; vetor de ponteiros para caracter
int *pont[10]; vetor de ponteiros para inteiro
float *fl[20]; vetor de ponteiros para pto. flut.
struct data *prt[30]; vetor de ponteiros para estruturas
Para atribuir o endereco de uma variavel a um vetor de ponteiros utilizamos

o seguinte formato:
ponteiro [n._elemento] = &nome_variavel
exemplo:
p[2]=&x; atribui ao 3. elementos do vetor de ponteiros
"p" o end. da variavel "x"
Lembrando que os elementos de um vetor de ponteiros somente pode conter end. de

variaveis.
Exemplo com vetor de ponteiros:*/
#ifdef ex15
char a[] = "erro de digitacao";

char b[] = "erro de conversao de valores";
char c[] = "erro de sintaxe";
char d[] = "erro de declaracao";
char e[] = "erro de colocacao de parenteses";
main()
40
{
int x;
char *z[5]; /* declara um vetor de ponteiros */
z[0] = &a[0];
z[1] = &b[0];
z[2] = c;
z[3] = d;
z[4] = e;
clrscr();
for(x=0;x <5 ;x++)
{
printf("imprime o conteudo do %d. elemento do vetor z = %s\n",x,z[x]);
}
getchar();
}
#endif
#ifdef ex16
main()
{
int x;
char *z[5];
/* inicializa o vetor de ponteiros */
z[0] = "erro de digitacao";

z[1] = "erro de conversao de valores";
z[2] = "erro de sintaxe";
z[3] = "erro de declaracao";
z[4] = "erro de colocacao de parenteses";
clrscr();
for(x=0;x <5 ;x++)

{
printf("imprime o conteudo do %d. elemento do vetor z = %s\n",x,z[x]);
}
getchar();
}
#endif
#ifdef ex17
main()
{
char *psemana [7] = { "Domingo" ,
"Segunda-feira",
"Terca-feira",
"Quarta-feira",
"Quinta-feira",
"Sexta-feira",
"Sabado",
};
clrscr();
printf(" Dias da semana \n\n");

printf(" %s\n",psemana [0]);
getchar();
}
/**********************************************************************
EXERCICIOS
**********************************************************************
1 - Imprima no video os mesmos conteudos do exercicio 1 de vetores porem
utilizando ponteiros.
2 - Com a estrutura definida no exercicio 3 de estruturas declare um

ponteiro para a mesma e imprima os conteudos no video.
3 - Do vetor de estrutura de 3 elementos definido no exercicio 6 de

estrturas, receba os dados via teclado e imprima no video utilizando ponteiros.
4 - Escreva um programa que receba via teclado os numeros short, long,

unsigned, float e double, declare ponteiros para os mesmos e imprima-os
no video utilizando o operador de conteudo * no seguinte formato:
10 20 30 40 50 60
41
123456789012345678901234567890123456789012345678901234567890
int long unsigned
float double
Capitulo 8
/**********************************************************************
FUNCOES
**********************************************************************
1 - Conceito de funcao
Funcoes dividem grandes tarefas de computacao em tarefas menores, e permitem as pessoas

trabalharem sobre o que outras ja' fizeram, em vez de partir do inicio novamente. Funcoes
bem definidas podem frequentemente esconder detalhes de operacao de partes de um programa.
Nos ja' usamos a funcao printf() sem conhecer os detalhes de sua programacao.
2 - Definicao
Funcao e' um conjunto de instrucoes e declaracoes desenhadas para cumprir uma determinada
tarefa e referenciada por um nome.
A principal razao para usar funcoes e' dividir uma tarefa em outras pequenas tarefas que
simplificam e organizam o programa como um todo.
Outra razao para escrever funcoes e' a de reduzir o tamanho do programa. Qualquer sequencia
de instrucoes ou declaracoes que apareca no programa mais de uma vez e' candidata a se
transformar em uma funcao.
Uma funcao e' escrita no programa uma unica vez mas pode ser executado muitas vezes durante
a execucao do programa.
A funcao, uma vez desenvolvida e testada, passa a ser completamente transparente ao usuario,
que so' necessita saber sua utilidade, as informacoes de entradas e infomacoes de saida,
podendo abster-se de todos os detalhes de sua implementacao. Um exemplo disso sao as funcoes
printf, scanf, gets, puts que temos utilizado sem saber como foram construidas.
3 - Chamando uma funcao
Chamar uma funcao e' desviar o fluxo do programa para que uma tarefa seja executada.
Terminada esta tarefa chamada, o fluxo do programa retorna para a declaracao seguinte a da
chamada da funcao.
Varias funcoes, como o printf(), sao desenvolvidas pelo fabricante do compilador e juntadas
ao programa pelo linkeditor. Sao as chamadas funcoes de biblioteca. Podemos tambem escrever
nossas proprias funcoes no programa.
A sintaxe para chamar uma funcao e'
nome_da_funcao(parametros);
Exemplo:
printf("teste");
soma(a,b);
4 - Formato de uma funcao em C
A estrutura de uma funcao em C e' semelhante a estrutura da funcao main(). A unica diferenca
e' que a funcao main() tem um nome especial.
tipo_de_retorno nome_da_funcao (parametros)

tipos dos parametros;
{
comandos;
funcoes;
}
tipo_de_retorno --------> E' o tipo do dado que a funcao retornara'.
nome_da_funcao ---------> E' o nome pelo qual a funcao sera' chamada.
parametros -------------> Sao as informacoes que a funcao recebe.
tipos dos parametros ---> Se houve parametros, entao o tipo das variaveis
destes deve ser declarado.
declaracao de variaveis-> Declaracao dos tipos das variaveis locais à funcao

e que sao utilizados apenas dentro nesta.
comandos ---------------> E' o corpo da funcao. Contem as instrucoes que

42
realizam o processamento.
funcoes ----------------> Sao chamadas de funcoes de biblioteca e da nossa

proprias funcoes.
Exemplo:*/
#ifdef ex1
main()
{
clrscr();

printf("Este exemplo mostra a chamada de uma funcao.\n\n");
imprimir_mensagem();

getchar();
}
/* funcao 1 imprimi mensagens na tela */
imprimir_mensagem()
{
printf("\t\t Voce esta' na funcao 1\n");
printf("\t\t esta funcao foi chamada pela funcao main()\n");
printf("\t\t fim da funcao 1\n\n");
}
#endif
/*
3 - Passagem de parametros
O que sao parametros ou argumentos de uma funcao?

Sao as informacoes que a funcao recebe para executar a tarefa para a qual foi desenvolvida.
Existem dois metodos de passagem de parametros para uma funcao.
- O 1. metodo e' a passagem de parametros ou informacoes por valor.
Neste metodo, quando uma funcao e' chamada, a função que chamou faz copias dos valores a
serem enviados para a funcao chamada. Dessa forma os valores originais nao podem ser
alterados, pois a funcao chamada manipula apenas as copias dos mesmos. Na funcao chamada sao
criadas variaveis do mesmo tipo da funcao que chamou que guardarao a copia destes valores.
Lembrando que as variaveis que recebem os parametors ou informcoes da funcao que chamou e as
que estao dentro da funcao chamada sao variaveis locais. Portanto, quando a execucao da
funcao se encerra as variaveis sao destruidas ou seja, o seu conteudo e' perdido.
Exemplo:*/
#ifdef ex2
main() /* passagem de parametros por valor */

{
int a,b;
a = 10;
b = 20;
clrscr();
printf("main() -> antes da troca ---> a = %d b = %d \n\n",a,b);
troca(a,b);
printf("main() -> depois da troca --> a = %d b = %d \n\n",a,b);
soma(a,b);
getchar();
}
/* funcao troca valores */
troca(x,y)
int x,y;
{
int c;
printf("\tfuncao troca()\n");
43
printf("\ttroca os valores da variaveis x e y que sao\n");
printf("\tcopias das variaveis a e b da funcao main().\n\n");
c = x;
x = y;
y = c;
printf("\to valor de x e' %d, o de y e' %d\n\n",x,y);

}
/* funcao soma valores */
soma(i,j)
int i,j;
{
int c;
c = i + j;
printf("\tfuncao soma()\n");
printf("\to valor de i e' %d, o de j e' %d e a soma de i + j e'%d\n",i,j,c);

}
#endif
/*
- O 2. metodo e' a passagem de parametros ou informacoes por referencia ou ponteiros.
Como vimos, quando passamos parametros ou informacoes por valor, a funcao chamada cria novas
variaveis do mesmo tipo dos parametros ou informacoes passados e copia nelas os valores
passados pela funcao que chamou.
Na passagem de parametros ou informacoes por refencencia a funcao que chama passa para a
funcao chamada o endereco das variaveis. A funcao chamada cria variaveis para receber esses
enderecos ou seja cria ponteiros que devem ser do mesmo tipo das variaveis que estao sendo
passada.
Diferentemente da passagem de parametros por valor onde nao podemos alterar os valores das
variaveis que sao passadas para a funcao chamada, aqui os conteudos
originais ou seja das variaveis da funcao que chama podem ser alterados.
Lembrando que atraves dos ponteiros podemos acessar o conteudos da variaveis de maneira
indireta.
A passagem de parametros ou informacoes por referencia e'normalmente utilizada para se

trabalhar com vetores e estruturas que nao podem utilizar a passagem por valor.
*/
#ifdef ex3
main() /* passagem de parametros por referencia */

{
int a,b;
a = 10;
b = 20;
clrscr();
printf("main() -> antes da troca ---> a = %d b = %d \n\n",a,b);
troca(&a,&b);
printf("main() -> depois da troca --> a = %d b = %d \n",a,b);
getchar();
}
/* funcao troca valores */
troca(p1,p2)
int *p1,*p2;
{
int c;
printf("\tfuncao troca()\n");
printf("\ttroca os conteudos da variaveis a e b da funcao main()\n");
printf("\tatraves dos enderecos da variaveis.\n\n");
c = *p1;
*p1 = *p2;
*p2 = c;
44
}
#endif
/* Exemplo passando um ponteiro para vetor */
#ifdef ex4
main()
{
int z[10],i;
clrscr();
printf("inicializa o vetor z com os valores de 10 a 19\n\n");
for(i=0;i < 10;++i)

{
z[i] = i+10;
}
display(z);
printf("\nde volta a funcao main()\n");

getchar();
}
display(pont)
int *pont;
{
int i;
printf("\tfuncao display\n");
printf("\timprime na tela os valores do vetor z via o ponteiro \n");
printf("\tpont que aponta para o 1. elemento do vetor\n");
for(i=0;i < 10;i++)

{
printf("\t %d\n",pont[i]);
}
}
#endif
/* exemplo passando um ponteiro para estrutura */
#ifdef ex5
struct data {
int dia;
int mes;
int ano;
int dia_ano;
char nome_mes[10];
};
struct data calendario = {7,9,1822,250,"setembro"};
main()
{
struct data *prt;
clrscr();
printf("inicializa o ponteiro prt e chama a funcao imp()\n\n");
prt=&calendario;
imp(prt);
printf("de volta a funcao main()\n");

getchar();
imp(pont)
struct data *pont;
{
printf("\tfuncao imp()\n");
printf("\timprimi os elementos da estrutura de dados calendario \n");
printf("\ta partir do ponteiro pont.\n\n");
printf("\tdata da procalmacao da independencia:\n");

printf("\t %d\n",pont->dia);
printf("\t %d\n",pont->mes);
45
printf("\t %d\n",pont->ano);
printf("\t %d\n",pont->dia_ano);
printf("\t %s\n\n",pont->nome_mes);
}
#endif
/*
4 - Retorno de funcao
Uma funcao chamada pode retornar um valor ou nenhum a funcao que a chamou.
Para retornar uma valor a funcao que chamou utilizamos o comando return.
O formato geral e':
return(valor); retorna o valor

return(); nao retorna valor
return; nao retorna valor
A utilizacao do comando return e' opcional quando nao ha' retorno de valor.
IMPORTANTE: O comando return so' retorna um unico valor.
Exemplo: */
#ifdef ex6
main()
{
int a,b,c;
a = 100;
b = 200;
clrscr();
printf("chama a funcao soma(). \n");

printf("A funcao soma() retorna o resultado que e' atribuido a variavel c\n\n");
c = soma(a,b);
printf("soma de a + b e': %d + %d = %d \n",a,b,c);

getchar();
}
soma(x,y)
int x,y;
{
int z;
printf("\tfuncao soma() \n");

printf("\ta funcao soma os valores x e y \n");
printf("\tretorna o resultado com o comando return\n\n");
z = x + y;
return(z);
}
#endif
/*
- Definindo o tipo do valor de retorno
Os valores devolvidos pelo comando return sao inteiros por default como no exemplo anterior.
Quando nao existe valor devolvido, se a funcao que chamou estiver esperando algum valor
recebera lixo e pode ocorrer erro de logica nao detectavel pelo compilador.
As funcoes podem devolver valores nao inteiros. Para isto devemos especificar
claramente o tipo de retorno na funcao chamada e declarar tambem este mesmo tipo
na funcao de chamada.
O formato geral na funcao chamada e':
tipo_de_retorno nome_da_função (lista_de_argumentos)
O formato geral na funcao que chama e':
tipo_de_retorno funcao();
Exemplo:*/
#ifdef ex7
main()
{
float a,b,c;
46
float soma();
a = 3957.779;
b = 43558.357;
clrscr();
printf("chama a funcao soma(). \n");

printf("A funcao soma() retorna o resultado que e' atribuido a variavel c\n\n");
c = soma(a,b);
printf("soma de a + b e': %.3f + %.3f = %.3f \n",a,b,c);

getchar();
}
float soma(x,y)
float x,y;
{
float z;
printf("\tfuncao soma() \n");

printf("\ta funcao soma os valores x e y \n");
printf("\tretorna o resultado com o comando return\n\n");
z = x + y;
return(z);
}

Idioma

Estrutura de Um Programa em C

Enviado por

Dados do documento

Título original

Direitos autorais

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Estrutura de Um Programa em C

Enviado por

Direitos autorais:

1

main() comando de inicio de programa em C. So' pode existe um no prog.

{ chave de abertura indicando inicio da funcao

} chave de fechamento encerrando a funcao

As declaracoes de pre'-processamento sao usadas para:

- definir constantes simbolicas para serem substituidas

As declaracoes de variaveis globais (ou externas) podem ou nao existir

A funcao main() representa o inicio do programa em C. Ela tem que existir

Uma funcao generica em C tem os seguintes elementos:

tipo nome da funcao (parametros)

tipo -------------------> E' o tipo do dado a ser retornado pela funcao.

parametros -------------> E' uma lista de variaveis que receberao os valores

declaracao de variaveis-> Declaracao dos tipos das variaveis que serao

comandos ---------------> E' o corpo da funcao. Contem as instrucoes que

funcoes ----------------> Sao chamadas a outras funcoes ou a si mesma.

Para se documentar um programa em C devemos escrever os comentarios entre

Falta apenas mais um detalhe importante neste momento. As letras maiusculas

#define ex1 /* estas duas declaracoes com o simbolo # na frente sao

/* a funcao printf e' definida na biblioteca padrao */

#endif /* esta tambem e' uma declaracao de pre'-processamento */

funcao1(); /* a chamada de uma funcao e' atraves do nome da

printf("Voce esta' de volta a funcao main()\n");

printf("Voce esta' de volta a funcao main()\n");

funcao2(); /* aqui a funcao 1 chama a funcao 2 */

printf("\t Voce esta' de volta a funcao 1\n\n");

A forma geral da função getchar() e´:

A forma geral da funcao putchar() e':

3 - gets () -> le uma serie de caracteres da entrada padrao ate' um ENTER.

A forma geral da funcao gets() e':

A forma geral da funcao puts() e´:

A forma geral da funcao printf() e´:

A <expressao de controle> contem tanto caracteres para serem impressos na

Os codigos de formatacao sao os seguintes:

%c - exibe um caracter simples

/*para o programa e espera uma tecla para ver o resultado na tela*/

O formato geral e':

% <justificacao> <tamanho de campo> . numero de casas decimais <codigo de formatacao>

%6d -> define a justificacao a direita e o tamanho de campo com 6 posicoes

%15.2f -> define a justificacao a direita, o tamanho de campo com 15 posicoes

%10s -> define a justificacao a direita e o tamanho de campo com 10 posicoes

printf("\n12345678901234567890 regua\n"); /* regua */

/*para o programa e espera uma tecla para ver o resultado na tela*/

6 - scanf() -> le caracteres formatados da entrada padrao. (no caso teclado)

A forma geral da funcao scanf() e´:

A <expressao de controle> so pode conter os codigos de formatacao que

Os codigos de formatacao sao os seguintes:

%c - leia um unico caracter simples

2 - Nao pode ser usado mensagens na serie de controle apenas os codigos

printf("\n\ndigite um numero real (123.123): ");

printf("\n\ndigite um numero inteiro positivo: ");

printf("\n\ndigite um numero no formato exponencial (1234e23): ");

printf("\n\ndigite um numero real no formato exponencial (1234e23) ou normal(123): ");

/*para o programa e espera uma tecla para ver o resultado na tela*/

1 - Escreva um programa utilizando a funcao getchar e receba via teclado o

2 - Escreva um programa utilizando a funcao gets e receba via teclado o

3 - Escreva um programa utilizando as funcoes printf e scanf para receber um

Os tipos de variaveis sao:

char ------> um unico byte, capaz de conter um caracter do conjunto de

Os qualificadores sao utilizados nos tipos de variaveis acima. Sao eles:

Aplicando os qualificadores nas variaveis acima:

Inteiro curto -> short int ou short

Inteiro longo -> long int ou long

caracter Sem sinal -> unsigned char

inteiro Sem sinal -> unsigned int

Obs.: Na funcao printf para imprimir um valor long utiliza-se a letra

/para o programa e espera uma tecla para ver o resultado na tela/

/para o programa e espera uma tecla para ver o resultado na tela/

/para o programa e espera uma tecla para ver o resultado na tela/