Lu´ıs Fernando de Oliveira 26 de maio de 2011

(1)

Linguagens de Programa¸c˜

ao C e C++: Uma

Introdu¸c˜

ao

Lu´ıs Fernando de Oliveira

(2)

(3)

Sum´

ario

1 Programa¸c˜ao em C e C++ 7

1.1 Aspectos B´asicos do C´odigo-Fonte em C . . . 7

1.2 Compiladores C e C++ . . . 9

1.3 Compila¸c˜ao dos C´odigos-fonte . . . 10

2 Tipos de Dados 13 2.1 Representa¸c˜ao de Dados na Mem´oria . . . 14

2.1.1 Representa¸c˜ao de N´umeros Inteiros . . . 15

2.1.2 Representa¸c˜ao de N´umeros Reais . . . 16

2.1.3 Tipos de Dados Representados . . . 17

2.1.4 Organiza¸c˜ao dos Dados na Mem´oria . . . 18

2.2 Tipos Definidos de Dado . . . 19

2.2.1 Tipo Literal: char . . . 19

2.2.2 Tipo Inteiro: char eint . . . 21

2.2.3 Tipo Real: float e double . . . 22

2.2.4 Tipo Indefinido: void . . . 23

2.2.5 Tipo L´ogico . . . 23

2.2.6 Modificadores de Tipo signed e unsigned . . . 24

2.2.7 Modificadores de Tipo short elong . . . 25

2.2.8 Type Casting . . . 26

2.2.9 Resumo dos Tipos intr´ınsecos . . . 27

2.3 Vetores, Matrizes eStrings . . . 27

2.3.1 Declara¸c˜ao de Vetores e Matrizes . . . 27

2.3.2 Cadeia de Caracteres (Strings) . . . 28

2.4 Tipos Abstratos de Dado . . . 29

2.4.1 Estruturas de Dados: struct . . . 29

2.4.2 Enumera¸c˜oes: enum . . . 32

2.4.3 Uni˜oes: union . . . 33

(4)

2.4.4 Campo de Bits . . . 34

2.4.5 Declara¸c˜aotypedef . . . 36

2.5 Ponteiros . . . 36

2.5.1 Ponteiros e Endere¸co de Mem´oria . . . 36

2.5.2 Declara¸c˜ao de Ponteiros . . . 38

2.5.3 Operador de Endere¸camento de Dado(&) . . . 39

2.5.4 Operador de Referenciamento de Dado (*) . . . 39

2.5.5 Operador de Referenciamento de Campo de Estrutura (->) . . . 40

2.5.6 Aritm´etica de Ponteiros . . . 41

2.5.7 Um Cuidado Mais Especial . . . 41

2.5.8 Rela¸c˜ao entre Ponteiros, Vetores e Matrizes . . . 42

2.5.9 Aloca¸c˜ao de Mem´oria para Ponteiros . . . 45

3 Operadores Matemáticos, Lógicos e Binários 47 3.1 Conversão de Tipo e Operador de Atribui¸cão . . . 47

3.2 Operadores Aritm´eticos . . . 50

3.3 Operadores Relacionais . . . 52

3.3.1 Operadores de Igualdade (==) e de Diferen¸ca (!=) . . 52

3.3.2 Operadores Maior (>) e Maior que (>=) . . . 52

3.3.3 Operadores Menor (<) e Menor que (<=) . . . 52

3.4 Operadores L´ogicos . . . 52

3.4.1 Operador de Conjun¸c˜ao: E L´ogico (&&) . . . 52

3.4.2 Operador de Disjun¸c˜ao: OU L´ogico (||) . . . 52

3.4.3 Operador de Nega¸c˜ao (!) . . . 52

3.5 Operadores Bin´arios . . . 52

3.5.1 Operador E Bin´ario (&) . . . 52

3.5.2 Operador OU Bin´ario (|) . . . 53

3.5.3 Operador OU EXCLUSIVO Bin´ario (ˆ) . . . 53

3.5.4 Operador de Nega¸c˜ao Bin´ario (∼) . . . 53

3.5.5 Operadores de Deslocamento Bin´ario (<< e>>) . . . 53

3.6 Operadores de Atribui¸c˜ao Concatenados . . . 53

3.6.1 Operador de Adi¸c˜ao (+=) . . . 53

3.6.2 Operador de Subtra¸c˜ao (-=) . . . 53

3.6.3 Operador de Multiplica¸c˜ao (*=) . . . 53

3.6.4 Operador de Divis˜ao (/=) . . . 53

3.6.5 Operador L´ogico E Bin´ario (&=) . . . 53

3.6.6 Operador L´ogico OU Bin´ario (|=) . . . 53

(5)

5

4 Estruturas de Controle de Execu¸c˜ao 55

4.1 Estruturas de Condi¸c˜ao . . . 55

4.1.1 Estrutura do Se . . . 55

4.1.2 Estrutura do Se Tern´ario . . . 57

4.1.3 Estrutura de Sele¸c˜ao de Caso . . . 58

4.2 Estruturas de Repeti¸c˜ao . . . 58

4.2.1 Estrutura de La¸co Definido . . . 58

4.2.2 Estrutura de La¸co Condicional . . . 60

5 Fun¸c˜oes 63 5.1 Argumentos por Valor e por Referˆencia . . . 64

5.2 Prot´otipo de uma Fun¸c˜ao . . . 66

5.3 Rela¸c˜ao das Fun¸c˜oes Intr´ınsecas . . . 67

5.4 Fun¸c˜oes de Entrada e Sa´ıda Padr˜oes . . . 74

6 Diretivas de Compila¸c˜ao 75 6.1 Diretiva #include . . . 75

6.2 Diretivas #define|#undef . . . 77

6.3 Diretivas #if–#elif–#else–#endif . . . 79

6.4 Diretivas #ifdef|#ifndef–#endif . . . 80

7 Organiza¸cão da Programa¸cão em C 85 8 Classes e Objetos 87 8.1 Encapsulamento de Atributos e Métodos . . . 88

8.2 Visibilidade de Implementa¸c˜ao . . . 89

8.3 Hierarquia de Classes e Hereditariedade . . . 91

8.4 Polimorfismo de M´etodos . . . 93

8.5 Objetos das Classes . . . 94

8.6 M´etodos Construtores e Destruidores . . . 95

8.7 Sobrecarga de Operadores . . . 98

(6)

(7)

1

Programa¸

c˜

ao em C e C++

1.1 Aspectos B´

asicos do C´

odigo-Fonte em C

Para come¸car, vejamos um exemplo de c´odigo-fonte simples em C para, depois, apresentarmos cada elemento componente dele.

C´odigo 1.1: exemplo1.c # include < stdlib .h >

# include < stdio .h > # include < string .h > # include < math .h >

int main (void) {

int a ;

float b , c ;

printf (" digite um valor inteiro : \ n ");

scanf (" % d ",& a );

b = 0.5; c = a + b ;

printf (" a soma deste valor com 0.5 eh : % f \ n ",c );

return 0; }

Um código-fonte em C é composto por instru¸cões de compila¸cão e instru¸cões de programa¸cão.

As instru¸cões de compila¸cão (ou diretivas de compila¸cão) iniciam com o s´ımbolo “#” e são direcionadas ao compilador. Elas não geram código

(8)

executável e somente têm efeito durante o processo de compila¸cão. Indicam a¸cões que o compilador deve executar ou modificam um comportamento es-pec´ıfico do compilador.

Asinstru¸cões de programa¸cão(tudo que não come¸ca com “#”) podem ser classificadas comocomandos de declara¸cãoecomandos de execu¸cão. Os comandos de declara¸cão são usados para definir variáveis, tipos de variáveis, estruturas de dados e fun¸cões. Os comandos de execu¸cão são as instru¸cões que serão efetivamente executadas pelo processador. Durante o processo de com-pila¸cão, estes comandos são traduzidos em uma linguagem intermediária, cha-mada de linguagem objeto (que não tem nada a ver com orienta¸cão a objeto) para depois, durante o processo de link-edi¸cão, ser convertida em linguagem de máquina.

Neste exemplo inicial, você pode ver todos estes tipos de instru¸cão. As quatro primeiras linhas de código (quatro diretivas #include) informam ao compilador que ele deve incluir, no processo de compila¸cão, quatro arquivos com extensão “.h” (chamados de arquivos de cabe¸calho, do inglêsheader files). Estes arquivos contêm os protótipos de fun¸cões intr´ınsecas da linguagem C e são usadas basicamente, durante o processo de compila¸cão, para verificar se as fun¸cões intr´ınsecas usadas no programa estão declaradas corretamente (sin-taxe da linguagem). Os arquivos de cabe¸calho não contém o código-fonte das fun¸cões, mas apenas as declara¸cões (protótipos). As fun¸cões em si estão dis-pon´ıveis na forma de bibliotecas pré-compiladas que acompanham a instala¸cão do compilador. Os arquivos de cabe¸calho, por assim dizer, funcionam como uma lista condensada com o nome das fun¸cões e seus respectivos argumentos. • O arquivostdlib.hcontém os protótipos das fun¸cões intr´ınsecas básicas. • O arquivostdio.h contém os protótipos das fun¸cões básicas de entrada

e sa´ıda de dados.

• O arquivostring.h contém os protótipos das fun¸cões básicas de mani-pula¸cão de strings (cadeia de caracteres).

• O arquivo math.h contém os protótipos das fun¸cões básicas de ma-temática.

Depois das diretivas de compila¸cão, encontramos as instru¸cões de pro-grama¸cão. A primeira instru¸cão é uma declara¸cão de fun¸cão: a fun¸cão int main(void). Esta é a fun¸cão principal das linguagens C e C++. Ela desem-penha um papel similar ao comando program do Fortran e do Pascal, isto é, define o ponto de entrada do programa executável. Pode faltar quase tudo num código-fonte em C e C++, mas não pode faltar a fun¸cãomain().

(9)

1.2. COMPILADORES C E C++ 9

Por que? Porque, sendo a linguagem C uma linguagem de programa¸cão es-truturada, as variáveis devem ser declaradas antes de serem usadas. Durante o processo de compila¸cão, as declara¸cões de variáveis são usadas para montar uma tabela de identificadores que deverão armazenar dados. Se uma variável é declarada duas vezes, o compilador tem como detectar o erro, pois o pro-cesso de compila¸cão tentará criar dois identificadores com os mesmos nomes. Se isso fosse feito depois de processar os comandos de execu¸cão, o compilador perderia o controle na identifica¸cão de que variável está sendo referenciada numa instru¸cão espec´ıfica. Então, declara¸cão de variável vem sempre antes dos comandos de execu¸cão, iniciando os blocos de instru¸cões.

Depois das declara¸cões de variáveis, vemos comandos de atribui¸cão, opera-¸cão aritmética, chamadas de fun¸cões e de retorno de dado.

Uma informa¸cão muito importante que deve ser levantada aqui, no in´ıcio do material sobre as linguagens C e C++, é que, em C e C++, não existe a declara¸cão formal de sub-rotina ou procedimento. Tudo em C e C++ é fun¸cão. O que irá definir se a fun¸cão se comportará como uma fun¸cão tradicional (que retorna um dado) ou como uma sub-rotina (que não possui retorno de informa¸cão através de opera¸cão de atribui¸cão) é o tipo da fun¸cão. Como será visto no cap´ıtulo 2 sobre tipos de dados, existe um tipo chamado de void que indica a ausência de tipo definido. Veja bem, não é “tipo indefinido”, é “ausência de tipo definido”. Então, uma fun¸cão declarada como sendo do tipo void não retorna dado, ou seja, comporta-se como uma sub-rotina. Outro uso do tipo void está na declara¸cão de fun¸cões que não precisam de argumentos (no nosso exemplo, a fun¸cãomain() é declarada com a palavra reservadavoid no lugar dos argumento. Isto significa que a fun¸cão main não recebe qualquer informa¸cão de fora do programa. Poderia ser diferente? Sim, poderia. Se o programador precisar passar dados para dentro da fun¸cão main, ele declara a lista de argumentos da forma tradicional: tipo do argumento e nome do argumento.

Agora que você já teve um primeiro contato com a linguagem, vamos falar um pouco do compilador e da compila¸cão.

1.2 Compiladores C e C++

(10)

Estes compiladores não possuem interfaces de desenvolvimento (as famosas IDE’s, do inglêsIntegrated Development Environment), mas aceitam que sejam instaladas a parte. As IDE’s para Windows mais famosas são o VisualC da Microsoft e oC++Buiderda CodeGear, ambos não gratuitos. No campo das IDE’s de código aberto, tanto para Windows como para Linux, existem alguns programas bons. Destacaria oCode::Blocksque tem versões para Windows e Linux. Outras duas IDE’s são: EclipseeNetBeans, que originalmente foram concebidas para a linguagem Java, mas possuem pacotes para as linguagens C e C++.

Para todos os efeitos, este material não tem a inten¸cão de for¸car nenhuma das IDE’s mencionadas, apenas determinar que os exemplos apresentados serão todos testados nos compiladoresgcc eg++. Fica ao cargo de cada um decidir se instala ou não uma IDE.

1.3 Compila¸c˜

ao dos C´

odigos-fonte

As linhas de comando dos compiladores s˜ao exatamente iguais `as usadas no Fortran (com of95 oug95 ougfortran):

• gcc:

– por etapas:

gcc -c <lista c´odigos fontes>

gcc -o <programa execut´avel><lista c´odigos objeto>

– forma resumida:

gcc -o <programa execut´avel><lista c´odigos fontes> • g++:

– por etapas:

g++ -c <lista c´odigos fontes>

g++ -o <programa execut´avel><lista c´odigos objeto>

– forma resumida:

g++ -o <programa execut´avel><lista c´odigos fontes>

(11)

1.3. COMPILAÇ ÃO DOS C ÓDIGOS-FONTE 11

Existe a forma reduzida de comando onde a compila¸cão e a link-edi¸cão são executadas sequencialmente. O resultado final é o mesmo em qualquer uma das duas op¸cões. A vantagem de se compilar por etapas se destaca quando o projeto que está sendo desenvolvido contém muitos arquivos de código. É sem-pre interessante compilar os arquivos separadamente para se ter um controle melhor sobre os erros. Quando se compila vários arquivos simultaneamente, a lista de erros pode ser tão grande que a manuten¸cão e corre¸cão dos erros fica prejudicada, além de desestimular.

Então, como a linguagem está montada sobre esta estrutura, vale olharmos para cada uma delas separadamente e com mais detalhes. Por isso, o material ficará organizado da seguinte forma:

• Cap´ıtulo 2: comandos de declara¸cão de variáveis, os tipos pré-definidos das linguagens, ponteiros, vetores e matrizes, tipos abstratos de dados. • Cap´ıtulo 3: comandos de execu¸cão referentes aos operadores algébricos,

relacionais, l´ogicos e bin´arios.

• Cap´ıtulo 4: comandos de execu¸cão condicionais se-senão, se ternário e sele¸cão de caso e de comandos de repeti¸cão para-de-até, repita-até e enquanto.

• Cap´ıtulo 5: comandos de declara¸cão de fun¸cões, passagem de argumentos e protótipos de fun¸cão.

• Cap´ıtulo 6: diretivas de compila¸c˜ao.

(12)

(13)

2

Tipos de Dados

Como em toda linguagem formal, a linguagem C possui tipos pr´e-definidos de dados (tipos intr´ınsecos) que podem ser classificados como:

• tipo literal (que armazena caracteres alfanum´ericos),

• tipo numérico inteiro (para dados numéricos dentro do conjunto dos números naturais positivos e negativos),

• tipo numérico real (próprio para os números racionais) e • tipo lógico (para o “falso” e “verdadeiro”).

E para que o programador tenha uma liberdade de cria¸cão, a linguagem C permite também a defini¸cão de novos tipos de dados – são os chamados tipos abstratos de dados. Dentre eles, encontram-se:

• os vetores e matrizes (tanto num´ericas como literais, as strings), • as estruturas de dados (na forma de registros e campos),

• as enumera¸cões (como listas ordenadas de constantes) e • as uniões (que permitem a superposi¸cão de estruturas).

Um tópico particular da linguagem C versa sobre os ponteiros, elemento este que distingui o C de todas as outras linguagens. Os ponteiros são uma ferramenta muito poderosa que permite ao programador trabalhar diretamente na memória do computador e descer a um n´ıvel mais baixo de programa¸cão (o que nem sempre é necessário). Para tanto, se faz necessário relembrar algumas caracter´ısticas de representa¸cão binária e organiza¸cão de dados na memória do computador. Isso facilitará a compreensão de recursos de programa¸cão em C tais como passagem de parâmetros por referência, declara¸cão de vetores e matrizes e aloca¸cão dinâmica de memória.

(14)

2.1 Representa¸c˜

ao de Dados na Mem´

oria

Todo dado deve estar armazenado em algum lugar no computador. O local mais provável é a memória RAM (do inglês random access memory). A arquitetura dos computadores não permite que os dados sejam armazenados usando a mesma representa¸cão gráfica que nós, humanos, usamos. Como todos devem recordar, os computadores só reconhecem dois tipos de informa¸cão: “ligado” e “desligado”. Para maior conforto nosso, as informa¸cões “ligado” e “desligado” podem ser representados como “falso” e “verdadeiro” ou 1 e 0, respectivamente. Ainda assim, representar uma informa¸cão complexa na forma de 0’s e 1’s não se traduz numa forma completamente confortável de leitura, pois não estamos acostumados a ver as coisas desta forma. Mas é muito importante que sejamos capazes de entender como um dado é armazenado na memória, pois isso interfere diretamente naquilo que estamos tentando fazer, ou seja, na programa¸cão.

Ent˜ao, de in´ıcio, vamos lembrar dos termos mais usuais, quais sejam: os bits, os bytes e seus prefixos de grandeza (quilo, mega, giga, tera, etc.).

bit (b): O bit é a menor informa¸cão representada no computador. Pode as-sumir dois valores distintos: 0 e 1. Eletronicamente corresponde às si-tua¸cões de: tem corrente, não tem corrente, ou tensão diferente de zero, tensão igual a zero. Da´ı a no¸cão de “ligado” e “desligado”.

byte (B): O byte é o agrupamento de 8 bits. Forma a menor “palavra” em computadores. Sua decodifica¸cão, ou seja, sua interpreta¸cão é obtida usando a base matemática binária. Os bytes podem ser concatenados formando palavras de 2 bytes (16 bits), 4 bytes (32 bits), 8 bytes (64 bits) e assim por diante. Repare que os agrupamentos são sempre em potência de 2 (uma vez que estamos usando nota¸cão binária).

kilobyte (kB): um kilobyte é o agrupamento de 1024 bytes. Este valor não é mágico; corresponde ao número 210_{; é a potência de 2 mais próxima do} valor decimal 1000 ou 103

.

megabyte (MB): um megabyte é o agrupamento de 10242 _bytes_{. Segue o} racioc´ınio de potência de 2 mais próximo a 106_.

gigabyte (GB): um gigabyte ´e o agrupamento de 10243 _bytes_.

terabyte (TB): um terabyte ´e o agrupamento de 10244 _bytes_.

petabyte (PB): um pentabyte ´e o agrupamento de 10245 _bytes_.

(15)

2.1. REPRESENTAÇ ÃO DE DADOS NA MEM ÓRIA 15

2.1.1 Representa¸c˜

ao de N´

umeros Inteiros

O conjunto de números naturais incorporam números positivos, negativos e nulo. Em binário, também se faz necessário representar este mesmo conjunto. Até aqui, o byte é apenas um agrupamento de 8 bits, sendo cada d´ıgito, 0 ou 1, valores compreendidos como positivos. Então, como representar um valor negativo?

Uma forma muito natural seria admitir o sinal “+” e “−” prefixando os números binários. Mas o computador só entende 0 e 1. Então, o jeito foi criar um padrão (internacional e aceito pela maioria das indústrias de componen-tes eletrônicos) que definisse a representa¸cão de números positivos e negati-vos em binário. Uma da agências internacionais que recomendam padrões é a IEEE (do inglês, Institute of Electrical and Electronic Engineering). Nas recomenda¸cões de representa¸cão de números binárias, consta que o bit mais significativo (abreviado em inglês para msb) do agrupamento de bytes, o bit mais a esquerda, pode ser interpretado como obit de sinal, seguindo a seguinte codifica¸cão:

• se o msb é 0, o número representado é positivo; • se o msb é 1, o número representado é negativo;

Neste padrão, pensando em um número com 1byte, o bit mais a esquerda, o msb, se torna o indicador de sinal. Sobram 7 bits então para representar os números propriamente ditos.

msb

b7 b6 b5 b4 b3 b2 b1 b0

Usando aritmética binária, 27_{vale 128. Se pusermos o}_bit _{de sinal na frente,} ter´ıamos 128 números positivos (desde o +0 até o +127) e 128 negativos (dede o −0 até o −127). Surge um problema: temos dois zeros, o +0 e o −0. Não faz sentido representarmos duas vezes o mesmo valor, até porque estar´ıamos desperdi¸cando capacidade computacional. Então, para superar esta dificul-dade, propôs-se um mecanismo de cálculo de números negativos chamado de cálculo por complemento a 2. Este mecanismo funciona assim: pegue a representa¸cão binário do número positivo; retire o bit de sinal; inverta cada bit da representa¸cão, isto é, troque os 0’s por 1’s e vice-versa (isto se chama cálculo de complemento a 1); adicione 1 ao resultado das inversões; acres-cente o digito 1 comomsb, obit de sinal; este novo resultado é a representa¸cão negativa do número positivo inicial.

(16)

separar obit de sinal – isso ajuda na visualiza¸cão da representa¸cão binária. A representa¸cão binária do número −9 será 1|1110111(b). O cálculo do número −9 é apresentado a seguir:

|0001001(b) → |1110110(b) /* complemento a 1 */

+ 1(b)

|1110111(b) /* complemento a 2 */

Então, o número −9 é 1|1110111(b). Este mecanismo pode ser aplicado a qualquer agrupamento debytes, sempre lembrando que obit de sinal é omsb, obit mais a esquerda do agrupamento.

Outros exemplos: o número binário 0|0000000(b) é o 0 decimal, 1|1111111(b) é o −1 e 1|0000000(b) é o número −128.

2.1.2 Representa¸c˜

ao de N´

umeros Reais

Um número real se difere do número inteiro por conta da parte fracionária. Os computadores, que só trabalham com 0’s e 1’s, precisam de alguma ou-tra forma de padroniza¸cão de representa¸cão para números reais. Da´ı que, novamente, a IEEE gerou uma outra recomenda¸cão. Os números reais são organizados na forma de mantissa e expoente. A mantissa do número real deve estar no intervalo 0,0 (fechado) e 1,0 (aberto). O expoente se refere a base 2. Assim, um número real, em binário, deve ser organizado na forma: mantissa×2expoente

. A IEEE sugere uma representa¸cão m´ınima para números reais com 4bytes de comprimento. Este é o chamado “número real de precisão simples”. Dos 4 bytes, o byte mais significativo é o expoente e os demais são a mantissa. O expoente e a mantissa possuem, cada um, um bit de sinal.

O formato binário de um número real usa o ponto decimal e cadabit após o ponto corresponde à uma potência de 2 com expoente negativo. Por exemplo: o número binário .1(b) corresponde ao número 1×2−₁

, isto é, 0,5 reais. O número 1|.11(b) vale−(1×2−1_{+ 1}_×₂−2_{), ou seja,} _−0,₅₋_0,_{25 =}_−0,_{75 reais.} O número

0|0000001 0|.1100000 00000000 00000000

vale 21_×₍₁_×₂−₁

+ 1×2−₂

) = 2×0,75 = 1,5, ou

0|0000000 0|1.100000 00000000 00000000

(17)

2.1. REPRESENTAÇ ÃO DE DADOS NA MEM ÓRIA 17

Por fim, a IEEE também recomenda um formato de dupla precisão para os números reais. Nele, o expoente tem 2 bytes e a mantissa tem 6 bytes. E se pode chegar até precisão quádrupla com 4 bytes para o expoente e 12bytes para a mantissa. Na prática, o maior formato para números reais usa 4 bytes para o expoente e 6 bytes para a mantissa.

2.1.3 Tipos de Dados Representados

Como foi visto, os números inteiros podem ser representados agrupando um ou maisbytes. Cada agrupamento pode conter números com limites distintos. Um número inteiro representado por 1 byte pode armazenar valores entre 0 e 28

−1 (= 255) se for sem sinal e entre −27

(= −128) e 27

−1 (= 127) se for com sinal. Se a representa¸c˜ao do n´umero inteiro utilizar 2 bytes, as faixas de valores aumentam: entre 0 e 216₋_{1 (= 65.535) para n´}_{umeros sem sinal e entre} −215

(=−32.768) e 215

−1 (= 32.767) para n´umeros com sinal.

Admitindo diferentes comprimentos em bytes para representa¸cão de n´ ume-ros inteiume-ros, cada linguagem de programa¸cão nomeia seus tipos de dados. Na linguagem C, os números inteiros são representados com tipos de dados que usam 1, 2 e 4 bytes de comprimento. Cada agrupamento recebe um nome diferente (um tipo diferente de inteiro). Além disso, existe a possibilidade de se “tipar” explicitamente, representa¸cões de números com e sem sinal. A linguagem C também permite essa situa¸cão.

Quanto aos números reais, as linguagem “tipificam” a precisão segundo a quantidade de d´ıgitos poss´ıveis para a parte fracionária em decimal. Existe a precisão simples, dupla e quádrupla. A linguagem C implementa estes três tipos de números reais.

Sobram, no rol dos tipos de dados que poderiam ser representados em computador por uma linguagem de programa¸cão, os dados lógicos e os literais. Algumas linguagens implementam os valores lógicosfalsoeverdadeiro. Não é o caso da linguagem C. Em C, “falso” é tudo que é igual a nulo e “verdadeiro” é tudo que for diferente de nulo. Como a base dos computadores é binária, 0 é falso e 1 é verdadeiro; 00000000(b) é falso e qualquer coisa diferente disso é verdadeiro.

(18)

2.1.4 Organiza¸c˜

ao dos Dados na Mem´

oria

Por fim, e não menos importante, quando um agrupamento debytes repre-sentando um número inteiro ou real é armazenado na memória do computador, o mesmo precisa reservar uma sequência cont´ınua de bytes para esta tarefa. A ordem com que os bytes componentes destes agrupamento são arranjados também precisa ser definido de alguma forma.

Durante muito tempo, esta ordem era definida pelo fabricante do dispo-sitivo (fosse ele um computador, um videogame, uma calculadora, um relógio digital ou qualquer outra coisa que usasse dados digitais). Com a populariza¸cão dos computadores, sua miniaturiza¸cão, seu barateamento e o aumento da com-plexidade das redes de computadores, fez-se necessário uma padroniza¸cão (que ainda não é admitida por todos). O padrão mais comum é armazenar dados a partir do byte menos significativo (abreviado em inglês como lsb) para o mais significativo (msb). Cada byte de um agrupamento (de um tipo de dado) é armazenado em um endere¸co de memória e o endere¸co dobyte menos significa-tivo é o que se chama de endere¸co base. A partir do endere¸co base, os demais bytes do dado são arranjados.

Numa linguagem de alto n´ıvel, quando o programador declara uma variável, ele está na verdade solicitando ao computador que localize um espa¸co de memória com um determinado comprimento em bytes (suficiente para arma-zenar o dado) e que associe o nome da variável ao endere¸co de memória onde o dado será armazenado. Quando o programador atribui um dado à variável, ele está na verdade solicitando ao computador para copiar o dado no endere¸co referente à variável declarada. O computador pega o dado, vê o nome da variável (que é um identificador), recupera o endere¸co associado à variável e transfere o dado para este endere¸co.

Na linguagem C, existe um “tipo” de dado chamado ponteiro que o diferen-cia de praticamente todas as outras linguagens (pelo menos as mais antigas). O ponteiro nada mais é do que o endere¸co de memória onde o dado está ou o endere¸co de memória referente a uma variável. Como endere¸co é um número inteiro e precisa ficar armazenado em algum lugar, a variável que armazena endere¸cos é dita ser do tipo “ponteiro”. Por que? Porque eleapontapara um endere¸co espec´ıfico da memória. Simples assim.

(19)

2.2. TIPOS DEFINIDOS DE DADO 19

2.2 Tipos Definidos de Dado

2.2.1 Tipo Literal:

char

O tipo de variável em C usado para armazenar caracteres se chama char. Este tipo tem comprimento de 1 byte e é equivalente ao tipo character do Fortran. Os caracteres válidos que podem ser associados as variáveischar são os caracteres da tabela ASCII.

O fragmento de código abaixo mostra a declara¸cão de duas variáveis char chamadas ch e letra. Estas variáveis serão preenchidas com as constantes literais ‘a’e ‘+’.

C´odigo 2.1: exemplo2.c

void main (void) {

char ch ;

char letra ;

ch = ’a ’;

letra = ’+ ’;

}

Como no Fortran, as variáveis podem ser inicializadas diretamente na de-clara¸cão de variável como a seguir:

void main (void) {

char ch = ’a ’;

char letra = ’+ ’;

}

Reparar que a constante literal é formada por um único carácter e que este é digitado entre apóstrofos.

(20)

constante ASCII

literal hexadecimal car´acter significado

\a 0x07 BEL beep

\b 0x08 BS backspace

\f 0x0c FF alimentador de folha

\n 0x0a LF alimentador de linha

\r 0x0d CR retorno de carrilh˜ao

\t 0x09 HT tabula¸c˜ao horizontal

\v 0x0b VT tabula¸c˜ao vertical

\\ 0x5c \ backslash

\’ 0x27 ’ ap´ostrofo

\” 0x22 ” aspas

\? 0x3f ? interroga¸c˜ao

Fora desta tabela, existe um outro carácter especial chamado NULL que é ‘\0’. Como seu nome diz, ele é um carácter nulo que corresponde ao valor zero. Ele será apresentado no tópico sobre ponteiros.

Para imprimir na tela o conteúdo de variáveis do tipo char quando o conteúdo é uma constante literal, usamos o seguinte comando:

printf("%c",/*variavel*/);

onde o código de formata¸cão “%c” indica que um carácter deverá ser impresso. E para que a fun¸cão printf() funcione corretamente, é necessário incluir a diretiva “#include <stdio.h>” no in´ıcio do código. Repetindo o exemplo2:

C´odigo 2.3: exemplo4a.c # include < stdio .h >

void main (void) {

char ch = ’a ’;

printf (" % c ", ch ); printf (" % c ", letra ); }

Para “quebrar” a linha após a impressão do conteúdo, pode-se incluir a constante literal “\n” na string de formata¸cão:

C´odigo 2.4: exemplo4b.c # include < stdio .h >

void main (void) {

(21)

printf (" % c % c \ n ",ch , letra ); }

2.2.2 Tipo Inteiro:

char

e

int

Em C, variáveis que armazenam valores inteiros são do tipo char e int. O tipo char é o mesmo usado para armazenar caracteres e, neste caso, o tipo character do Fortran não possui correspondência. Quando usado para armazenar valores inteiros, o tipochar pode assumir valores entre -128 e 127, que são os valores poss´ıveis para um número inteiro de 8bits, sendo um deles obit de sinal.

C´odigo 2.5: exemplo5.c # include < stdio .h >

void main (void) {

char x = -100;

char i = 54;

printf (" % d % d \ n ",x , i ); }

O código de controle de formata¸cão para impressão de um número inteiro é “%d”. Repare que mesmo a variável sendo do tipochar, o que será impresso na tela é o número inteiro armazenado na variável, mesmo que a variável tenha sido inicializada com uma constante literal:

C´odigo 2.6: exemplo5a.c # include < stdio .h >

void main (void) {

char x = ’a ’; char i = ’1 ’;

printf (" % d % d \ n ",x , i ); }

Neste exemplo, o compilador substitui as constantes literais pelos seus respec-tivos ´ındices na tabela ASCII: o ´ındice do carácter ‘a’ é 97 e do carácter ‘1’ é 49.

(22)

void main (void) {

int k = 10000 , a , h ;

a = -1234567; h = 8 5 7 4 8 4 0 3 ;

printf (" % d \ t % d \ t % d \ n ",k ,a , h ); }

A constante literal “\t” é responsável pela tabula¸cão da impressão. O padrão de tabula¸cão em C são 8 caracteres.

2.2.3 Tipo Real:

float

e

double

No Fortran, um número real de precisão simples recebe o nome de real. Em C, o número real de precisão simples é ofloat, que possui precisão de 7 d´ıgitos e 4 bytes de comprimento. Os valores limites do tipo float são ±3,4×10±38_.

void main (void) {

float f = 0 . 0 3 4 5 3 ; float x = 1.2 e -10; float y = -0.4356 e23 ; float z = 10;

printf (" %f , %f , %f , % f \ n ",f ,x ,y , z ); }

O código de controle de formata¸cão para o tipo float é “%f”. O número real é impresso na forma decimal. A questão é que nem sempre este estilo de formata¸cão é adequado à magnitude do número. O resultado do exemplo anterior é prova disto. Então, uma alternativa é imprimir o número real no formato de nota¸cão cient´ıfica. O código de formata¸cão é “%e”. Experimente trocar a formata¸cão no exemplo anterior para ver o efeito.

Além do tipo float, a linguagem C possui outro tipo de variável para ar-mazenar um número real com um número maior de d´ıgitos que é o double. Sua precisão é de 15 d´ıgitos e possui 64 bits (ou 8 bytes) de comprimento. Seus valores limites são±1,7×10±₃₀₈

(23)

void main (void) {

double G , k , g , Na ;

G = 6.672 e -11; /* c o n s t a n t e g r a v i t a c i o n a l */

k = 1.3807 e -23; /* c o n s t a n t e de B o l t z m a n n */

g = 9 . 8 0 6 6 5 ; /* g r a v i d a d e padrao */

Na = 6.0220 e23 ; /* numero de A v o g a d r o */

printf (" numero de A v o g a d r o = % lf \ n " " c o n s t a n t e de B o l t z m a n n = % lf \ n " " c o n s t a n t e g r a v i t a c i o n a l = % lf \ n " " g r a v i d a d e padrao = % lf \ n ",Na ,k ,G , g ); }

O código de controle de formata¸cão para o tipodouble é “%lf” (long float). Novamente, a formata¸cão pode não ser apropriada para a impressão do número em fun¸cão de sua magnitude. Experimente trocar “%lf” para “%g” que ajusta a formata¸cão automaticamente.

Repare que existem duas variáveis que usam a letragê, uma delas maiúscula G e a outra minúscula g. A linguagem C diferencia estes nomes de variáveis (identificadores), pois ela écase sensitive, ou seja, “sens´ıvel à caixa”. Portanto, as variáveis G e g são distintas.

2.2.4 Tipo Indefinido:

void

O tipovoid é algo que só existe na linguagem C. Ele representa a ausência de tipo pré-definido. Possui um comprimento de 4 bytes e pode ser usado para armazenar endere¸cos de memória se associado a um ponteiro (que será apresentado mais adiante). Sua aplica¸cão mais intensa se refere à defini¸cão de sub-rotinas que, em C, são fun¸cões que não retornam valores.

2.2.5 Tipo L´

ogico

Um dado do tipo lógico deve, por defini¸cão, assumir dois valores poss´ıveis: falso e verdadeiro. Em C, não existe um tipo lógico pré-definido como em Fortran (logical). Para reproduzir as caracter´ısticas de um tipo lógico, a lin-guagem C usa a seguinte regra: qualquer dado igual a zero é interpretado como o valor “falso” e, por oposi¸cão, qualquer coisa diferente de zero é considerado “verdadeiro”.

(24)

que está sendo executado pode ser desviado para uma posi¸cão espec´ıfica dentro do código. O teste lógico também está presente nas instru¸cões de repeti¸cão. O teste de parada pode usar uma variável lógica ou o resultado de uma expressão lógica para determinar se a itera¸cão prossegue ou para.

Tome os seguintes exemplos:

void main (void) {

char a = 0 , b = 1;

char c = ’ \0 ’, d = ’z ’;

int g = 0 , h = -100;

float f = 0 , r = 0.1 e -10; double x = 0 , y = 1e -30; }

Se os testes lógicos fossem realizados com as variáveis declaradas acima, os resultados dos testes para as variáveis a, c, g, f e x seriam “falso”. As demais variáveis retornariam “verdadeiro”, pois seus conteúdos são diferentes de zero (nulo). Isso ficará mais claro quando for tratado o tema sobre comandos condicionais.

2.2.6 Modificadores de Tipo

signed

e

unsigned

Duas palavras reservadas em C são usadas para controlar o uso ou não do bit de sinal em um número inteiro. Estas palavras sãosigned eunsigned. Toda variável inteira é, a princ´ıpio, uma variável inteira com sinal (usando-se ou não a palavrasigned). Se há a necessidade de se declarar uma variável inteira sem sinal, deve-se usar a palavra reservada unsigned antes da declara¸cão do tipo (somente os tiposchar eint aceitam o prefixosigned eunsigned). Em Fortran, não há equivalência para este mecanismo.

Uma variável declarada como unsigned char aceita valores entre 0 e 255 e uma variável do tipo unsigned int assume valores entre 0 e 4.294.967.295. Se uma variável for declarada comounsigned (sem a declara¸cãoint), o compilador entende que a variável declarada é do tipo unsigned int. Exemplo:

void main (void) {

char r ; /* 1 byte com sinal */

u n s i g n e d char t ; /* 1 byte sem sinal */

int i ; /* 4 bytes com sinal */

u n s i g n e d j ; /* 4 bytes sem sinal */

(25)

" sizeof ( int )=% d \ nsizeof ( u n s i g n e d )=% d \ n ", sizeof(char) ,sizeof(u n s i g n e d char) ,

sizeof(int) ,sizeof(u n s i g n e d)); }

A fun¸c˜ao sizeof(tipo) retorna o comprimento em bytes do tipo passado como argumento.

Caberia uma pergunta aqui que seria a seguinte: o que acontece quando se declara uma vari´avel char, por exemplo, e associa-se um valor maior que 127 a ela?

void main (void) {

char ch = 129; /* ? */

printf (" % d \ n ", ch ); }

Para responder isto, é necessário analisar o byte que representa a variável ch. O número 129(d) em binário é 10000001(b). Mas o bit mais significativo (msb: most significant bit), que é o bit mais a esquerda, é o bit de sinal. Por-tanto, o processador entende que este número é um número negativo. Para descobrir que número negativo é este, é necessário calcular-se o complemento a dois dele.

|0000001(b) → |1111110(b) /* complemento a 1 */

+ 1(b)

|1111111(b) /* complemento a 2 */

O número binário |1111111(b) é o decimal 127(d). Portanto, o computador entenderá internamente que “char ch = 129;” é, na verdade, “char ch = -127;”.

2.2.7 Modificadores de Tipo

short

e

long

(26)

de bytes de comprimento que o tipo int, isto é, 4 bytes. Portanto, pode ar-mazenar valores entre -2.147.483.648 e 2.147.483.647. A linguagem C aceita a declara¸cão de variáveis usando-se somente as palavras reservadasshort elong. Ela entende que as variáveis serão do tiposhort int elong int respectivamente, mas esta não é uma boa regra de programa¸cão.

O tipo double também admite o modificador long. Uma variável do tipo long double pode assumir valores com precisão ou amplitudes muito grandes (±3,37×10±4932_{). Ela possui um comprimento de 80} _bits _{(ou 10} _bytes_{) com} 18 d´ıgitos de precisão.

Os compiladores Fortran possuem um mecanismo que permite definir o comprimento de uma variável inteira, mas este mecanismo não é padronizado. Alguns compiladores aceitam a declara¸cão integer*8 como um inteiro de 8 bytes, outros declaram integer 8, e há aqueles que defineminteger(8). Substi-tuindo o número 8 por 4 ou 2, seria poss´ıvel declarar-se variáveis inteiras com 4 ou 2bytes respectivamente.

2.2.8 Type Casting

Type casting é um mecanismo de conversão de tipos que nada mais é que colocar um dos tipos predefinidos (char, int, float, double, short, long, un-signed e assim por diante) entre parênteses na frente da variável a ter o tipo convertido. Veja que esta opera¸cão não muda o tipo da variável, mas somente o seu conteúdo no momento de uma associa¸cão. Veja o seguinte exemplo:

void main (void) {

char c ; int i ;

float f =200.0;

i = (int) f ; /* C o n v e r t e r 200.0 para inteiro

s i g n i f i c a truncar a parte decimal . */

c = (char) f ; /* Aqui , alem do numero 200.0 ser

truncado , pois o tipo char so aceita n´umeros inteiros , o numero 200

u l t r a p a s s a o limite de r e p r e s e n t a c a o do char . Logo , o n´umero 200 sera i n t e r p r e t a d o como -56. */

(27)

2.3. VETORES, MATRIZES E STRINGS 27

2.2.9 Resumo dos Tipos intr´ınsecos

Tipo bits Faixa de valores

unsigned char 8 0 : 255

char 8 −128 : 127

short int 16 −32.768 : 32.767

unsigned short int 16 0 : 65.535 unsigned int 32 0 : 4.294.967.295

int 32 −2.147.483.648 : 2.147.483.647 unsigned long int 32 0 : 4.294.967.295

long int 32 −2.147.483.648 : 2.147.483.647

float 32 ±3,4×10±₃₈

double 64 ±1,7×10±308

long double 80 ±3,4×10±4932

2.3 Vetores, Matrizes e

Strings

2.3.1 Declara¸c˜

ao de Vetores e Matrizes

Os vetores e matrizes são sequências cont´ınuas de um mesmo tipo de variável cujos elementos individuais podem ser acessados através de ´ındices. Em C, um vetor é declarado definindo-se o seu tipo de variável e o nome do vetor seguido de sua dimensão:

void main (void) {

u n s i g n e d v_int [100]; /* Tipo : u n s i g n e d int Nome : v_int

D i m e n s ~a o : 100 e l e m e n t o s . */

}

Uma matriz é declarada da mesma forma: tipo, nome da variável e suas dimensões. Mas cada dimensão é apresentada individualmente entre colchetes:

void main (void) {

double dmat [ 1 0 ] [ 1 0 ] ; /* Tipo : double Nome : dmat

D i m e n s ~a o : 10 x10 . */

}

(28)

vetor e da matriz é sua dimensão menos 1. Para os exemplos apresentados, os elementos v int[99] e dmat[9][9] são os elementos finais do vetor e da matriz, respectivamente.

Teoricamente, não há limite no dimensionamento das matrizes. Isto signi-fica que se poderia criar matrizes N dimensionais com N tendendo a infinito. Lógico que isso é um exagero, mas fica a ideia de poder-se criar matrizes com dimensões muito grandes. O maior limitante é a quantidade de memória dis-pon´ıvel. Para se calcular a quantidade de memória ocupada por um vetor ou matriz, basta multiplicar as dimensões da estrutura (vetor ou matriz) pelo total de bytes correspondente ao tipo de dado que define a estrutura. Então, o vetorv int com 100 elementos ocupa 100×4 bytes ou 400 bytes. A matriz dmat ocupa 10×10×8bytes ou 800 bytes de memória.

2.3.2 Cadeia de Caracteres (

Strings

)

As cadeias de caracteres (strings) em Fortran são declaradas usando-se o tipocharacter e a palavra reservada len. O len define o comprimento total de caracteres que a cadeia pode assumir. Em C, o tipochar é usado para declarar a cadeira de caracteres, que não é mais que um vetor de caracteres. E como vetor, sua declara¸cão em C é igual à usada em qualquer outra situa¸cão:

void main (void) {

/* duas strings : frase e palavra . */

char frase [100] , palavra [30];

}

Astringfrase pode conter até 100 caracteres e palavra, 30; O que diferencia o C do Fortran é a utiliza¸cão do carácter NULL como terminador do vetor. Em Fortran, se umastring chamada “palavra” for declarada com comprimento 30 e contiver a palavra “paralelepipedo” (14 caracteres), os 16 caracteres res-tantes continuam fazendo parte da string. Caso ela seja impressa na tela do computador, através do comando “write(unit=*,fmt=“(a)”) palavra”, os 30 caracteres serão impressos. Para eliminar os 6 caracteres restantes, é preciso usar a fun¸cão “trim(palavra)”.

Em C, o carácter que indica o fim dastring é o NULL. No exemplo acima, se o vetor palavra[30] contiver a palavra “paralelepipedo”, o décimo quinto carácter, ou seja, palavra[14], será o carácter NULL.

(29)

2.4. TIPOS ABSTRATOS DE DADO 29

Veja que o nome da string (que é um vetor) é um ponteiro. Portanto, a fun¸cão “printf( )” recebe um ponteiro contendo o in´ıcio da string e come¸ca imprimindo na tela a sequência de caracteres até encontrar oNULL. Enquanto a fun¸cão não encontrar oNULL, ela continuará imprimindo. Mas o importante aqui não é a fun¸cão “printf()”, mas a importância do carácter terminador NULL e que o programador deve sempre prever que um dos caracteres de sua string será ele, ou seja, ele terá que somar 1 no comprimento da string. Sempre. Para armazenar a palavra “paralelepipedo”, ele deve usar no m´ınimo 15 caracteres (14 letras mais o NULL).

Se o programador quiser concatenar duas palavras, a string que receberá a união das duas deverá ter, no m´ınimo, a soma dos comprimentos delas mais 1. Uma string nula, isto é, sem caracteres (“”), deve ter pelo menos um byte de comprimento, para acomodar o carácterNULL.

Duas fun¸cões em C que são muito úteis na manipula¸cão de strings são: “strcpy( )” e “strlen()”. A fun¸cão “strcpy( )” usa dois argumentos: um pon-teiro que aponta para a área de memória que contém a string e outro que aponta para o endere¸co de destino. A fun¸cão “strlen()” retorna o total de caracteres que compõem uma string, passada como argumento, exclusive o terminador NULL. O exemplo a seguir mostra como copiar a string “parale-lepipedo” para o vetor palavra:

strcpy(palavra,‘‘paralelepipedo’’);

2.4 Tipos Abstratos de Dado

2.4.1 Estruturas de Dados:

struct

O Fortran e o C estabelecem um mecanismo de constru¸cão de tipos mais complexos que os intr´ınsecos através de agrupamentos (campos) em estruturas de dados. Uma situa¸cão t´ıpica de aplica¸cão de estrutura de dados é a cria¸cão de bancos de dados. Normalmente, deseja-se cadastrar pessoas agrupando, de alguma forma, seus dados de identifica¸cão, tais como: nome completo, identidade, endere¸co, profissão, etc.

A palavra reservada em C que define uma estrutura ´estruct. Por exemplo, se o programador deseja criar uma estrutura chamada “tDadosPessoais” e que contenha os campos nome, identidade e endere¸co, ele deveria escrever o seguinte fragmento de c´odigo:

(30)

Repare que a declara¸cão struct termina com o ponto e v´ırgula. Para se de-finir uma variável deste novo tipo de dado, o procedimento é similar a defini¸cão de variáveis de qualquer outro tipo:

struct tDadosPessoais Usuario; /* variavel: Usu´ario

tipo : struct tDadosPessoais */ struct tDadosPessoais Funcionario;

/* variavel: Funcionario

tipo : struct tDadosPessoais */ struct tDadosPessoais Biblioteca;

/* variavel: Biblioteca

tipo : struct tDadosPessoais */

Para preencher qualquer um dos campos de uma estrutura em C, é ne-cessário utilizar o operador ‘.’ (ponto). Este operador indica o acesso a um determinado campo da estrutura. Por exemplo: um determinado funcionário tem identidade 9871234. O código completo seria:

void main (void) {

struct t D a d o s P e s s o a i s {

char nome [256];

char e n d e r e c o [256];

int i d e n t i d a d e ; };

struct t D a d o s P e s s o a i s F u n c i o n a r i o ;

/* tipo : struct t D a d o s P e s s o a i s v a r i a v e l : F u n c i o n a r i o */

F u n c i o n a r i o . i d e n t i d a d e = 9 8 7 1 2 3 4 ;

/* le - se : campo i d e n t i d a d e da v a r i a v e l F u n c i o n a r i o */

}

Pode-se criar um vetor de estruturas simplesmente adicionando-se a di-mensão do vetor após o nome da variável estrutura:

void main (void) {

/* d e c l a r a c a o da e s t r u t u r a */

char nome [256];

(31)

/* d e c l a r a c a o do vetor de e s t r u t u r a Usuario com 1000 e n t r a d a s */

struct t D a d o s P e s s o a i s Usuario [1000];

/* usuario de ´ı n d i c e 0 */

strcpy ( Usuario [0]. nome ," Joao das Neves ");

strcpy ( Usuario [0]. endereco ," Av . Atlantida , 100/101 ");

Usuario [0]. i d e n t i d a d e = 1234;

/* usuario de indice 100 */

strcpy ( Usuario [100]. nome ," P a t r i c i a Araujo ");

strcpy ( Usuario [100]. endereco ," R . Xavier , 312/708 ");

strcpy ( Usuario [12]. nome ," Carlos P a r r e i r a ");

strcpy ( Usuario [12]. endereco ," R . Da Cruz , casa 100 ");

/* ultima entrada de um vetor de 1000 p o s i c o e s */

strcpy ( Usuario [999]. nome ," Raquel de Queiroz ");

strcpy ( Usuario [999]. endereco ," R . Paiva , 3 9 8 / 1 1 0 2 "); Usuario [999]. i d e n t i d a d e = 4444;

}

A linguagem C permite algumas simplifica¸cões muito úteis para o progra-mador no que se refere a declara¸cão de variáveis de estrutura. A principal é a declara¸cão da estrutura propriamente dita combinada à declara¸cão das variáveis. Por exemplo:

void main (void) {

/* d e c l a r a c a o da e s t r u t u r a c o m b i n a d a a d e c l a r a c a o das v a r i a v e i s */

char nome [256];

int i d e n t i d a d e ;

} Usuario [1000] , F u n c i o n a r i o ;

strcpy ( Usuario [0]. nome ," Joao das Neves ");

strcpy ( Usuario [0]. endereco ," Av . Atlantida , 100/101 ");

(32)

F u n c i o n a r i o . i d e n t i d a d e = 9 8 7 1 2 3 4 ;

strcpy ( F u n c i o n a r i o . endereco ," R . S . F r a n c i s c o " " Xavier , 524 "); strcpy ( F u n c i o n a r i o . nome ," Piquet C a r n e i r o Jr . "); }

A declara¸cão das variáveis segue a declara¸cão dos campos da estrutura.

2.4.2 Enumera¸c˜

oes:

enum

As enumera¸cões são agrupamentos de “constantes” associadas à números inteiros. Por exemplo:

enum Posicao { PARA_CIMA, PARA_BAIXO,

PARA_ESQUERDA, PARA_DIREITA };

Nesta declara¸cão de enumera¸cão, a constante PARA CIMA é vista pelo com-pilador como o número 0. As constantes PARA BAIXO, PARA ES-QUERDA e PARA DIREITA são interpretadas como os números 1, 2 e 3 respectivamente. O papel principal das enumera¸cões é facilitar a rotula¸cão de determinados números que tenham um significado especial. E a enumera¸cão impede que uma variável do tipo enumera¸cão assuma outros valores que não tenham sido declarados na enumera¸cão.

O mecanismo para declarar uma vari´avel do tipo enum Posicao´e similar ao de uma estrutura:

enum Posicao posicao;

A variável posicao pode assumir qualquer um dos valores pré-definidos para oenum Posicao. Veja o trecho de código a seguir:

void main (void) {

/* d e c l a r a c a o da e n u m e r a c a o */

enum Posicao { PARA_CIMA , PARA_BAIXO ,

PARA_ESQUERDA , P A R A _ D I R E I T A };

/* d e c l a r a c a o das v a r i a v e i s do tipo e n u m e r a c a o */

enum Posicao posicao , situacao , comando ;

(33)

2.4.3 Uni˜

oes:

union

As uniões (unions) são estruturas onde os campos compartilham o mesmo espa¸co da memória, isto é, os campos que compõem a união estão “superpos-tos”. Por exemplo, uma união que define dois campos: uma variável do tipo int e um vetor de 4 elementos do tipo unsigned char.

union char4int {

unsigned char c[4]; int i;

};

A declara¸cão de variáveis do tipo união segue o mesmo modelo das de-clara¸cões de variáveis de estruturas. No exemplo a seguir, a variável Byte4 está sendo declarada como sendo do tipo union char4int. Para preencher o campo i de variável Byte4, usa-se o operador ‘.’.

void main (void) {

/* d e c l a r a c a o da uniao */

union c h a r 4 i n t {

u n s i g n e d char c [4]; int i ;

};

/* d e c l a r a c a o da v a r i a v e l */

union c h a r 4 i n t Byte4 ;

/* a c e s s a n d o o campo ’i ’ da uniao */

Byte4 . i = 0 x 0 1 2 0 0 8 0 3 ; /* h e x a d e c i m a l */

/* i m p r e s s a o do c o n t e u d o do vetor ’c ’ como numeros h e x a d e c i m a i s */

printf (" % x \ t % x \ t % x \ t % x \ n ",

Byte4 . c [0] , Byte4 . c [1] , Byte4 . c [2] , Byte4 . c [3]); }

O código de formata¸cão “%x” imprime um número inteiro na forma de um número hexadecimal. Desta forma, fica mais fácil conferir o conteúdo de cada byte de dado da estrutura.

(34)

Endere¸co Mem´oria Vari´avel

0x1a3c20 0x03 c[0]

0x08 c[1] 0x20 c[2] 0x01 c[3]            i 0x1a3c24

Na memória, obyte menos significativo é o primeiro a ser escrito: 0x03. O próximo byte é 0x08, o terceiro, 0x20 e o quarto, o mais significativo, 0x01. Repare que c[0] coincide com o byte menos significativo. c[1] coincide com o segundo, c[2] com o terceiro ec[3] com o quarto.

2.4.4 Campo de Bits

O campo de bits é um recurso provavelmente exclusivo da linguagem C. Tem por sintaxe a forma de uma estrutura, mas cada campo declarado dentro dela refere-se a uma sequência de bits que pode variar de 1 até o limite de 32 bits. O tipo de cada entrada na estrutura de campo de bits deve ser do tipo unsigned, pois o elementobit não tem sinal. Por exemplo:

struct CampoBits {

/* bit identificado por b0 tem 1 bit de comprimento. */ unsigned b0:1;

/* o mesmo vale para o bit declarado como b1. */ unsigned b1:1;

/* o campo b2_3 tem comprimento de 2 bits. */

unsigned b2_3:2;

/* e o campo b4_7 tem comprimento de 4 bits. */

unsigned b4_7:4; };

No exemplo acima, a estrutura CampoBits declara quatro agrupamentos de bits: dois com 1 bit de comprimento (b0 e b1), um com dois bits (b2 3) e um com quatro (b4 7). Repare que o total debits da estrutura é 8 que equivale a uma variável char. O acesso a cada bit é tratado de forma natural como de qualquer outra estrutura:

void main (void) {

struct C a m p o B i t s {

u n s i g n e d b0 :1; /* 0 ,1 */

(35)

u n s i g n e d b2_3 :2; /* 0..3 */

u n s i g n e d b4_7 :4; /* 0..15 */

};

struct C a m p o B i t s bits ;

bits . b0 = 0; bits . b1 = 1;

bits . b2_3 = 2; /* 2 decimal em binario ´e 10. */

bits . b4_7 = 6; /* 6 decimal em binario ´e 0110. */

Se o campo debits for utilizado dentro de uma uni˜ao, cria-se a possibilidade de se converter n´umeros declarados “binariamente” em decimais e vice-versa. ´

E interessante perceber que o campo de bits é muito apropriado para gera¸cão de “máscaras” (muito utilizado quando se precisa acessar o hardware e tes-tar/acionar bits individualmente).

void main (void) {

struct C a m p o B i t s { u n s i g n e d b0 :1; u n s i g n e d b1 :1; u n s i g n e d b2_3 :2; u n s i g n e d b4_7 :4; };

union S t a t u s M o u s e {

/* o campo de bits e a v a r i a v e l u n s i g n e d char */ /* c o m p a r t i l h a m a mesma area da memoria . */

struct C a m p o B i t s bits ; u n s i g n e d char ch ;

};

union S t a t u s M o u s e sm ;

sm . ch = 12;

/* 12 em binario ´e 0 0 0 0 1 1 0 0 . O bit b0 eh o */ /* mais a direita e os bits de b4_7 , os mais */ /* a e s q u e r d a . Portanto , b0 ´e 0 , b1 eh 0 , */ /* b2_3 eh 3 (11 em binario eh 3 decimal ) , e */ /* b4_7 eh 0 (0000 binario ). */

}

(36)

bit b1 (o mecanismo que liga o bit b0 e o bit b1 ao status do mouse n˜ao est´a mostrado; assuma que exista um mecanismo que fa¸ca isso).

2.4.5 Declara¸c˜

ao

typedef

typedef é uma palavra reservada da linguagem C que simplifica a declara¸cão de estruturas, uniões, enumera¸cões e campos de bits. Através do typedef, declara-se formalmente o nome de novos tipos. A sintaxe dotypedef é simples:

/* cria - se a e s t r u t u r a M e u C a d a s t r o . */

struct M e u C a d a s t r o {

char nome [256];

u n s i g n e d t e l e f o n e ; };

/* defini - se o novo tipo para struct M e u C a d a s t r o como sendo s i m p l e s m e n t e C a d a s t r o . */

typedef struct M e u C a d a s t r o C a d a s t r o ;

void main (void) {

/* vetor de 100 e l e m e n t o s do tipo C a d a s t r o ( que ´e , na verdade , struct M e u C a d a s t r o ). */

C a d a s t r o cad [100]; }

Sem o typedef, a linha struct MeuCadastro Cadastro estaria criando uma variável Cadastro do tipo struct MeuCadastro. Com o typedef, o compilador entende que Cadastro é o novo nome de struct MeuCadastro. Cadastroé muito mais compacto que struct MeuCadastro.

2.5 Ponteiros

Dada a importância e a frequência com que os ponteiros são utilizados em C, este “tipo” único de dado, que é t´ıpico do C e de umas poucas outras lin-guagens, será apresentado de forma cuidadosa nesta se¸cão. Antecipando uma informa¸cão crucial, os ponteiros estão intimamente relacionados aos vetores e matrizes.

2.5.1 Ponteiros e Endere¸co de Mem´

oria

(37)

2.5. PONTEIROS 37

ele sabe que a sua variável será alocada em algum endere¸co na memória do computador. O programador não precisa, a princ´ıpio, saber o endere¸co da variável para fazer sua lógica funcionar ou armazenar um dado; o computador é que faz o papel de relacionar o nome da variável com o endere¸co no qual ela foi alocada, e “copiar para” ou “ler de” lá os dados.

Para facilitar a visualiza¸cão do mecanismo de funcionamento dos ponteiros, imagine a memória do computador como uma grande pilha de caixas onde cada uma possui um endere¸co espec´ıfico e um byte de comprimento. Quando o pro-gramador declara uma variável e executa o programa (depois da compila¸cão), o computador associa uma dessas caixas com o como da variável; é como se o nome da variável e o endere¸co na memória fossem sinônimos. Quando o pro-gramador acessa uma variável, é o endere¸co dela que o computador enxerga. Quando o programador lê ou escreve um dado na variável, o computador lê ou escreve este dado na caixa correspondente à variável. A figura abaixo irá ajudar.

char ch1, ch2;

ch1 = 10; ch2 = 2*ch1;

0x1100 10 ch1

0x1101 20 ch2

Pela figura, a variável ch1foi alocada na memória no endere¸co 0x1100 e a variávelch2no endere¸co 0x1101. Quando a linha de instru¸cão “ch1 = 10;” é executada, o computador copia o número 10 no endere¸co da variável ch1, ou seja, no endere¸co 0x1100.

(38)

int i1, i2;

0x1100 i1

0x1104 i2

0x1107 0x1108

Vejamos um outro exemplo agora usando variáveis do tipo int que tem 4 bytes de comprimento. Quando o programador declara uma variável do tipo int, ele está solicitando ao computador que reserve 4 bytes cont´ıguos na memória para serem usados no armazenamento de números inteiros. O computador irá, novamente, associar um endere¸co de memória ao nome da variável. O endere¸co associado é o endere¸co do primeiro byte dos quatro que formam o número inteiro, o endere¸co base (veja a figura anterior).

Se o programador declara duas variáveisint,i1ei2, o computador reserva 4 bytes para cada uma delas. A variável i1 é alocada no endere¸co 0x1100. A variáveli2só poderá ser alocada 4bytesdepois. Isto significa que seu endere¸co de memória será 0x1104. Além disso, qualquer outra variável que tiver de ser alocada na memória, só poderá estar a partir do endere¸co 0x1108, uma vez que o byte do endere¸co 0x1107 ainda faz parte da variável i2.

A rela¸cão entre uma variável e seu endere¸co é biun´ıvoca, de um para um: toda variável possui um endere¸co espec´ıfico, assim como todo endere¸co corres-ponde a uma variável.

2.5.2 Declara¸c˜

ao de Ponteiros

A variável ponteiro é declarada a partir de um dos tipos válidos em C, isto é, é válido declarar ponteiros para: char, unsigned char, short, unsigned short, int, unsigned, long, unsigned long, float, double e long double. O compilador reconhece como defini¸cão de ponteiro a declara¸cão de uma variável de qualquer um destes tipos válidos precedido de um asterisco ‘*’. Por exemplo, o fragmento de código abaixo declara variáveis ponteiro para cada um dos tipos válidos (os nomes das variáveis foram escolhidos arbitrariamente).

char *ch;

unsigned char *uch;

(39)

2.5. PONTEIROS 39

unsigned short *usi; /* mesmo que ‘unsigned short int’ */

int *i;

unsigned *ui; /* mesmo que ‘unsigned int’ */

long *li; /* mesmo que ‘long int’ */

unsigned long *uli; /* mesmo que ‘unsigned long int’ */

float *flt;

double *dbl;

long double *ldbl;

Duas vari´aveis ponteiro do mesmo tipo podem ser declaradas na mesma linha:

unsigned char *ch1, *ch2;

As variáveis ponteiros ocupam 4bytesde memória, independente do tipo de dado apontado. O conteúdo da variável ponteiro é um endere¸co de memória. Qualquer endere¸co de memória é um número inteiro, positivo e sem sinal. Se o computador é de 32 bits, a variável ponteiro tem 32 bits de comprimento (4 bytes). Caso o computador seja de 64 bits, as variáveis ponteiros ocuparão 8 bytes cada. Nos exemplos apresentados nesta se¸cão, será assumido um com-putador de 32 bits.

2.5.3 Operador de Endere¸camento de Dado(&)

Um ponteiro pode receber um endere¸co de memória explicitamente (digi-tado pelo programador ou declarado como constante numérica) ou receber o endere¸co de uma variável através do operador ‘&’. Este operador é usado na frente da variável que se deseja extrair o endere¸co. Por exemplo:

int *iptr, i; /* iptr é um ponteiro para int e i é uma variável do tipo int. */

iptr = &i; /* iptr recebe o endere¸co

da vari´avel i. */

´

E importante manter a coerência entre tipos de ponteiros e tipos de variáveis que estão retornando endere¸co. Ponteiros do tipo int recebem endere¸cos de variáveis do tipoint; ponteiros do tipo double recebem endere¸cos de variáveis do tipo double e assim por diante.

2.5.4 Operador de Referenciamento de Dado (*)

(40)

pela variável ponteiro, é necessário usar-se o operador ‘*’ antes do ponteiro. O fragmento de código a seguir mostra o procedimento e a figura auxilia na visualiza¸cão da memória:

char i1, *iptr, i2;

i1 = 20; iptr = &i1; i2 = *iptr;

0x1a3c22 20 i1

0x1a3c23 0x22 iptr 0x3c

0x1a 0x0

0x1a3c27 20 i2

Quando o código é executado, o computador encontra inicialmente a de-clara¸cão de três variáveis: i1, iptr e i2. Ele aloca as variáveis, na ordem de declara¸cão, em espa¸cos da memória. Suponha que a variável i1 seja alocada no endere¸co 0x1a3c22, a variável ponteiro iptr fique no endere¸co 0x1a3c23 e a variáveli2 fique em 0x1a3c27. As variáveisi1 ei2 ocupam 1 byte cada. Já a variáveliptr, por ser um ponteiro, ocupa 4 bytes da memória.

Uma vez criadas as variáveis, a primeira instru¸cão executada é copiar o número 20 na variável i1. Depois, copiar o endere¸co de i1 em iptr. iptr recebe então o endere¸co 0x1a3c22. Por fim, copiar o dado apontado pelo endere¸co contido emiptr para a variável i2, ou seja, o número 20.

2.5.5 Operador de Referenciamento de Campo de

Es-trutura (-

>

)

Quando uma estrutura ´e associada a um ponteiro, seus campos s˜ao aces-sados substituindo os operadores ‘.’ pelos operadores ‘->’. Por exemplo:

struct DadosPessoais { char nome[100]; char matricula; };

struct DadosPessoais Cadastro[1000], *ficha;

/* endere¸co do cent´esimo elemento. */ ficha = &(Cadastro[99]);

/* equivalente a: Cadastro[99].matricula = 5234542; */ ficha->matricula = 5234542;

/* idem: Cadastro[99].nome, ... */

(41)

2.5. PONTEIROS 41

A aplica¸cão de ponteiros com estruturas é mais intensa quando o programa a ser implementado envolve banco de dados e as estruturas apontam para outras estruturas. É normal que o espa¸co ocupado por uma estrutura seja grande comparado com o espa¸co de um ponteiro. Nestas situa¸cões, é mais econômico e mais eficiente fazer-se referência ao endere¸co a estrutura que uma cópia desta.

2.5.6 Aritm´

etica de Ponteiros

Os endere¸cos de memória são números inteiros sem sinal. Uma vez ar-mazenados em ponteiros, estes endere¸cos podem ser incrementados ou decre-mentados. Mas o incremento de uma unidade no endere¸co de memória pode não corresponder ao endere¸co do próximo byte. O número de bytes corres-pondente ao incremento (ou decremento) de uma unidade depende do tipo do ponteiro. Assim, se o ponteiro é do tipo char ou unsigned char, somar ou subtrair uma unidade de um endere¸co significa somar ou subtrair 1 byte. Se o ponteiro é um short int ou um unsigned short int, a unidade corresponde a 2 bytes. Se o ponteiro é do tipo int, unsigned int ou long int e o endere¸co de memória é incrementado (ou decrementado) de uma unidade, esta unidade corresponderá a 4bytes. Portanto, a unidade somada ou subtra´ıda de um en-dere¸co de memória corresponde ao comprimento do tipo, em bytes, associado ao ponteiro. A tabela abaixo resume a correspondência entre o tipo associado ao ponteiro e o número de bytes acrescido ao endere¸co de memória quando se soma uma unidade a este.

tipo apontado bytes unsigned char 1

char 1

short int 2

unsigned int 4

int 4

unsigned long 4

long 4

float 4

double 8

long double 10

2.5.7 Um Cuidado Mais Especial

´

(42)

dos ponteiros e outro que n˜ao, o melhor ´e optar por perder um pouco mais de tempo de desenvolvimento e controlar de forma mais r´ıgida os ponteiros.

Em termos práticos, cuidar da inicializa¸cão dos ponteiros significa iniciá-los com algum endere¸co “inofensivo” ou pré-estabelecido. Dentre os milhões de endere¸cos válidos, o endere¸co 0x0 (em hexadecimal) é o melhor, pois a maioria dos sistemas operacionais “sabe” que escrever no endere¸co 0 é errado. Con-sequentemente, o sistema operacional gera uma mensagem de erro abortando o programa. Em C, este endere¸co 0 é representado pelo carácter NULL, que já foi mencionado no tópico sobre variáveis do tipo char. A inicializa¸cão do ponteiro com NULL é simples e direto:

char *cptr = NULL; double *dptr = NULL; unsigned *uiptr = NULL;

Se o programador compilar seu programa e depois executá-lo, e, em algum instante, receber uma mensagem de erro por referência indevida a um endere¸co de memória, ele deve desconfiar que algum ponteiro em seu programa ainda esteja com o endere¸co NULL.

O perigo real é que as a¸cões do sistema operacional (ejetar CD, desligar o computador, formatar o HD, etc) são fun¸cões que estão na memória e tem um endere¸co de in´ıcio. Se, por um azar do destino, um ponteiro não inicializado contiver o endere¸co de entrada da fun¸cão que formata o HD e este ponteiro for usado, o sistema operacional pode “entender” que o programador esteja querendo formatar seu HD. E a´ı ... No melhor das hipóteses, o computador irá travar ou reiniciar. Mas se o programa estiver rodando em um supercom-putador junto de dezenas de outros programas, reiniciar o comsupercom-putador pode não ser uma boa.

2.5.8 Rela¸c˜

ao entre Ponteiros, Vetores e Matrizes

Existe uma rela¸cão muito estreita entre os vetores, matrizes e ponteiros. O nome de um vetor e de uma matriz (sem o ´ındice de um elemento) é um ponteiro. Nos exemplos apresentados acima,v intedmatsão ponteiros do tipo unsigned edouble, respectivamente, e armazenam os endere¸cos onde come¸cam o vetor e a matriz. Logo, para recuperar estes endere¸cos, não é necessário usar o operador ‘&’. Só se usa este operador com vetores e matrizes se o programador deseja descobrir o endere¸co de um elemento individualmente (referenciado por seus ´ındices). Por exemplo:

char cvet[3], *cptr1, *cptr2;

(43)

2.5. PONTEIROS 43

copiado para cptr1. */ cptr2 = &(cvet[2]); /* o endere¸co do terceiro

elemento do vetor cvet ´

e copiado para cptr2. */

Os endere¸cos iniciais do vetor e da matriz correspondem aos endere¸cos dos primeiros elementos do vetor e da matriz, respectivamente. No exemplo apresentado, o endere¸co contido em cvet é o mesmo obtido com o comando “&(cvet[0])”. Na figura da memória, assumindo o vetor cvet iniciando no endere¸co 0x1a3c26, seus elementos e demais variáveis ficam dispostos da se-guinte forma:

0x1a3c22 0x26 cvet 0x3c

0x1a 0x0

0x1a3c26 -1 cvet[0]

0x1a3c27 2 cvet[1]

0x1a3c28 100 cvet[2] 0x1a3c29 0x26 cptr1

0x3c 0x1a 0x1a3c2c 0x0

0x1a3c2d cptr2

0x1a3c2d 0x28 cptr2 0x3c

0x1a 0x0

Para acessar um elemento do vetor ou da matriz, basta referenci´a-lo pelo ´ındice:

cvet[0] = 5; /* copiando o n´umero 5 para o primeiro elemento de cvet. */

(44)

char c[4], ch;

/* acesso direto ao terceiro elemento do vetor c. */

ch = c[2];

/* acesso indireto ao terceiro elemento do vetor c atrav´es de aritm´etica de ponteiros. */

ch = *(c+2);

0x1a3c22 0x26 c

0x3c 0x1a 0x0

0x1a3c26 6 c[0]

0x1a3c27 20 c[1]

0x1a3c28 -47 c[2] 0x1a3c29 -55 c[3]

0x1a3c2a -47 ch

Assumindo que os elementos do vetor c come¸cam no endere¸co 0x1a3c26, o resultado da soma do ´ındice 2 com este endere¸co gera o endere¸co 0x1a3c28 que ´e o endere¸co do elemento c[2]. Por isso, o dado apontado por c+2, ou seja, *(c+2), e o elemento c[2]s˜ao os mesmos OBRIGATORIAMENTE! Veja que isto funciona para todos os elementos do vetor!

c[0] <-> *(c+0) = *c c[1] <-> *(c+1) c[2] <-> *(c+2) c[3] <-> *(c+3)

A organiza¸c˜ao de uma matriz ´e mais sofisticada e exige mais tempo para ser compreendida.

A matriz é um vetor de ponteiros que contêm os endere¸cos dos dados. Acompanhe o seguinte exemplo: uma matriz m do tipo char com dimensão 2× 2. A declara¸cão da matriz m pode ser vista no fragmento de código a seguir:

char m[2][2];

m[0][0] = 6; m[1][1] = -55; m[1][0] = -47; m[0][1] = 20;