programaçào estruturas de dados e algoritmos em c

241 Pages·1995·18.56 MB·Portuguese

P
ROGRAMA˙ˆO

E
STRUTURAS
D
DE ADOS

A
E LGORITMOS

C
EM

Professor Doutor Ant(cid:243)nio Manuel Adrego da Rocha
Professor Doutor Ant(cid:243)nio Rui Oliveira e Silva Borges

Departamento de Electr(cid:243)nica e Telecomunica(cid:231)ıes
Universidade de Aveiro
PrefÆcio
Este texto serve de suporte (cid:224) disciplina de Programa(cid:231)ªo II, cujo objectivo Ø o de fornecer uma
familiariza(cid:231)ªo com o ambiente de programa(cid:231)ªo fornecido pelo Unix, na sua variante mais popularizada
Linux e o dom(cid:237)nio da linguagem C, na sua norma ANSI, para o desenvolvimento de programas de
mØdia e elevada complexidade.

Come(cid:231)amos por apresentar os aspectos essenciais da linguagem C em dois cap(cid:237)tulos. Depois
introduzirmos as constru(cid:231)ıes mais complexas da linguagem de forma gradual, (cid:224) medida que sªo
necessÆrias (cid:224) constru(cid:231)ªo de estruturas de dados mais complexas, bem como para a optimiza(cid:231)ªo e
generaliza(cid:231)ªo de algoritmos. Os aspectos fundamentais apresentados no texto sªo os seguintes:
(cid:120) A familiariza(cid:231)ªo progressiva com a linguagem de programa(cid:231)ªo C e com as suas bibliotecas.
(cid:120) A apresenta(cid:231)ªo de algoritmos recursivos e sua compara(cid:231)ªo com os algoritmos iterativos
equivalentes.
(cid:120) A introdu(cid:231)ªo da metodologia de decomposi(cid:231)ªo modular das solu(cid:231)ıes, ou seja, o paradigma da
programa(cid:231)ªo modular.
(cid:120) O estudo da organiza(cid:231)ªo da Mem(cid:243)ria de Acesso Aleat(cid:243)rio (RAM), nas suas implementa(cid:231)ıes
estÆtica e semiestÆtica, e, de um conjunto significativo de algoritmos de pesquisa e de ordena(cid:231)ªo.
(cid:120) O estudo da organiza(cid:231)ªo de mem(cid:243)rias mais complexas que a Mem(cid:243)ria de Acesso Aleat(cid:243)rio, como
por exemplo, a Mem(cid:243)ria Fila de Espera (FIFO), a Memoria Pilha (Stack) e a Mem(cid:243)ria Associativa
(CAM), nas suas implementa(cid:231)ıes estÆtica, semiestÆtica e din(cid:226)mica, e, dos algoritmos associados
para pesquisa, introdu(cid:231)ªo e retirada de informa(cid:231)ªo.

Assume-se que os alunos frequentaram a disciplina de Programa(cid:231)ªo I, e portanto, jÆ estªo
familiarizados com a metodologia de decomposi(cid:231)ªo hierÆrquica das solu(cid:231)ıes, estabelecendo
dependŒncias de informa(cid:231)ªo e no encapsulamento da informa(cid:231)ªo com a cria(cid:231)ªo de novas instru(cid:231)ıes no
(cid:226)mbito da linguagem Pascal, ou seja, com o paradigma da programa(cid:231)ªo procedimental. Bem como,
com a cria(cid:231)ªo de estruturas de dados estÆticas com alguma complexidade que modelam correctamente a
resolu(cid:231)ªo dos problemas. Pelo que, a apresenta(cid:231)ªo da linguagem C Ø feita por compara(cid:231)ªo com a
linguagem Pascal.

Pretende-se ainda, que os alunos se familiarizem com a terminologia informÆtica apresentada nos textos
de referŒncia da Ærea das CiŒncias da Computa(cid:231)ªo, pelo que, se tenha optado pela apresenta(cid:231)ªo
sistemÆtica, em itÆlico e entre parŒntesis, dos nomes dos algoritmos e das estruturas de dados em inglŒs.
Cap(cid:237)tulo 1

I C
NTRODU˙ˆO AO
SumÆrio
Este cap(cid:237)tulo Ø dedicado (cid:224) introdu(cid:231)ªo das primeiras no(cid:231)ıes sobre a gramÆtica da linguagem
C. Come(cid:231)amos por apresentar a estrutura de um programa e os seus elementos bÆsicos.
Explicamos os tipos de dados bÆsicos existentes, a defini(cid:231)ªo de constantes e de variÆveis.
Apresentamos os vÆrios tipos de expressıes e operadores existentes e a instru(cid:231)ªo de
atribui(cid:231)ªo, que Ø a instru(cid:231)ªo bÆsica de uma linguagem imperativa. Apresentamos de seguida
as estruturas de controlo, que permitem alterar o fluxo da sequŒncia das instru(cid:231)ıes.
Apresentamos ainda as instru(cid:231)ıes de leitura de dados do teclado scanf e de escrita de
dados no monitor printf. Finalmente, apresentamos as bibliotecas que contŒm as fun(cid:231)ıes
mais usuais e que estendem a operacionalidade da linguagem.
PROGRAMA˙ˆO ESTRUTURAS DE DADOS E ALGORITMOS EM C 2

1.1 Introdu(cid:231)ªo
Em 1972, Dennis M. Ritchie desenvolveu a linguagem C, nos Laborat(cid:243)rios Bell da
companhia AT & T, que Ø a principal empresa de telecomunica(cid:231)ıes dos Estados Unidos da
AmØrica, como uma linguagem de programa(cid:231)ªo concebida para a escrita de sistemas
operativos, aquilo que se designa por Programa(cid:231)ªo de Sistemas. Como a linguagem C era
tªo flex(cid:237)vel e permitia que os compiladores produzissem c(cid:243)digo em linguagem mÆquina
muito eficiente, em 1973, Dennis M. Ritchie e Ken Thompson reescreveram quase
totalmente o sistema operativo Unix em C. Devido a esta liga(cid:231)ªo (cid:237)ntima, (cid:224) medida que o
Unix se tornou popular no meio acadØmico, tambØm a linguagem C se tornou a linguagem
preferida para o desenvolvimento de aplica(cid:231)ıes cient(cid:237)ficas. Pelo que, apesar de ter sido
concebida para a escrita de sistemas operativos, a linguagem C Ø hoje encarada como uma
linguagem de uso geral.

A principal caracter(cid:237)stica da linguagem C Ø que combina as vantagens de uma linguagem de
alto n(cid:237)vel descendente do AlGOL 68, com a eficiŒncia da linguagem assembly, uma vez que
permite a execu(cid:231)ªo de opera(cid:231)ıes aritmØticas sobre ponteiros e opera(cid:231)ıes sobre palavras
binÆrias. A linguagem C tambØm tem uma sintaxe muito compacta e permite que
operadores de tipos diferentes possam ser combinados livremente.

Esta liberdade e poder da linguagem C, permite aos programadores experientes escreverem
c(cid:243)digo compacto e eficiente que dificilmente poderiam ser escritos noutras linguagens de
programa(cid:231)ªo. Mas, como Ø fracamente estruturada em termos sem(cid:226)nticos, tambØm permite
que constru(cid:231)ıes sem sentido aparente, escritas por programadores inexperientes, sejam
aceites pelo compilador como vÆlidas. O facto da linguagem C ser muito poderosa, exige
portanto, do programador muita disciplina e rigor na utiliza(cid:231)ªo das constru(cid:231)ıes da
linguagem, para que o c(cid:243)digo escrito seja leg(cid:237)vel e facilmente alterÆvel.

Apesar da linguagem C ter sido desenvolvida no princ(cid:237)pio da dØcada de 1970, a norma
ANSI (American National Standards Institute) foi apenas aprovada em 1989 (norma
ISO/IEC 9899-1990).

1.2 A estrutura de um programa em C
Ao contrÆrio do que se passa em Pascal, em que um programa apresenta uma organiza(cid:231)ªo
hierÆrquica que reflecte directamente o algoritmo que lhe deu origem, na linguagem C, um
programa Ø organizado horizontalmente como um agrupamento de variÆveis e fun(cid:231)ıes
colocadas todas ao mesmo n(cid:237)vel, uma estrutura conhecida pelo nome de mar de fun(cid:231)ıes.

Neste contexto, a diferencia(cid:231)ªo entre o programa principal e os diversos subprogramas
associados Ø feita pelo facto de existir uma fun(cid:231)ªo particular, de nome main, que Ø sempre
invocada em primeiro lugar aquando da execu(cid:231)ªo do programa. Assim, a fun(cid:231)ªo main
desempenha na prÆtica o papel do programa principal do Pascal. Segundo a norma ANSI, a
fun(cid:231)ªo main Ø uma fun(cid:231)ªo de tipo inteiro, em que o valor devolvido serve para informar
sobre o estado de execu(cid:231)ªo do programa.
3 CAP˝TULO 1 : INTRODU˙ˆO AO C

De facto, a no(cid:231)ªo de devolver um valor associado ao estado de execu(cid:231)ªo de um programa
corresponde (cid:224) filosofia subjacente (cid:224) arquitectura de comandos do Unix, em que a
linguagem de comandos (shell) Ø, no fundo, uma verdadeira linguagem de programa(cid:231)ªo, que
permite construir comandos mais complexos por combina(cid:231)ªo de comandos mais simples
(shell scripts), usando um conjunto de estruturas de controlo muito semelhantes aos
encontrados na linguagem C ou Pascal. Neste contexto, os comandos mais simples sªo
programas, de cujo sucesso de execu(cid:231)ªo vai eventualmente depender a continua(cid:231)ªo das
opera(cid:231)ıes.

Ora, como esta Ø uma Ærea que nªo serÆ explorada no (cid:226)mbito desta disciplina, em muitos
programas, sobretudo naqueles que serªo desenvolvidos nesta disciplina, nªo se coloca a
questªo de devolver um valor. Pelo que, para evitar a mensagem de aviso do compilador,
recomenda-se terminar o main com a instru(cid:231)ªo return 0. Um programa em C tem a
estrutura apresentada na Figura 1.1.

alusªo a fun(cid:231)ıes e defini(cid:231)ıes externas

alusªo a fun(cid:231)ıes e defini(cid:231)ıes locais

int main ( void )
{
declara(cid:231)ªo de variÆveis

alusªo a fun(cid:231)ıes

sequŒncia de instru(cid:231)ıes

return 0;
}

defini(cid:231)ªo de fun(cid:231)ıes locais

Figura 1.1 - Estrutura de um programa em C.
Vamos analisar as diversas partes de um programa em C atravØs do exemplo do programa
de conversªo de dist(cid:226)ncias de milhas para quil(cid:243)metros apresentado na Figura 1.2. O
ficheiro fonte que contØm o programa come(cid:231)a por mencionar as fun(cid:231)ıes e estruturas de
dados externas necessÆrias (cid:224) execu(cid:231)ªo do programa, que estªo implementadas noutros
ficheiros providenciados pela linguagem C, as chamadas bibliotecas da linguagem, ou que
em alternativa sªo desenvolvidos pelo utilizador. A linguagem C foi concebida tendo em
mente facilitar a constru(cid:231)ªo descentralizada de aplica(cid:231)ıes, atravØs do fraccionamento do
c(cid:243)digo de um programa por diferentes ficheiros fonte. Por isso, Ø necessÆrio e inevitÆvel,
mesmo em programas muito simples, recorrer (cid:224) alusªo a fun(cid:231)ıes e defini(cid:231)ıes feitas
externamente, ou seja, noutros ficheiros. Para tornar mais rigorosa esta referŒncia, foi
criado o conceito de ficheiro de interface, onde todas as alusıes e defini(cid:231)ıes associadas a
um dado tipo de funcionalidade sªo colocadas. Estes ficheiros de interface distinguem-se
dos ficheiros fonte, propriamente ditos, por terem a termina(cid:231)ªo .h em vez de .c.

A norma ANSI fornece um conjunto muito variado de ficheiros de interface que
descrevem as diferentes funcionalidades fornecidas pelas bibliotecas de execu(cid:231)ªo ANSI.
Em Unix, por defeito, todos eles estªo armazenados no direct(cid:243)rio /usr/include. Da(cid:237), nªo ser
necessÆrio referenciar este caminho de um modo expl(cid:237)cito. Quando o ficheiro em causa
estÆ neste direct(cid:243)rio, basta colocar o seu nome entre os s(cid:237)mbolos < e >. Em todos os
outros casos, a especifica(cid:231)ªo do caminho deve ser inclu(cid:237)da no nome do ficheiro e o
conjunto ser colocado entre aspas duplas.
PROGRAMA˙ˆO ESTRUTURAS DE DADOS E ALGORITMOS EM C 4
A inclusªo de ficheiros de interface num dado ficheiro fonte Ø feita usando a directiva do
prØ-processador #include numa das suas duas variantes:
(cid:120) No caso do ficheiro de interface pertencer (cid:224) linguagem C, entªo ele estÆ armazenado no
direct(cid:243)rio por defeito e usa-se a directiva #include <nome do ficheiro de interface>.
(cid:120) No caso do ficheiro de interface ter sido criado pelo utilizador e nªo estar armazenado
no direct(cid:243)rio por defeito, usa-se a directiva #include "nome do ficheiro de interface".

No m(cid:237)nimo, todos os ficheiros que contenham c(cid:243)digo que fa(cid:231)a acesso aos dispositivos
convencionais de entrada e de sa(cid:237)da tŒm que incluir o ficheiro de interface stdio.h, que
descreve as fun(cid:231)ıes e que contØm as defini(cid:231)ıes associadas com o acesso aos dispositivos
de entrada e de sa(cid:237)da e aos ficheiros. Normalmente, o dispositivo de entrada Ø o teclado e o
dispositivo de sa(cid:237)da Ø o monitor. Portanto, qualquer programa interactivo tem pelo menos
a alusªo a este ficheiro de interface, tal como se apresenta na Figura 1.2.

A seguir (cid:224)s defini(cid:231)ıes de objectos externos segue-se a alusªo (cid:224)s fun(cid:231)ıes locais que vªo ser
usadas na fun(cid:231)ªo main, bem como a defini(cid:231)ªo de estruturas de dados e constantes locais.
Locais para a aplica(cid:231)ªo, mas que para o ficheiro, se comportam como defini(cid:231)ıes globais.
Repare que a estrutura(cid:231)ªo do programa, Ø muito diferente do Pascal, sendo que as fun(cid:231)ıes
sªo primeiramente aludidas ou referidas, para se tornarem vis(cid:237)veis em todo o ficheiro e s(cid:243)
depois da fun(cid:231)ªo main Ø que sªo definidas. Neste exemplo, define-se apenas, atravØs da
directiva #define, um identificador constante MIL_QUI, que representa o factor de
conversªo de milhas para quil(cid:243)metros. Ele Ø vis(cid:237)vel para todo o c(cid:243)digo do ficheiro, ou seja,
Ø uma constante global. A fun(cid:231)ªo main Ø implementada com instru(cid:231)ıes simples, e com
recurso apenas (cid:224)s fun(cid:231)ıes de entrada e de sa(cid:237)da de dados da biblioteca stdio.

/* Programa de conversªo de dist(cid:226)ncias de milhas para quil(cid:243)metros */

/* Instru(cid:231)ıes para o prØ-processador */

#include <stdio.h> /* interface com a biblioteca de entrada/sa(cid:237)da */

#define MIL_QUI 1.609 /* factor de conversªo */

/* Instru(cid:231)ıes em linguagem C propriamente ditas */

int main ( void )
{
double MILHAS, /* dist(cid:226)ncia expressa em milhas */
QUILOMETROS; /* dist(cid:226)ncia expressa em quil(cid:243)metros */

do /* Leitura com valida(cid:231)ªo de uma dist(cid:226)ncia expressa em milhas */
{
printf ("Dist(cid:226)ncia em milhas? ");
scanf ("%lf", &MILHAS);
} while (MILHAS < 0.0);

QUILOMETROS = MIL_QUI * MILHAS; /* Conversªo da dist(cid:226)ncia */

/* Impressªo da dist(cid:226)ncia expressa em quil(cid:243)metros */
printf ("Dist(cid:226)ncia em quil(cid:243)metros Ø %8.3f\n", QUILOMETROS);
return 0;
}

Figura 1.2 - Programa da conversªo de dist(cid:226)ncias.
Vamos agora analisar com detalhe na Figura 1.3 a defini(cid:231)ªo da fun(cid:231)ªo main, que tal como
qualquer outra fun(cid:231)ªo na linguagem C, supıe a especifica(cid:231)ªo do seu cabe(cid:231)alho e do seu
corpo. No cabe(cid:231)alho, indica-se o tipo do valor devolvido, que como jÆ foi referido
anteriormente Ø sempre do tipo inteiro, o nome, e entre parŒnteses curvos, a lista de
5 CAP˝TULO 1 : INTRODU˙ˆO AO C

par(cid:226)metros de comunica(cid:231)ªo. Neste caso a fun(cid:231)ªo nªo comunica directamente com o
exterior, pelo que, nªo existe lista de par(cid:226)metros de comunica(cid:231)ªo. Quando tal acontece,
utiliza-se o identificador void. O corpo da fun(cid:231)ªo Ø delimitado pelos separadores { e },
correspondentes, respectivamente, aos separadores begin e end do Pascal, e contØm a
declara(cid:231)ªo das variÆveis locais, a alusªo a fun(cid:231)ıes usadas na sequŒncia de instru(cid:231)ıes e a
sequŒncia de instru(cid:231)ıes propriamente dita. Constitui aquilo que em linguagem C se designa
por um bloco.

cabe(cid:231)alho
int main ( void )
corpo
{
declara(cid:231)ªo de variÆveis locais
double MILHAS,
QUILOMETROS;
sequŒncia de instru(cid:231)ıes
do
{
printf ("Dist(cid:226)ncia em milhas? ");
scanf ("%lf", &MILHAS);
} while (MILHAS < 0.0);
QUILOMETROS = MIL_QUI * MILHAS;
printf ("Dist(cid:226)ncia em quil(cid:243)metros Ø %8.3f\n", QUILOMETROS);
return 0;
}

Figura 1.3 - A fun(cid:231)ªo main.

1.3 Elementos bÆsicos da linguagem C
Os identificadores sªo nomes que sªo usados para designar os diferentes objectos
existentes no programa, como por exemplo, o nome do programa, os nomes das fun(cid:231)ıes,
os nomes das constantes, tipos de dados e variÆveis. Os identificadores obedecem (cid:224) regra
de produ(cid:231)ªo apresentada na Figura 1.4.

identificador ::= letra do alfabeto | carÆcter underscore |
identificador letra do alfabeto |
identificador carÆcter underscore |
identificador algarismo decimal

Figura 1.4 - Defini(cid:231)ªo formal de um identificador.
Ou seja, sªo formados por uma sequŒncia de caracteres alfanumØricos e o carÆcter
underscore, em que o primeiro carÆcter Ø obrigatoriamente uma letra do alfabeto ou o
carÆcter underscore. Embora seja poss(cid:237)vel come(cid:231)ar um identificador pelo carÆcter underscore,
tal deve ser evitado. Este tipo de nota(cid:231)ªo Ø, em princ(cid:237)pio, reservado para o compilador.
Nªo hÆ limite para o comprimento de um identificador. Na prÆtica, esse limite Ø imposto
pelo compilador. A norma ANSI exige um comprimento m(cid:237)nimo de 31 e 6 caracteres,
respectivamente, para os identificadores internos e externos.
PROGRAMA˙ˆO ESTRUTURAS DE DADOS E ALGORITMOS EM C 6
Na linguagem C, os alfabetos maiœsculo e minœsculo sªo distintos, ou seja, a linguagem Ø
sens(cid:237)vel ao tipo de letra (case sensitive). Assim sendo, o identificador conv_dist Ø diferente do
identificador CONV_DIST. Embora nªo seja obrigat(cid:243)rio, Ø costume designar todos os
identificadores da responsabilidade do programador com caracteres maiœsculos de maneira
a distingui-los dos identificadores da linguagem C, que tŒm de ser escritos obrigatoriamente
com caracteres minœsculos. Em alternativa, hÆ programadores que gostam de usar um
carÆcter maiœsculo no primeiro carÆcter de cada palavra que compıe o identificador e os
restantes caracteres minœsculos. Nesse caso, devem designar pelo menos os nomes das
constantes em caracteres maiœsculos. Mas, o importante Ø que cada programador defina o
seu pr(cid:243)prio estilo, e que exista uma certa coerŒncia nas regras que adopte.

As palavras reservadas da linguagem C sªo: auto; break; case; char; const; continue;
default; do; double; else; enum; extern; float; for; goto; if; int; long; register; return;
short; signed; sizeof; static; struct; switch; typedef; union; unsigned; void; volatile; e
while. As palavras reservadas aparecem a cheio ao longo do texto e no c(cid:243)digo apresentado.

Para melhorar a legibilidade do programa, devem ser introduzidos comentÆrios relevantes,
que expliquem o significado dos diferentes objectos, ou que opera(cid:231)ªo Ø efectuada por
grupos bem definidos de instru(cid:231)ıes. Um comentÆrio Ø uma qualquer sequŒncia de
s(cid:237)mbolos inserida entre /* e */ e que nªo contenha */. Isto significa que nªo se pode
nunca encapsular comentÆrios. A Figura 1.5 apresenta a defini(cid:231)ªo formal do comentÆrio.

comentÆrio ::= /*qualquer sequŒncia de s(cid:237)mbolos que nªocontenha (cid:145)*/(cid:146) */

Figura 1.5 - Defini(cid:231)ªo formal do comentÆrio.
O uso adequado de comentÆrios melhora extraordinariamente a legibilidade e a
compreensªo de um segmento de c(cid:243)digo. Assim, devem introduzir-se comentÆrios, pelo
menos, nas situa(cid:231)ıes seguintes:
(cid:120) Em t(cid:237)tulo, para explicar o que faz o segmento de c(cid:243)digo e descrever, caso exista, o
mecanismo de comunica(cid:231)ªo associado.
(cid:120) Sempre que se declarem constantes ou variÆveis, para explicar o seu significado, a
menos que este seja trivial.
(cid:120) A encabe(cid:231)ar as por(cid:231)ıes de c(cid:243)digo correspondentes (cid:224) decomposi(cid:231)ªo algor(cid:237)tmica que lhe
deu origem.

1.4 Representa(cid:231)ªo da informa(cid:231)ªo
Em Pascal, os tipos de dados predefinidos estªo directamente relacionados com o tipo de
informa(cid:231)ªo neles armazenado. Assim, para informa(cid:231)ªo numØrica, existem os tipos inteiro
(integer) para a representa(cid:231)ªo exacta e real (real) para a representa(cid:231)ªo aproximada; para
quantidades l(cid:243)gicas existe o tipo booleano (boolean); e para a representa(cid:231)ªo de s(cid:237)mbolos
grÆficos existe o tipo carÆcter (char).

Em linguagem C, pelo contrÆrio, os tipos de dados predefinidos reflectem apenas o
formato de armazenamento. Sªo sempre tipos numØricos, embora em alguns casos
possibilitem uma interpreta(cid:231)ªo alternativa, fun(cid:231)ªo do contexto em que sªo usados.
7 CAP˝TULO 1 : INTRODU˙ˆO AO C

A Figura 1.6 apresenta os tipos de dados simples existentes na linguagem C. Estes tipos de
dados tambØm se designam por escalares, uma vez que, todos os seus valores estªo
distribu(cid:237)dos ao longo de uma escala linear. Dentro dos tipos de dados simples, temos o tipo
ponteiro (pointer), o tipo enumerado (enum) e os tipos aritmØticos, que se dividem em
tipos inteiros e tipos reais. Os tipos aritmØticos e o tipo enumerado designam-se por tipos
bÆsicos. Os tipos aritmØticos inteiros podem armazenar valores negativos e positivos, que Ø
o estado por defeito ou usando o qualificativo signed, ou em alternativa, podem
armazenar apenas valores positivos, usando para o efeito o qualificativo unsigned que lhe
duplica a gama din(cid:226)mica positiva. O tipo aritmØtico int pode ainda ser qualificado como
short, reduzindo-lhe a capacidade de armazenamento. O qualificativo long pode ser usado
para aumentar a capacidade de armazenamento do tipo inteiro int e do tipo real double.

Tipos de Dados Simples
Qualificativos
Ponteiro AritmØticos short
pointer
long
Tipos Inteiros Tipos Reais
signed
unsigned
int char float double Enumerado
enum
Tipos BÆsicos

Figura 1.6 - Tipos de dados simples existentes na linguagem C.

1.4.1 Tipos de dados inteiros
Na linguagem C existem os seguintes tipos de dados inteiros:
(cid:120) O tipo char permite a representa(cid:231)ªo de quantidades com sinal num byte e portanto,
permite armazenar valores entre -128 a 127.
(cid:120) O tipo unsigned char permite a representa(cid:231)ªo de quantidades sem sinal num byte e
portanto, permite armazenar valores entre 0 e 255.
(cid:120) O tipo short [int] permite a representa(cid:231)ªo de nœmeros negativos e positivos em 2 bytes e
portanto, permite armazenar valores entre -32768 e 32767.
(cid:120) O tipo unsigned short [int] permite a representa(cid:231)ªo de nœmeros positivos em 2 bytes e
portanto, permite armazenar valores entre 0 e 65535.
(cid:120) O tipo int permite a representa(cid:231)ªo de nœmeros negativos e positivos em 2 bytes ou 4
bytes, consoante o computador.
(cid:120) O tipo unsigned int permite a representa(cid:231)ªo de nœmeros positivos em 2 bytes ou 4 bytes,
consoante o computador.
(cid:120) O tipo long [int] permite a representa(cid:231)ªo de nœmeros negativos e positivos em 4 bytes
ou 8 bytes, consoante o computador.
(cid:120) O tipo unsigned long [int] permite a representa(cid:231)ªo de nœmeros positivos em 4 bytes ou
8 bytes, consoante o computador.
PROGRAMA˙ˆO ESTRUTURAS DE DADOS E ALGORITMOS EM C 8
O tamanho dos tipos inteiros int e long e a sua gama din(cid:226)mica dependem do compilador e
do hardware utilizados. Esta informa(cid:231)ªo Ø indicada no ficheiro limits.h localizado no
direct(cid:243)rio include do ambiente de desenvolvimento. No caso do computador utilizado nesta
disciplina, cujo processador Ø de 32 bits, os tipos int e unsigned int sªo representados em
4 bytes, pelo que, permitem armazenar respectivamente valores entre -2147483648 e
2147483647 e valores entre 0 e 4294967295. Os tipos long e unsigned long sªo tambØm
representados em 4 bytes.

1.4.2 Tipos de dados reais
Na linguagem C existem os seguintes tipos de dados reais: float; double; e long double. O
tamanho, a precisªo e a gama din(cid:226)mica dos tipos reais dependem do compilador e do
hardware utilizados. Esta informa(cid:231)ªo Ø indicada no ficheiro float.h localizado no direct(cid:243)rio
include do ambiente de desenvolvimento. Para o caso do computador utilizado nesta
disciplina, o tamanho, a precisªo e a gama din(cid:226)mica dos tipos reais sªo os seguintes:
(cid:120) O tipo float utiliza 4 bytes, o que permite armazenar valores entre 1.2x10-38 e 3.4x1038,
com uma mantissa de 6-7 algarismos significativos.
(cid:120) O tipo double utiliza 8 bytes, o que permite armazenar valores entre 2.2x10-308 e
1.8x10308, com uma mantissa de 15-16 algarismos significativos.
(cid:120) O tipo long double utiliza 12 bytes, o que permite armazenar valores entre 3.4x10-4932 e
1.2x104932, com uma mantissa de 18-19 algarismos significativos.

1.4.3 Representa(cid:231)ªo de caracteres e inteiros
A maioria das linguagens de programa(cid:231)ªo, entre as quais se inclui o Pascal, faz a distin(cid:231)ªo
entre o tipo inteiro e o tipo carÆcter. Mesmo, apesar de nessas linguagens, os caracteres
serem armazenados na mem(cid:243)ria em numØrico, usando para o efeito o c(cid:243)digo ASCII.

Na linguagem C nªo existe tal distin(cid:231)ªo. O tipo char que utiliza um byte permite armazenar
quer um carÆcter quer um valor inteiro. A Figura 1.7 apresenta dois exemplos que
exemplificam esta polivalŒncia. No primeiro caso a atribui(cid:231)ªo do valor 65, que Ø o c(cid:243)digo
ASCII do carÆcter A, Ø equivalente (cid:224) atribui(cid:231)ªo do pr(cid:243)prio carÆcter ’A’ (cid:224) variÆvel CAR. No
segundo caso a atribui(cid:231)ªo do valor 3 (cid:224) variÆvel NUM Ø diferente da atribui(cid:231)ªo (cid:224) variÆvel
CAR do carÆcter ’3’, cujo c(cid:243)digo ASCII Ø 51. Devido a esta polivalŒncia de interpreta(cid:231)ªo do
valor inteiro armazenado na variÆvel, o valor escrito no monitor depende do especificador
de formato que seja empregue na instru(cid:231)ªo de sa(cid:237)da de dados. O formato %d representa o
valor decimal, enquanto que o formato %c representa o carÆcter.

char CAR; /* declara(cid:231)ªo da variÆvel CAR de tipo char */
...
CAR = ’A’; /* ambas as atribui(cid:231)ıes armazenam */
CAR = 65; /* na posi(cid:231)ªo de mem(cid:243)ria CAR o valor 65 */
(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)(cid:326)
char NUM, CAR; /* declara(cid:231)ªo das variÆveis NUM e CAR de tipo char */
...
NUM = 3; /* armazena na posi(cid:231)ªo de mem(cid:243)ria NUM o valor 3 */
CAR = ’3’; /* armazena na posi(cid:231)ªo de mem(cid:243)ria CAR o valor 51 */

Figura 1.7 - Utiliza(cid:231)ªo do tipo char.