COMPUTAO II

(PARTE 1)
Prof.. Dr.
Dr. Ionildo Jos Sanches

CURITIBA
2011

SUMRIO
1.

FUNES EM C ................................................................................................................................................................ 1
1.1 SUBPROGRAMAS .............................................................................................................................................................. 1
1.2 FUNES EM C................................................................................................................................................................. 1
1.2.1
Escopo de Variveis............................................................................................................................................... 2
1.2.2
Passagem de Parmetros....................................................................................................................................... 4
1.3 ESPECIFICAO DE CLASSES DE ARMAZENAMENTO ........................................................................................................ 6

2.

PONTEIROS ....................................................................................................................................................................... 8
2.1
2.2
2.3
2.4
2.5

3.

ESTRUTURAS.................................................................................................................................................................. 15
3.1

4.

OPERAES COM PONTEIROS ........................................................................................................................................... 9

PASSANDO ENDEREOS PARA FUNES......................................................................................................................... 12
INICIALIZAO DE PONTEIROS ....................................................................................................................................... 13
ALOCAO DINMICA DE MEMRIA ............................................................................................................................. 13
ARGUMENTOS DA LINHA DE COMANDO ......................................................................................................................... 14

EXEMPLO DE UMA ESTRUTURA ...................................................................................................................................... 15

ARQUIVOS ....................................................................................................................................................................... 19
4.1 DECLARAO DE ARQUIVOS EM C/C++ ........................................................................................................................ 19
4.2 COMANDOS DE ARQUIVOS EM C/C++ ............................................................................................................................ 19
4.2.1
Funo fopen ().................................................................................................................................................... 19
4.2.2
Funo fclose() .................................................................................................................................................... 21
4.2.3
Funo ferror() .................................................................................................................................................... 21
4.2.4
Funo fputc()...................................................................................................................................................... 21
4.2.5
Funo fgetc()...................................................................................................................................................... 21
4.2.6
Funo fputs()...................................................................................................................................................... 22
4.2.7
Funo fgets() ...................................................................................................................................................... 22
4.2.8
Funo fwrite() .................................................................................................................................................... 22
4.2.9
Funo fread() ..................................................................................................................................................... 22
4.2.10 Funo fseek()...................................................................................................................................................... 23
4.2.11 Funo feof()........................................................................................................................................................ 23
4.2.12 Funo rewind() .................................................................................................................................................. 23
4.2.13 Funo remove().................................................................................................................................................. 23
4.2.14 Funo fflush()..................................................................................................................................................... 23
4.2.15 Funo ftell() ....................................................................................................................................................... 24
4.2.16 Funo fprintf().................................................................................................................................................... 24
4.2.17 Funo fscanf() .................................................................................................................................................... 25

BIBLIOGRAFIA ....................................................................................................................................................................... 26
APNDICE A - .......................................................................................................................................................................... 27

ii

1. Funes em C
1.1

Subprogramas

Um subprograma um grupo de instrues a que se deu um nome. Os subprogramas permitem a

diviso de um programa em vrios mdulos, cada um dos quais pode ser desenvolvido separadamente e
independente dos outros, podendo estes mdulos, posteriormente, serem integrados num programa nico.
A resoluo de problemas maiores exige o uso de estratgias de resoluo de problemas e tcnicas
de Programao Modular. Dentre as estratgias de resoluo de problemas, a mais utilizada a tcnica de
Refinamentos Sucessivos (ou Decomposio), que consiste na diviso de um problema em subprogramas
sucessivamente at torn-lo simples.
Quando os programas se tornam longos, interessante implementar os subproblemas em
subprogramas e fazer do programa um conjunto de subprogramas. Esta tcnica conhecida como
Modularizao ou Programao Modular. O C implementa este pensamento, tornando natural a
codificao dos subproblemas obtidos a partir de tcnicas de refinamento sucessivos e dando nveis de
detalhamento ao programa (profundidade).
Os subprogramas possuem definies de dados e comandos prprios, alm de uma rea de
comunicao para troca de informaes.
Quando um programa executado, ele sempre inicia pelo bloco de comandos do programa
principal, ou seja, a funo main. Ao encontrar uma chamada a uma funo, ocorre um desvio do
processamento para o bloco de comandos da funo que, por sua vez, podem conter chamadas a outras
funes. Ao trmino da funo, o processamento retorna ao comando seguinte ao da sua chamada.

1.2

Funes em C

A declarao de uma funo serve para desviar uma parte (ou trecho) de um programa e associ-lo
a um identificador, de modo que ele possa ser ativado atravs de uma chamada funo.
J vimos alguns exemplos de funes, como as funes sqrt(x) e pow(x, y). Para utilizlas basta passar-lhes os argumentos, e um valor retornado pela funo.
Alm das funes das bibliotecas padro, o C permite a criao de novas funes pelo prprio
programador, como descrito a seguir. A declarao de uma funo consiste do tipo de dado a ser
retornado pela funo, o identificador da funo, ( (abre parnteses), seus parmetros opcionais e, por
ltimo ) (fecha parnteses). Se o especificador de tipo for omitido, int assumido.
<tipo devolvido> <Identificador> ( <lista de parmetros> )
{
Seqncia de comandos
}

A lista de parmetros (opcional) estabelece a comunicao entre a funo e quem a ativou.

Quando o tipo devolvido for omitido, o compilador interpreta como do tipo int.
O programa Ordena1 abaixo l dois nmeros a e b, os ordena caso a seja maior que b e
escreve o par ordenado. O programa Ordena2 tem o mesmo objetivo, mas possui a sua estrutura
modularizada.
/* Programa Ordena1 */
#include <stdio.h>
int a, b, Aux;

/* Programa Ordena2 */
#include <stdio.h>
int a, b, Aux;

int main()
{
scanf(%d %d, a, b);

void Ordena(void)
{
if (a > b) {

2
if (a > b) {
Aux = a;
a = b;
b = Aux;
}
printf(%d %d, a, b);
}

Aux = a;
a = b;
b = Aux;
}
}
int main()
{
scanf(%d %d, &a, &b);
Ordena();
printf(%d %d\n, a, b);
}

Quando o programa Ordena2 executado, e encontra o identificador Ordena (chamada de

funo), ocorre um desvio para a funo que executada. Ao trmino da funo, o controle devolvido
ao comando seguinte ao da sua ativao (comando printf).
A chamada de uma funo funciona como um Comando Simples, bastando o nome da funo
seguida pelos parnteses para ativ-la. Perceba que a funo main de Ordena2 executa exatamente o
que o problema define: ler, ordenar e escrever.
Exemplo: Programa para calcular o fatorial de um nmero:
#include <stdio.h>
#include <conio.h>
long fat(int N)
{
int i;
long Fat;
Fat = 1;
for (i=2; i<=N; i++)
Fat = Fat * i;
return Fat;
}
int main()
/* programa principal */
{
int N;
char ch;
do {
printf("\n\nEntre com um numero: ");
scanf("%d", &N);
if (N > 0)
printf("Fatorial de %d = %ld\n", N, fat(N));
else
printf("Numero Invalido!\n");
printf("\nDeseja Continuar <S> ou <N>? ");
ch=getch();
} while (ch=='s' || ch=='S');
return 0;
}

1.2.1 Escopo de Variveis

A linguagem C permite definir o escopo das variveis de um programa, isto , em que pontos do
programa estas variveis so visveis (podem ser referenciadas).
Esta visibilidade definida pelo local onde a varivel est declarada no programa, ou seja, a qual
Bloco de Declaraes pertence. Isto porque um programa pode ser formado por um conjunto de funes,
onde cada uma possui seu prprio Bloco de declaraes.

3
No programa Ordena2, visto anteriormente, a varivel Aux est declarada no incio do programa
(fora das funes) e s utilizada pelo procedimento Ordena. Neste caso, tanto a funo Ordena como
a funo main podem usar esta varivel. Dizemos que Aux uma varivel global ao programa.
/* Programa Ordena3 */
#include <stdio.h>
int a, b;
/* variveis globais */
void Ordena(void)
{
int Aux;
if (a > b) {
Aux = a;
a = b;
b = Aux;
}
}

/* varivel local */

int main()
{
scanf(%d %d, &a, &b);
Ordena();
printf(%d %d\n, a, b);
return 0;
}

Agora Aux uma varivel local a Ordena(), pois est declarada no seu bloco de declaraes,
impedindo o seu acesso pela funo main. Na verdade, a varivel Aux s criada quando a funo
ativada e ao seu trmino a varivel Aux liberada, tornando-se inacessvel e seu contedo perdido.
As variveis a e b, como esto declaradas fora das funes, podem ser acessadas tanto pelo
programa principal quanto pela funo Ordena(). So variveis globais funo.
Na realidade, todas as variveis declaradas fora das funes so visveis (globais) a todos os seus
subprogramas, com exceo do caso a seguir:
/* Programa Escopo */
#include <stdio.h>
int x;
/* x global */
void Troca(void)
{
int x;
x = 1;
}

/* x local */

int main()
{
x = 0;
printf(x antes = %d\n, x);
Troca();
printf(x depois = %d\n, x);
return 0;
}

Sada: x antes

= 0

x depois = 0

O programa Escopo possui declaradas duas variveis x. Uma global (definida no inicio do
programa) e outra local (definida na funo Troca()). Quando duas variveis so declaradas com um
mesmo nome, o mecanismo de visibilidade deve definir qual das variveis est sendo realmente acessada.

4
O mecanismo de visibilidade determina que a declarao da varivel x local impede o acesso
varivel x global. So duas variveis distintas que ocupam posies de memria diferentes, tendo apenas
o nome em comum. A atribuio do valor 1 a x, na funo Troca, em nada afeta a varivel x do
programa principal que permanece com zero.
1.2.2 Passagem de Parmetros

Nos programas at agora apresentados, a comunicao entre as funes e a unidade que as ativa
feita atravs de mecanismos de visibilidade de variveis. o caso do programa Ordena3 onde a e b,
sendo globais ao programa, podem ser alterados na funo Ordena(). Este esquema de comunicao
conhecido como comunicao implcita entre subprogramas.
Existe um outro esquema de comunicao que define muito bem as informaes que entram e
saem de um subprograma e a maneira como sero trocadas com a unidade que os ativou. Este esquema
chamado de Comunicao Explcita entre subprogramas.
Neste esquema so definidos os Argumentos na chamada do subprograma e os Parmetros na
declarao do subprograma. Os argumentos s fazem sentido no ambiente que ativa o subprograma, da
mesma forma que os parmetros no ambiente do subprograma ativado.
Exemplo: Ler dois salrios distintos e informar qual o maior, usando uma funo:
#include <stdio.h>
float Maior(float S1, float S2) /* funo com 2 parmetros */
{
if (S1 > S2)
return (S1);
else
return (S2);
}
int main()
{
float Sal1, Sal2, MaiorSal;
printf(Entre com dois salarios : );
scanf(%f %f, &Sal1, &Sal2);
MaiorSal = Maior(Sal1, Sal2);
/* chamada de funo com 2 argumentos */
printf(Maior Salario: R$ %.2f\n, MaiorSal);
return 0;
}

Argumentos e parmetros devem se corresponder por tipo e posio. No exemplo acima, o

parmetros S1 e S2 do tipo float sero associados aos argumentos Sal1 e Sal2 tambm float. Se alguma
destas condies falhar, um erro de compilao ser indicado.
Existem duas formas de associao entre parmetros e argumentos: a associao do parmetro por
referncia e por valor.
A associao de parmetros por referncia ou endereo deve ser utilizada quando se deseja
alterar o valor do argumento. Como o nome diz, referncia significa que, quando se altera o valor do
parmetro, se est na realizada referenciando (endereando) o argumento. como se o parmetro fosse
um sinnimo do argumento, funcionando como uma varivel global ao programa.
A associao de parmetros por valor implica no se alterar o valor do argumento. Portanto, esta
forma de associao deve ser utilizada apenas em argumentos de entrada.
Muito embora a conveno de C de passagem de parmetros seja por valor, pode-se criar uma
chamada por referncia passando um ponteiro para o argumento. Como isso faz com que o endereo do
argumento seja passado para a funo, pode-se, ento alterar o valor do argumento externo funo.

5
Ponteiros so passados para as funes como qualquer outra varivel. Obviamente, necessrio
declarar os parmetros como do tipo ponteiro. Por exemplo, a funo Ordena(), que troca os valores dos
seus dois argumentos inteiros.
/* Programa Ordena3 */
#include <stdio.h>
void Ordena(int *a, int *b)
{
int Aux;
if (*a > *b) {
Aux = *a;
*a = *b;
*b = Aux;
}
}
int main()
{
int a, b;
scanf(%d %d, &a, &b);
Ordena(&a, &b);
printf(%d %d\n, a, b);
return 0;
}

#include <stdio.h>
void Troca(int *y)
{
*y = 1;
}
int main()
{
int x = 0;
printf(x antes = %d\n, x);
Troca(&x);
printf(x depois = %d\n, x);
return 0;
}

Sada: x antes

= 0
x depois = 1

Exemplo: Calcular o produto de dois nmeros:

#include <stdio.h>
void Mult (float x, float y)
{
printf(%f\n, x * y);
}
int main()
{
Mult(2, 3);
Return 0;
}

6
O programa anterior consiste de uma funo que imprime o valor do produto de dois nmeros
recebidos pela passagem de parmetros e funo main que manda executar a funo Mult() enviando os
valores numricos 2 e 3 como argumentos.
Observe que:
No utilizou nenhuma varivel global.
As variveis x e y do procedimento no precisam ser declaradas, pois so variveis de
passagem e foram declaradas no incio da funo.
A funo main no utiliza nenhuma varivel.
Os parmetros recebem os valores na mesma ordem em que so declarados como
parmetros. Isto quer dizer que para efeito de clculo dentro da funo Mult(), o x assume
valor 2 e y o 3.
b

Exemplo: Calcular

dx usando Soma do Retngulos.

/* Programa Integral */
#include <stdio.h>
float f(float x)
{
float fx;
fx = x * x;
return fx;
}

/* funcao utilizada */

int main()
{
float a, b, h, Soma;
int i, n;
printf(Entre com um numero inteiro de divisoes: );
scanf(%d, &n);
printf(Entre com o intervalo inicial: );
scanf(%f, &a);
printf(Entre com o intervalo final: );
scanf(%f, &b);
h = (b - a) / n;
Soma = 0;
for(i=0; i<n; i++)
Soma = Soma + f(a + i * h);
Soma = Soma * h;
printf(O Valor Aprox. da Integral = %.10f\n, Soma);
return 0;
}

Em C permitido que funes ativem a elas mesmas. Esta forma de ativao conhecida como
Recursividade.

1.3

Especificao de Classes de Armazenamento

Declaraes fora de uma funo implicam armazenamento default static. Uma varivel static tem
alocao de memria permanente inalterado, exceto se modificado por uma funo: seu escopo dito ser
o programa.
A palavra chave auto redundante, uma vez que no se pode declarar uma varivel como auto
fora de uma funo, e declaraes dentro do corpo de uma funo so assumidas como auto. A memria
alocada (na pilha) at que a funo retorne; o escopo de uma varivel auto dito ser a funo.
A palavra chave register tambm cria objetos auto, mas orienta o compilador a armazenar o
objeto em um registrador rpido; sugere ao compilador que uma varivel usada fortemente. No
permitido ter acesso ao endereo de uma varivel register.

7
Extern no aloca memria, mas implica que o objeto declarado estar presente mais tarde no
arquivo fonte ou em outro arquivo fonte.

2. Ponteiros
Um ponteiro proporciona um modo de acesso a variveis sem referenci-las diretamente.
Basicamente, um ponteiro uma representao simblica de um endereo.
Ponteiros so usados em situaes em que a passagem de valores difcil ou indesejvel. Algumas
razes para o uso de ponteiros so (MIZRAHI, 1990):
1. Fornecem maneiras com as quais as funes podem realmente modificar os argumentos que
recebem;
2. Para passar vetores e strings mais convenientemente de uma funo para outra, isto , us-los
ao invs de vetores;
3. Para manipular vetores mais facilmente atravs de movimentao de ponteiros para elas (ou
parte delas), em vez de o prprio vetor.
4. Para criar estruturas de dados complexas, como listas encadeadas e rvores binrias, onde uma
estrutura de dados deve conter referncias sobre outra;
5. Para comunicar informaes sobre memria, como na funo malloc() que retorna a
localizao de memria livre atravs do uso de ponteiro;
6. Uma outra razo importante para o uso de ponteiros que notaes e ponteiros compilam mais
rapidamente tornando o cdigo mais eficiente.
Um ponteiro uma varivel que contm um endereo de memria. Esse endereo normalmente
a posio de uma outra varivel na memria. Se uma varivel contm o endereo de uma outra, ento a
primeira varivel dita para apontar para a segunda.
A figura abaixo ilustra esta situao, onde uma varivel aponta para outra.
Endereo na
Memria

Varivel na
Memria

1000

1005

1001
1002
1003
1004
1005
1006
:

Se uma varivel ir conter um ponteiro, ela deve ser declarada como tal. Uma declarao de
ponteiro consiste do tipo de base, um "*" (asterisco) e o nome da varivel. A forma geral para se declarar
uma varivel ponteiro :
<tipo> *<identificador>

onde <tipo> qualquer tipo vlido em C e <identificador> o nome da varivel ponteiro.

O tipo base do ponteiro define que tipo de variveis o ponteiro pode apontar. Tecnicamente,
qualquer tipo de ponteiro pode apontar para qualquer lugar na memria. No entanto, toda a aritmtica de
ponteiros feita por meio do tipo base, assim, importante declarar o ponteiro corretamente. Por
exemplo,
char *ptr;

9
Existem dois operadores especiais para ponteiros: * e &. O operador de endereo (&) um
operador unrio que devolve o endereo na memria do seu operando. Um operador unrio requer apenas
um operando. Por exemplo,
ptr = &soma;

coloca em ptr o endereo da memria que contm a varivel soma. Esse endereo a posio interna ao
da varivel no computador. O endereo no tem relao alguma com o valor de soma. O operador & pode
ser imaginado como retornando "o endereo de". Assim, o comando de atribuio anterior significa "ptr
recebe o endereo de soma".
Para entender melhor a atribuio anterior, assuma que a varivel soma usa a posio de memria
1005 para armazenar seu valor. Assuma tambm que soma tem o valor 10. Ento, aps a atribuio
anterior, ptr ter o valor 1005.
O segundo operador de ponteiro o operador indireto (*) que o complemento de (&). um
operador unrio que devolve o valor da varivel localizada no endereo (ponteiro) operando, isto ,
devolve o contedo da varivel apontada pelo operando. Por exemplo, se ptr contm o endereo da
varivel soma,
aux = *ptr;

coloca o valor de soma em aux. Portanto, aux ter o valor 10 porque 10 estava armazenado na posio
1005, que o endereo que estava armazenado em ptr. O operador * pode ser imaginado como "no
endereo". Nesse caso, o comando anterior significa "aux recebe o valor que est no endereo ptr".
#include <stdio.h>
int main()
{
int y, x=1;
int *p;
p=&x;
/* faz com que p aponte para o endereo de x */
y=*p;
/* atribui o valor de x para y */
printf("Endereco de p = %u\n", &p);
printf("Endereco de x = %u\n", &x);
printf("Endereco de y = %u\n", &y);
printf("Valor de p = %u\n", p);
printf("Valor de *p = %d\n", *p);
printf("Valor de x = %d\n", x);
printf("Valor de y = %d\n", y);
return 0;
}

2.1

Operaes com Ponteiros

Em geral, expresses envolvendo ponteiros concordam com as mesmas regras de qualquer outra
expresso em C.
Como o caso com qualquer varivel, um ponteiro pode ser usado no lado direito de um comando
de atribuio para passar seu valor para um outro ponteiro. Por exemplo,
#include <stdio.h>
int main()
{
int x=100;
int *p1, *p2;
p1=&x;
p2=p1;
printf("%p\n", p2);

/* imprime o endereo de x, no seu valor */

10
printf("%d\n", *p2);
return 0;

/* imprime o valor de x */

Agora, tanto p1 quanto p2 apontam para x. O endereo de x mostrado, usando o modificador de

formato de printf() %p, que faz com que printf() apresente um endereo no formato usado no
computador.
Existem apenas duas operaes aritmticas que podem ser usadas com ponteiros: adio e
subtrao.
Para entender o que ocorre na aritmtica de ponteiros, considere p1 um ponteiro para um inteiro
com o valor atual 1000. Assuma tambm, que os inteiros so de 2 bytes. Aps a expresso
p1++;

p1 contm 1002, no 1001. Cada vez que p1 incrementado, ele aponta para o prximo inteiro na
memria. O mesmo verdade nas operaes de decrementos. Por exemplo, assumindo que p1 tem o valor
1000, a expresso:
p1--;

faz com que p1 receba o valor 998.

Cada vez que um ponteiro incrementado, ele aponta para a posio de memria do prximo
elemento do seu tipo base. Cada vez que decrementado, ele aponta para a posio do elemento anterior.
Com ponteiros para caracteres, o incremento ou decremento de um em um byte. Contudo, todos os
outros ponteiros incrementam ou decrementam pelo tamanho do tipo de dado que eles apontam.
char *ch=1000;
int *i=1000;

Memria
ch

1000

ch+1

1001

ch+2
ch+3

1002
1003

ch+4

1004

ch+5
:

1005
:

i
i+1
i+2

As operaes no esto limitadas apenas a incremento e decremento. Tambm permitido somar

ou subtrair inteiros de ponteiros. A expresso
p1=p1 + 5;

faz p1 apontar para o quinto elemento do tipo p1 adiante do elemento que ele est atualmente apontando.
Alm da adio e subtrao entre um ponteiro e um inteiro, nenhuma outra operao aritmtica
pode ser efetuada com ponteiros, especificamente, voc no pode multiplicar ou dividir ponteiros; no
pode aplicar os operadores de deslocamento e de mascaramento bit a bit com ponteiros; e no pode
adicionar ou subtrair o tipo float ou o tipo double a ponteiros.
#include <stdio.h>
void soma(int *px, int *py)
{
*px=*px+10;
*py=*py*2;

11
}
int main()
{
int x=1, y=2;
soma(&x, &y);
printf("X = %d e Y = %d\n", x, y);
return 0;
}

A sada do programa ser:

X = 11 e Y = 4

O smbolo *px indica o contedo do endereo px. Em outras palavras, pode usar *px onde usaria
x. A primeira instruo toma o contedo do endereo px (isto , 1) e soma 10 a ele, armazenando o total
no endereo px. O mesmo vale para a segunda instruo.
O programa abaixo mostra o uso de ponteiros dentro do prprio programa.
#include <stdio.h>
int main()
{
int x=1, y=2;
int *px, *py;
printf("X = %d e Y = %d\n", x, y);
px = &x;
/* inicializa ponteiro atribuindo endereos */
py = &y;
*px = *px + 10;
*py = *py * 2;
printf("X = %d e Y = %d\n", x, y);
return 0;
}

A instruo:
int *px, *py;

declara px e py do tipo "ponteiros para inteiros". Ponteiros so sempre inicializados com o valor 0 ou
(nulo) e C garante que NULL no um endereo vlido, ento antes de us-los devemos atribuir
algum endereo vlido a eles, o que feito pelas instrues:
NULL

px = &x;
py = &y;

As instrues
*px = *px + 10;
*py = *py * 2;

so equivalentes a:
x = x + 10;
y = y * 2;

possvel comparar dois ponteiros em uma expresso relacional. Por exemplo, dados dois
ponteiros p e q, o fragmento de cdigo seguinte perfeitamente vlido.

12
if (p < q)
printf("p aponta para um endereco anterior a q");

2.2

Passando Endereos para Funes

Funes podem alterar argumentos que recebem da funo que a chamou. A forma de passar
vrios valores para uma funo e retornar um nico j foi vista. Mas, como fazer para que uma funo
altere mais de um valor para a funo chamadora? Visto que no h mecanismos prprios de funes para
isto, ns devemos contar com o uso de ponteiros.
Vamos analisar a seguinte situao: como uma funo pode alterar duas variveis da funo
chamadora. Dois procedimentos so necessrios:
1. O programa chamador, em vez de passar valores para a funo, passa seus endereos. estes
endereos so onde o programa chamador quer que a funo coloque os dados gerados; em
outras palavras, so endereos de variveis do programa chamador onde ns queremos
armazenar os novos valores.
2. A funo chamada deve declarar os endereos recebidos como ponteiros.
Exemplo: Programa que passa o endereo de duas variveis como argumentos para uma funo onde os
seus valores so alterados.
#include <stdio.h>
void altera1(int px, int py)
{
px=1;
py=2;
}
void altera2(int *px, int *py)
{
*px=1;
*py=2;
}
int main()
{
int x=0, y=0;
altera1(x, y);
printf("X = %d e Y = %d\n", x, y);
altera2(&x, &y);
printf("X = %d e Y = %d\n", x, y);
return 0;
}

Ao executar este programa, a sada ser:

X = 0 e Y = 0
X = 1 e Y = 2

A funo main() indica para a funo altera2() onde colocar os valores atravs da passagem de
seus endereos usando o operador de endereos (&). A expresso
altera2(&x, &y);

causa a passagem dos endereos de x e y para a funo, que os armazena em localizaes privadas de
memria somente conhecidas por ela.

13
A estes endereos so dados nomes: px e py, para que a funo possa referenci-los, justamente
como feito com qualquer outro tipo de varivel.
A declarao de ponteiros tem um sentido diferente da de uma varivel simples. A instruo
int *px, *py;

declara que *px e *py so do tipo int e que px e py so ponteiros, isto , px e py contm endereos de
variveis do tipo int.

2.3

Inicializao de Ponteiros

Aps um ponteiro ser declarado, mas antes que lhe seja atribudo um valor, ele contm um valor
desconhecido. Se voc tentar usar um ponteiro antes de lhe dar um valor, provavelmente, levar a um erro
durante a execuo do programa.
Por conveno, voc deve atribuir o valor nulo a um ponteiro, que no est apontando para lugar
algum, para indicar que ele no aponta para nada. Porm, apenas porque um ponteiro tem um valor nulo,
no o torna seguro.
O exemplo abaixo mostra como inicializar uma string usando ponteiro.
#include <stdio.h>
int main()
{
char *msg = "Bom dia, ";
char nome[37];
printf("Digite o seu nome: ");
gets(nome);
printf("%s%s\n", msg, nome);
return 0;
}

Com voc pode observar, o ponteiro msg no um vetor. Todo compilador cria uma tabela de
strings, que usada internamente pelo compilador para armazenar as constantes strings usadas pelo
programa. Assim, o comando de declarao anterior coloca o endereo de Bom dia, , armazenado na
tabela de strings no ponteiro msg. O ponteiro msg pode ser usado por todo o programa como qualquer
outra string. Por exemplo, o programa que segue perfeitamente vlido:
/* imprime o conteudo da string de tras para frente */
#include <stdio.h>
#include <string.h>
char *msg = "Hello World";
int main(void)
{
register int i;
puts(msg);
for (i=strlen(msg)-1; i>=0; i--)
printf("%c", msg[i]);
printf("\n");
return 0;
}

2.4

Alocao Dinmica de Memria

Alocao esttica: previso no pior caso da quantidade de memria a ser usada; reserva de
memria em tempo de compilao/traduo;

14
Alocao dinmica: alocao de memria para o componente quando ele comea a existir
durante a execuo do programa.
Exemplo de alocao dinmica de memria para uma varivel do tipo int.
#include <stdio.h>
#include <stdlib.h>
int main(){
int *iptr;
iptr = malloc(sizeof(int));
*iptr = 10;
printf(O Valor %d, *iptr);
free(iptr);
return 0;
}

2.5

Argumentos da Linha de Comando

Voc j deve ter usado algum programa em que, quando voc o chama pelo sistema operacional,
voc pode no s digitar o seu nome, como tambm vrios outros itens, como o nome do arquivo a ser
utilizado. Um exemplo tpico :
$ gcc

-o

programa

programa.c

Aqui o argumento "-o" indica que o prximo argumento ser o nome do arquivo executvel, neste
caso, ser programa (se for omitido o arquivo de sada se chamar "a.out") e o ltimo argumento indica
o nome do arquivo fonte.
O C, automaticamente, fornece a capacidade de ler este tipo de argumentos a todos os programas
C.
O programa seguinte mostra isso:
#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
printf("Numero de argumentos: %d\n", argc);
for (i=0; i<argc; i++)
printf("Argumento[%d]: %s\n", i, *(argv+i));
return 0;
}

Os dois argumentos nos parnteses de main() so argc e argv. A varivel argc corresponde ao
nmero de argumentos da linha de comando, incluindo o nome do programa. A varivel *argv[]
representa uma matriz de ponteiros para string, onde cada string representa um argumento da linha de
comandos. As strings podem ser acessadas atravs de *(argv + i) ou argv[i], para i variando de 0 at
argc 1.
A primeira string, *(argv + 0), representa o nome do programa e o caminho de localizao dele
no disco.
Os nomes argc (ARGument Count) e argv (ARGument Values) so tradicionalmente usados para
este fim, mas qualquer outro pode ser usado.

15

3. Estruturas
No caso de vetores, foi visto que todos os componentes pertenciam a um mesmo grupo (tipobase). O problema de agrupar dados desiguais em C resolvido pelo uso de Estruturas. Estruturas
permitem agrupar um conjunto de tipos de dados no similares sob um nico nome.
Uma estrutura uma coleo de uma ou mais variveis, possivelmente de tipos diferentes,
colocadas juntas sob um nico nome. Estruturas so chamadas de registros em algumas linguagens. Um
Registro uma estrutura que envolve elementos de natureza distinta. No registro cada elemento pode ser
de um tipo diferente.
Cada Estrutura tem um certo nmero de componentes denominados campos (fields) e definidos
atravs de identificadores.
struct <NomeEstrutura> {
<Tipo1> <Campo1>;
<Tipo2> <Campo2>;
M
<TipoN> <CampoN>;
};

Variveis do Tipo Estrutura so utilizadas quando uma coleo de dados tem alguma afinidade
entre si.

3.1

Exemplo de uma Estrutura

O programa a seguir usa uma estrutura simples contendo dois itens de dados: uma varivel inteira
(cdigo) e uma varivel float (salrio).
#include <stdio.h>
int main()
{
struct exemplo {
/* define o tipo de dado */
int codigo;
/* atributo inteiro */
float salario;
/* atributo float */
};
struct exemplo x;
x.codigo=2410;
x.salario=545.00;
printf(Cdigo = %d\nSalario=%f\n, x.codigo, x.salario);
return 0;
}

O exemplo tradicional de uma estrutura o cadastro de funcionrios de uma empresa que agrega
as caractersticas deste funcionrio: um funcionrio descrito por um conjunto de atributos como nome
(uma strting), cargo (string), salrio (float), data de admisso (inteiros). Provavelmente, haver outros
funcionrios, ento dever ser definido um vetor de estruturas.
Primeiramente, deve ser definido o tipo da estrutura que deseja criar.

16
Registro Func.
Nome

Registro Funcionrio:
Nome
Cargo
Salrio
Data de Admisso

Cargo
Salrio
Data Admisso
Dia

Ms Ano

typedef struct {
int Dia, Mes, Ano;
} TpData;
typedef struct {
char Nome[30];
char Cargo[20];
float Salario;
TpData DataAdm;
} TpRegFunc;
TpRegFunc RegFunc;

Estas instrues definem um novo tipo de dado chamado TpRegFunc que uma estrutura.
Um campo de uma varivel do tipo struct acessado pelo nome da varivel do tipo struct seguido
de um ponto (.) e o nome do campo.
<VarRegistro>.<Campo>

Exemplo:

RegFunc.Nome
RegFunc.Salario
RegFunc.DataAdm.Ano

O campo de uma Estrutura funciona exatamente como uma varivel (do tipo do campo). Por
exemplo, a varivel RegFunc.Salario pode ser utilizada em qualquer lugar onde uma varivel do tipo
float requerida.
Vetores e estruturas podem ser combinados livremente, e este um recurso bastante utilizado em
programao.
Funcionrios

1
2
3
4

Registro Func.
Nome
Cargo
Salrio

Data Admisso
Dia

Ms Ano

Exemplo: Fazer um programa que leia dados de 10 funcionrios e imprima uma relao de todos os
empregados que ganham salrio maior que a mdia geral.

17
#include <stdio.h>
#include <conio.h>
#define NumFunc 10
typedef struct {
int Dia, Mes, Ano;
} TpData;
typedef struct {
char Nome[30];
char Cargo[20];
float Salario;
TpData DataAdm;
} TpRegFunc;
TpRegFunc CadFunc[NumFunc];
float Media;
void LeFuncionarios()
{
int i;
for (i=0; i<NumFunc; i++) {
printf("Entre com o Nome
: ");
scanf("%[^\n]", CadFunc[i].Nome);
fflush(stdin);
printf("Entre com o Cargo
: ");
scanf("%[^\n]", CadFunc[i].Cargo);
fflush(stdin);
printf("Entre com o Salario
: ");
scanf("%f", &CadFunc[i].Salario);
fflush(stdin);
printf("Entre com a Data de Admissao : ");
scanf("%d/%d/%d",&CadFunc[i].DataAdm.Dia,&CadFunc[i].DataAdm.Mes,&CadFunc[i].DataAdm.Ano);
fflush(stdin);
printf("\n");
}
}
void CalcMedia()
{
int i;
Media = 0;
for (i=0; i<NumFunc; i++)
Media = Media + CadFunc[i].Salario;
Media = Media / NumFunc;
}
void ExibeSalarios()
{
int i;
for (i=0; i<NumFunc; i++) {
if (CadFunc[i].Salario > Media) {
printf("%s\n", CadFunc[i].Nome);
printf("%s\n", CadFunc[i].Cargo);
printf("%.2f\n", CadFunc[i].Salario);
printf("%02d/%02d/%02d\n\n",
CadFunc[i].DataAdm.Dia,
CadFunc[i].DataAdm.Ano);

CadFunc[i].DataAdm.Mes,

18
}
}
}
int main()
{
LeFuncionarios();
CalcMedia();
ExibeSalarios();
getch();
return 0;
}

19

4. Arquivos
Estruturas de dados manipulados fora do ambiente do programa so conhecidas como arquivos.
Considera-se como ambiente do programa a memria principal, onde nem sempre possvel ou
conveniente manter certas estruturas de dados.
Um arquivo, que armazenado em um dispositivo de memria secundria, como discos, por
exemplo, pode ser lido ou escrito por um programa.
Um arquivo formado por uma coleo de registros, cada registro composto por campos e cada
campo possui suas caractersticas especficas. Um ou mais campos desse registro considerado campochave, que o campo que diferencia um registro dos demais, evitando duplicidade de informaes.

4.1

Declarao de Arquivos em C/C++

Um arquivo em C/C++ pode representar diversas coisas, como arquivos em disco, uma
impressora, um teclado, ou qualquer dispositivo de entrada ou sada. Iremos considerar aqui apenas
arquivos em disco.
Quando se comea a execuo de um programa, o sistema automaticamente abre alguns arquivos
pr-definidos:

stdin: dispositivo de entrada padro (geralmente o teclado)

stdout: dispositivo de sada padro (geralmente o vdeo)

stderr: dispositivo de sada de erro padro (geralmente o vdeo)

stdaux: dispositivo de sada auxiliar (em muitos sistemas, associado porta serial)

stdprn : dispositivo de impresso padro (em muitos sistemas, associado porta paralela)

Cada uma destas constantes pode ser utilizada como um ponteiro para FILE, para acessar os
perifricos associados a eles. Desta maneira, pode-se, por exemplo, usar:
ch =getc(stdin);

para efetuar a leitura de um caractere a partir do teclado, ou :

putc(ch, stdout);

para imprim-lo na tela.

A linguagem C/C++ d suporte utilizao de arquivos por meio da biblioteca stdlib.h. Essa
biblioteca fornece vrias funes para manipulao de arquivos, define novos tipos de dados para serem
usados especificamente com arquivos e, ainda, oferece algumas macros.
Os tipos de dados definidos na biblioteca stdlib.h so: size_t, fpos_t (ambos assumem os
mesmos valores que o tipo unsigned) e FILE. Uma varivel quando do tipo ponteiro para FILE
capaz de identificar um arquivo no disco, direcionando-lhe todas as operaes. Essas variveis so
declaradas como qualquer outro tipo de ponteiro:
FILE *arq, *pont;

4.2

Comandos de Arquivos em C/C++

4.2.1 Funo fopen ()

Essa funo abre arquivos, retornando o ponteiro associado a esse arquivo. O prottipo da funo
fopen() :

20
FILE *fopen (nome_do_arquivo, modo_de_abertura);
onde:
nome_do_arquivo representa o nome do arquivo que se deseja abrir, podendo conter, inclusive, o
caminho (path) para o arquivo;
modo_de_abertura representa como o arquivo ser aberto. A tabela a seguir descreve todos os modos.
r
w
a
rb
wb
ab
r+
w+
a+
rb+
wb+
ab+

Abre um arquivo de texto onde podero ser realizadas apenas leituras.

Cria um arquivo de texto onde podero ser realizadas apenas operaes de escrita.
Anexa novos dados no final de um arquivo de texto.
Abre um arquivo binrio onde podero ser realizadas apenas leituras.
Cria um arquivo binrio onde podero ser realizadas apenas operaes de escrita.
Anexa novos dados no final de um arquivo binrio.
Abre um arquivo de texto onde podero ser realizadas operaes de leitura e escrita.
Cria um arquivo de texto onde podero ser realizadas operaes de escrita e de leitura.
Anexa novos dados no final ou cria um arquivo de texto para operaes de leitura e de escrita.
Abre um arquivo binrio onde podero ser realizadas operaes de leitura e de escrita.
Cria um arquivo binrio onde podero ser realizadas operaes de escrita e de leitura.
Anexa novos dados no final de um arquivo binrio para operaes de leitura e de escrita.

Exemplo 1:
FILE *arq;
arq = fopen(arquivol.dat,w);

No Exemplo 1, a funo fopen() cria um arquivo chamado arquivo1.dat, onde podero ser
realizadas operaes de escrita (gravao). Se a funo fopen() for executada sem problemas, a varivel
arq receber o endereo de memria ocupado pelo arquivo. Caso algum erro ocorra, a varivel arq
receber o valor NULL. Sendo assim, recomendvel a realizao de um teste para verificar se o arquivo
foi aberto corretamente.
Exemplo 2:
FILE *arq;
arq = fopen(arquivo1.dat, w);
if (arq == NULL) {
printf(Ocorreu um erro. O arquivo no foi aberto.\n);
getch();
}
else {
/* As demais instrues do programa s sero ser executadas se o arquivo foi aberto de
forma correta.*/
}

Observaes:
Quando a funo fopen() utilizada para abrir um arquivo no modo escrita (w e wb), duas
situaes podem ser encontradas:
1. se o arquivo no existir, o mesmo ser criado;

21
2. se o arquivo j existir, o mesmo ser sobrescrito por um novo arquivo vazio.
Quando a funo fopen() utilizada para abrir um arquivo j existente, dever ser utilizado o
modo para leitura ou para leitura/escrita. Dessa maneira, caso o arquivo j exista, seu contedo ser
preservado.
4.2.2 Funo fclose()

Essa funo fecha um arquivo. Quando ocorrer algum erro durante a execuo dessa, poder haver
perda de dados ou, at mesmo, a perda do arquivo. O prottipo da funo fclose() :
int fclose(FILE *arq);

onde:
Arq o ponteiro para um arquivo (arq o ponteiro obtido quando o arquivo foi aberto com a funo
fopen()).
Quando a funo fclose() executada ela gera como resultado um nmero inteiro. Quando o
resultado for igual a 0 (zero) significa que o arquivo foi fechado corretamente. Quando o resultado for
qualquer valor diferente de 0 (zero) significa que houve erro na operao.
4.2.3 Funo ferror()

A funo ferror() detecta se ocorreu algum erro durante uma operao com arquivos. O
prottipo dessa funo :
int ferror(FILE *arq);

A funo ferror() retorna um nmero inteiro. Se esse nmero for diferente de zero significa
que ocorreu erro durante a ltima operao realizada com o arquivo apontado por arq. Se esse nmero for
0 (zero) no ocorreu erro.
4.2.4 Funo fputc()

Essa funo escreve um caractere em um arquivo. O prottipo da funo fputc() :

int fputc(char ch, FILE *arq);

onde:
ch o caractere que ser escrito;
arq representa o endereo do arquivo onde o caractere ser escrito.
Se a execuo da funo fputc() for bem-sucedida, vai gerar como retorno o valor do caractere
escrito; caso contrrio, devolver o valor EOF (End Of File).
4.2.5 Funo fgetc()

Essa funo l um caractere em um arquivo. O prottipo da funo fgetc ( ) :

int fgetc(FILE *arq);

onde:
arq representa o endereo do arquivo de onde o caractere ser lido.
Se a execuo da funo fgetc() for bem-sucedida, vai gerar como retorno o valor do caractere
lido; caso contrrio, devolver o valor EOF.

22
4.2.6 Funo fputs()

Essa funo escreve uma cadeia de caracteres em um arquivo. O prottipo da funo fputs() :
char *fputs (char *cadeia, FILE *arq);

onde:
cadeia armazena a cadeia de caracteres que ser escrita no arquivo;
arq o endereo do arquivo onde a cadeia de caractere ser escrita.
4.2.7 Funo fgets()

Essa funo l uma cadeia de caracteres armazenada (at que seja encontrado um caractere de
nova linha ou at que tam-1 caracteres j tenham sido lidos) em um arquivo.
char *fgets (char *cadeia, int tam, FILE *arq);

onde:
cadeia armazena a cadeia de caracteres obtida do arquivo.
tam o tamanho da cadeia.
arq o endereo do arquivo.
4.2.8 Funo fwrite()

A funo fwrite() pode escrever qualquer tipo de dado e no apenas caracteres ou cadeias de
caracteres. O prottipo da funo fwrite() :
size_t fwrite(void *mem, size_t qtd_bytes, size_t cont, FILE *arq);

onde:
mem representa a varivel que armazena o contedo para ser gravado no arquivo.
qtd_bytes representa o total em bytes que ser escrito no arquivo.
cont representa o nmero de espao de memria do tamanho especificado por qtd_bytes que sero
escritos no arquivo.
arq o endereo do arquivo onde as informaes sero escritas.
Quando a funo fwrite() for bem-sucedida, vai gerar como retorno um valor igual ao nmero
de gravaes realizadas (o parmetro cont descrito anteriormente). Caso contrrio, quando ocorrer algum
erro, o valor retornado ser menor que cont.
Exemplo:
fwrite(&var, sizeof(double), 1, arq);
4.2.9 Funo fread()

A funo fread() pode ler qualquer tipo de dado e no apenas caracteres ou cadeias de
caracteres. O prottipo da funo fread() .
size_t fread(void *mem, size_t qtd_bytes, size_t cont, FILE *arq);

onde:
mem representa a varivel que vai receber o contedo lido do arquivo.
qtd_bytes representa o total em bytes que ser lido do arquivo.
cont representa o nmero de espaos de memria do tamanho especificado por qtd_bytes que
sero lidos.
arq o endereo do arquivo que ser lido.

23
Quando a funo fread() for bem-sucedida, vai gerar como retorno um valor igual ao nmero de
leituras realizadas (o parmetro cont descrito anteriormente). Caso contrrio, quando ocorrer algum erro
ou quando o final do arquivo for encontrado, o valor retornado ser menor que cont.
Exemplo:
fread(&var, sizeof(double), 1, arq);
4.2.10 Funo fseek()

Posiciona o cursor (ponteiro) em um endereo especfico, tornando possvel leituras e escritas

aleatrias. O prottipo da funo fseek() :
int fseek(FILE *arq, long qtd_bytes, int posio);

onde:
arq representa o arquivo que ser percorrido pela funo fseek.
qtd_bytes representa a quantidade de bytes que ser percorrido a partir de posicao para encontrar
a informao desejada dentro do arquivo.
posicao representa o ponto a partir do qual a busca ser executada a varivel posicao poder
receber trs valores: SEEK_SET, SEEK_CUR ou SEEK_END.
SEEK_SET - permite a movimentao de qtd_bytes a partir da posio inicial do arquivo.
SEEK_CUR permite a movimentao de qtd_bytes a partir da posio atual do arquivo.
SEEK_END permite a movimentao de qtd_bytes a partir da posio final do arquivo.
4.2.11 Funo feof()

Essa funo determina se o final do arquivo foi encontrado. A funo feof() retorna um nmero
inteiro. Quando esse nmero for 0 (zero) significa que o fim do arquivo ainda no foi atingido. Qualquer
outro valor significa que o fim do arquivo foi encontrado.
4.2.12 Funo rewind()

Posicionar o cursor (indicador da posio atual) de volta ao incio do arquivo. O prottipo da

funo rewind() :
void rewind(FILE *arq);

onde:
arq representa o arquivo que ter o cursor reposicionado.
4.2.13 Funo remove()

Essa funo apaga um arquivo. O prottipo da funo remove() :

int remove (char *nome_arq);

onde:
nome_arq indica o nome do arquivo que ser removido (podendo ser includo o path).
Se a funo remove() for executada com xito, ser devolvido o nmero 0 (zero). Caso
contrrio, ser devolvido qualquer outro valor.
4.2.14 Funo fflush()

A funo fflush() escreve o contedo armazenado no buffer dentro de um determinado arquivo.

O prottipo da funo fflush() :

24
int fflush(FILE *arq);

onde:
arq especifica o endereo do arquivo onde sero efetivadas as gravaes.
Caso a funo fflush() no indique um arquivo especificamente, as gravaes associadas a
todos os arquivos abertos no memento sero efetivadas.
4.2.15 Funo ftell()

A funo ftell() retorna o valor atual do indicador de posio do arquivo. O prottipo da

funo ftell() :
long int ftell(FILE *arq);

onde:
arq especifica o endereo do arquivo que ser consultada a posio.
Se a funo for executada com sucesso, o valor atual do indicador de posio retornado. Se
ocorrer erro, -1L ser retornado, e o errno da varivel global ajustado para um valor positivo. Este valor
pode ser interpretado por perror().
/* exemplo ftell: consultar o tamanho de um arquivo */
#include <stdio.h>
int main ()
{
FILE * pFile;
long size;
pFile = fopen ("myfile.txt","rb");
if (pFile==NULL)
perror ("Erro ao abrir o arquivo.");
else
{
fseek (pFile, 0, SEEK_END);
size=ftell(pFile);
fclose (pFile);
printf ("Tamanho de myfile.txt: %ld bytes.\n",size);
}
return 0;
}

4.2.16 Funo fprintf()

A funo fprintf()escreve em um arquivo especfico uma seqncia de dados formatados

como os argumentos do formato especificado. Aps o parmetro do formato, a funo espera pelo menos
a quantidade de argumentos especificados no formato. O prottipo da funo fprintf() :
int fprintf(FILE *arq, const char * format, ...);

onde:
arq o endereo do arquivo onde as informaes sero escritas.
Quando a funo fprintf() for bem-sucedida, vai gerar como retorno um valor igual ao nmero
de bytes escritos no arquivo. Caso contrrio, quando ocorrer algum erro, um valor negativo ser
retornado.
/* exemplo fprintf */

25
#include <stdio.h>
int main ()
{
FILE * pFile;
int n;
char name [100];
pFile = fopen ("myfile.txt","w");
for (n=0 ; n<3 ; n++)
{
puts ("Digite seu nome: ");
gets (name);
fprintf (pFile, "Nome %d [%-10.10s]\n",n,name);
}
fclose (pFile);
return 0;
}

4.2.17 Funo fscanf()

A funo fscanf()l dados do arquivo e armazena-os de acordo com o formato do parmetro

nas posies apontadas pelos argumentos adicionais. O prottipo da funo fscanf() :
int fscanf(FILE *arq, const char * format, ...);

onde:
arq o endereo do arquivo que ser lido.
Quando a funo fscanf() for bem-sucedida, vai gerar como retorno um valor igual ao nmero
de bytes lidos. No caso de uma falha de leitura antes que todos os dados sejam lidos com sucesso, o EOF
retornado.
/* exemplo fscanf */
#include <stdio.h>
int main ()
{
char str [80];
float f;
FILE * pFile;
pFile = fopen ("myfile.txt","w+");
fprintf (pFile, "%f %s", 3.1416, "PI");
rewind (pFile);
fscanf (pFile, "%f", &f);
fscanf (pFile, "%s", str);
fclose (pFile);
printf ("Foi lido: %f e %s \n",f,str);
return 0;
}

26

Bibliografia
ASCENCIO, A. F. G., Lgica de Programao com PASCAL, Makron Books, So Paulo, 1999.
ASCENCIO, A. F. G., CAMPOS. E. A. V., Fundamentos da Programao de Computadores, PrenticeHall, So Paulo, 2002.
FARRER, H., at al, Algoritmos Estruturados, Editora Guanabara Dois, Rio de Janeiro, 1986.
FORBELLONE, A. L. V., EBERSPACHER, H. F., Lgica de Programao, 2a Edio, Makron Books,
So Paulo, 2000.
KERNIGHAN, Brian W., RITCHIE, Dennis M., C, A Linguagem de Programao: Padro ANSI, Rio de
Janeiro: Campus, 1990.
MECLER, I., MAIA, L. P., Programao e Lgica com Turbo Pascal, Editora Campus, Rio de Janeiro,
1989.
MIZRAHI, Victorine V., Treinamento em Linguagem C, So Paulo: McGraw-Hill, 1990.
SCHILDT, Herbert, C, Completo e Total, 3 edio, So Paulo: Makron Books, 1996.
TANEMBAUM, A. M., LANGSAM, Y., AUGENSTEIN, M. J., Estruturas de Dados usando C, Makron
Books, So Paulo, 1995.
WIRTH, N., Algoritmos e estruturas de dados, Prentice-Hall do Brasil, Rio de Janeiro, 1989.

27

Apndice A -