Linguagem C

(1)

Linguagem de

programac

¸˜

ao C

Universidade do Estado do Rio de Janeiro Centro de Tecnologia e Ciˆencias

Instituto de F´ısica

(2)

(3)

Sum´

ario

1 Introduc¸˜ao 1

1.1 Aspectos b´asicos do c´odigo-fonte em C . . . 1

1.2 Compiladores C e C++ . . . 4

1.3 Compilação dos códigos-fonte . . . 5

2 Tipos de dados 7 2.1 Representação de Dados na Memória . . . 8

2.1.1 Representação de Números Inteiros. . . 9

2.1.2 Representação de Números Reais . . . 11

2.1.3 Tipos de Dados Representados . . . 11

2.1.4 Organização dos Dados na Memória . . . 12

2.2 Tipos Definidos de Dado . . . 14

2.2.1 Tipo Literal: char . . . 14

2.2.2 Tipo Inteiro: char e int . . . 17

2.2.3 Tipo Real: float e double . . . 18

2.2.4 Tipo Indefinido: void . . . 20

2.2.5 Tipo L´ogico . . . 20

2.2.6 Modificadores de Tipo signed e unsigned . . . 21

2.2.7 Modificadores de Tipo short e long . . . 22

2.2.8 Type Casting . . . 23

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

2.3 Vetores, Matrizes e Strings . . . 24

2.3.1 Declarac¸˜ao de Vetores e Matrizes . . . 24

2.3.2 Cadeia de Caracteres (Strings) . . . 25

(4)

2.4 Tipos Abstratos de Dado . . . 27

2.4.1 Estruturas de Dados: struct . . . 27

2.4.2 Enumerac¸˜oes: enum . . . 30

2.4.3 Uni˜oes: union . . . 31

2.4.4 Campo de Bits . . . 33

2.4.5 Declarac¸˜ao typedef . . . 35

2.5 Ponteiros . . . 36

2.5.1 Ponteiros e Enderec¸o de Mem´oria . . . 36

2.5.2 Declarac¸˜ao de Ponteiros . . . 38

2.5.3 Operador de Enderec¸amento 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 Relac¸˜ao entre Ponteiros, Vetores e Matrizes . . . 42

2.5.9 Alocação de Memória para Ponteiros . . . 46

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

3.2 Operadores Aritm´eticos . . . 50

3.3 Operadores Relacionais . . . 53

3.3.1 Operadores de Igualdade (==) e de Diferenc¸a (!=) . . . 53

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

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

3.4 Operadores L´ogicos . . . 53

3.4.1 Operador de Conjunção: E Lógico (&&) . . . 53

3.4.2 Operador de Disjunção: OU Lógico (||) . . . 53

3.4.3 Operador de Negac¸˜ao (!) . . . 53

3.5 Operadores Bin´arios . . . 53

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

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

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

(5)

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

3.6 Operadores de Atribuic¸˜ao Concatenados . . . 54

3.6.1 Operador de Adic¸˜ao (+=) . . . 54

3.6.2 Operador de Subtrac¸˜ao (-=) . . . 54

3.6.3 Operador de Multiplicac¸˜ao (*=) . . . 54

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

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

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

3.6.7 Operador L´ogico OU EXCLUSIVO Bin´ario (ˆ=) . . . 55

3.6.8 Operadores de Deslocamento Bin´ario (<<= e >>=) . . . 55

4 Estruturas de Controle de Execução 57 4.1 Estruturas de Condição. . . 57

4.1.1 Estrutura do Se . . . 57

4.1.2 Estrutura do Se Tern´ario . . . 59

4.1.3 Estrutura de Selec¸˜ao de Caso . . . 60

4.2 Estruturas de Repetic¸˜ao . . . 61

4.2.1 Estrutura de Lac¸o Definido. . . 61

4.2.2 Estrutura de Lac¸o Condicional. . . 63

5 Funções 65 5.1 Argumentos por Valor e por Referência . . . 67

5.2 Protótipo de uma Função . . . 69

5.3 Relação das Funções Intr´ınsecas . . . 70

5.4 Funções de Entrada e Sa´ıda Padrões . . . 79

6 Diretivas de Compilac¸˜ao 81 6.1 Diretiva #include . . . 81

6.2 Diretivas #define|#undef . . . 83

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

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

(6)

(7)

Lista de Figuras

2.1 Tabela ASCII de valores literais. . . 14

(8)

(9)

Introduc

¸˜

ao

1.1 Aspectos b´

asicos do c´

odigo-fonte em C

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

C´odigo 1.1: exemplo1.c # i n c l u d e < s t d l i b . h > # i n c l u d e < s t d i o . h > # i n c l u d e < s t r i n g . h > # i n c l u d e < m a t h . h > int m a i n (v o i d) { int a ; f l o a t b , c ; p r i n t f (" d i g i t e um v a l o r i n t e i r o : \ n "); s c a n f (" % d ",& a ); b = 0 . 5 ; c = a + b ; p r i n t f (" a s o m a d e s t e v a l o r com 0.5 eh : % f \ n ", c ); 1

(10)

r e t u r n 0; }

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

Asinstruções de compilação (ou diretivas de compilação) iniciam com o s´ımbolo “#” e são direcionadas ao compilador. Elas não geram código executável e somente têm efeito durante o processo de compilação. Indicam ações que o compilador deve executar ou modificam um comportamento espec´ıfico do compilador.

Asinstruções de programação (tudo que não começa com “#”) podem ser clas-sificadas como comandos de declaração e comandos de execução. Os comandos de declaração são usados para definir variáveis, tipos de variáveis, estruturas de dados e funções. Os comandos de execução são as instruções que serão efetivamente executadas pelo processador. Durante o processo de compilação, estes comandos são traduzidos em uma linguagem intermediária, chamada de linguagem objeto (que não tem nada a ver com orientaç˜ao a objeto) para depois, durante o processo de link-ediç˜ao, ser convertida em linguagem de máquina.

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

• O arquivo stdlib.h contém os protótipos das funções intr´ınsecas básicas.

• O arquivo stdio.h contém os protótipos das funções básicas de entrada e sa´ıda de dados.

(11)

strings (cadeia de caracteres).

• O arquivo math.h contém os protótipos das funções básicas de matemática. Depois das diretivas de compilação, encontramos as instruções de programação. A primeira instrução é uma declaração de função: a função int main(void). Esta ´

e a função principal das linguagens C e C++. Ela desempenha um papel similar ao comando program do Fortran e do Pascal, isto ´e, 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ç˜ao main().

Dentro da funç˜ao main(), encontramos as declaraç˜oes de variáveis e os comandos de execução. As variáveis são declaradas sempre no in´ıcio da codificação de um bloco de instruções (delimitado pelos s´ımbolos “{” e “}”). Por que? Porque, sendo a linguagem C uma linguagem de programação estruturada, as variáveis devem ser declaradas antes de serem usadas. Durante o processo de compilação, as declarações de variáveis são usa-das 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 processo de compilação tentará criar dois identificadores com os mesmos nomes. Se isso fosse feito depois de processar os comandos de execução, o compilador perderia o controle na identificação de que variável está sendo referenciada numa instrução espec´ıfica. Então, declaração de variável vem sempre antes dos comandos de execução, iniciando os blocos de instruções.

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

Uma informação muito importante que deve ser levantada aqui, no in´ıcio do mate-rial sobre as linguagens C e C++, é que, em C e C++, não existe a declaração formal de sub-rotina ou procedimento. Tudo em C e C++ é função. O que irá definir se a função se comportará como uma função tradicional (que retorna um dado) ou como uma sub-rotina (que não possui retorno de informação através de operação de atribuição) é o tipo da função. Como será visto no cap´ıtulo2sobre tipos de dados, existe um tipo cha-mado de void que indica a ausˆencia de tipo definido. Veja bem, não é “tipo indefinido”, é “ausência de tipo definido”. Então, uma funç˜ao declarada como sendo do tipo void n˜ao retorna dado, ou seja, comporta-se como uma sub-rotina. Outro uso do tipo void est´a na declaração de funções que não precisam de argumentos (no nosso exemplo, a função

(12)

main() é declarada com a palavra reservada void no lugar dos argumento. Isto significa que a funç˜ao main n˜ao recebe qualquer informação de fora do programa. Poderia ser diferente? Sim, poderia. Se o programador precisar passar dados para dentro da funçã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ção.

1.2 Compiladores C e C++

Existem diversos compiladores C e C++. Pensando em compiladores de acesso

livre, os mais usados s˜ao os compilares GNU gcc para a linguagem C e GNU g++

para a linguagem C++. Ambos os compiladores possuem vers˜oes para Windows,

Ma-cOS e Linux. No ambiente Linux, estes compiladores são padrão e já vem com a instalação da distribuição do sistema operacional. Caso não estejam instalados, é só acessar o repositório de programas da distribuição e instalá-los. Para Windows, existem as distribuiçõesMinGW e CygWin, ambos gratuitos.

Estes compiladores não possuem interfaces de desenvolvimento (as famosas IDE’s, do inglˆes Integrated Development Environment), mas aceitam que sejam instaladas a parte. As IDE’s para Windows mais famosas são oVisualC da Microsoft e o C++Buider da 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::Blocks que tem versões para Windows e Linux. Outras duas IDE’s são:Eclipse e NetBeans, 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ção de forçar nenhuma das IDE’s mencionadas, apenas determinar que os exemplos apresentados serão todos tes-tados nos compiladores gcc e g++. Fica ao cargo de cada um decidir se instala ou n˜ao uma IDE.

(13)

1.3 Compilac

¸˜

ao dos c´

odigos-fonte

As linhas de comando dos compiladores s˜ao exatamente iguais `as usadas no For-tran (com o f95 ou g95 ou gforFor-tran):

• 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>

Os arquivos de código fonte em C usam a extensão “.c” e os arquivos de código fonte em C++ usam a extensão “.cpp” ou “.C”. No processo de compilaç˜ao (gcc -c ou

g++ -c), os c´odigos fontes dão origem aos arquivos objeto cujas extensões são “.o”. No processo de link-edição (gcc -o ou g++ -o), todos os arquivos objeto gerados na compilação são processados para gerar o programa executável.

Existe a forma reduzida de comando onde a compilaç˜ao e a link-ediç˜ao são execu-tadas sequencialmente. O resultado final é o mesmo em qualquer uma das duas opções. A vantagem de se compilar por etapas se destaca quando o projeto que está sendo de-senvolvido contém muitos arquivos de código. É sempre interessante compilar os arqui-vos 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ção e correção dos erros fica prejudicada, além de desestimular.

(14)

Ent˜ao, como a linguagem est´a montada sobre esta estrutura, vale olharmos para cada uma delas separadamente e com mais detalhes.

Outro detalhe é a codificação dos exemplos. Vai acontecer dos exemplos conterem elementos (instruções) que não tenham sido apresentados formalmente ainda, em espe-cial as diretivas de compilação. Mas, a intenção é que os exemplos possam ser copiados e testados. No tempo certo, as dúvidas serão sanadas. Portanto, mãos à obra.

(15)

Tipos de dados

Como em toda linguagem formal, a linguagem C possui tipos pr´e-definidos de dados, ou tipos intr´ınsecos, que s˜ao definidos 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); • tipo lógico (para o “falso” e “verdadeiro”).

• tipo ponteiro (relacionado aos enderec¸os de dados na mem´oria).

Cada um destes tipos intr´ınsecos pode ser usado para a declaração de dados escala-res (um único valor por dado) ou dados ordenados (vários valores por dado, ordenados através de ´ındices).

E para que o programador tenha uma liberdade de criação, a linguagem C permite também a definição de novos tipos de dados a partir da abstração dos tipos intr´ınsecos que s˜ao os tipos derivados. Dentre eles, encontram-se:

• as estruturas de dados; • as enumerações; • as uniões.

(16)

Um tópico particular da linguagem C versa sobre osponteiros, 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 computa-dor e descer a um n´ıvel mais baixo de programação (o que nem sempre é necessário). Para tanto, se faz necessário relembrar algumas caracter´ısticas de representação binária e organização de dados na memória do computador. Isso facilitará a compreensão de recursos de programação em C tais como passagem de parâmetros por referência, declaração de vetores e matrizes e alocação dinâmica de memória.

2.1 Representac

¸˜

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ˆes random access memory). A arquitetura dos com-putadores não permite que os dados sejam armazenados usando a mesma representação gráfica que nós, humanos, usamos. Como todos devem recordar, os computadores só re-conhecem dois tipos de informação: “ligado” e “desligado”. Para maior conforto nosso, as informações “ligado” e “desligado” podem ser representados como “falso” e “verda-deiro” ou 1 e 0, respectivamente. Ainda assim, representar uma informaçã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çã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 ´e a menor informação representada no computador. Pode assumir dois va-lores distintos: 0 e 1. Eletronicamente corresponde às situações de: tem corrente, não tem corrente, ou tensão diferente de zero, tensão igual a zero. Da´ı a noção de “ligado” e “desligado”.

byte (B): O byte ´e o agrupamento de 8 bits. Forma a menor “palavra” em computadores. Sua decodificação, ou seja, sua interpretação é obtida usando a base matemática bin´aria. Os bytes podem ser concatenados formando palavras de 2 bytes (16 bits),

(17)

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ção binária). kilobyte (kB): um kilobyte ´e o agrupamento de 1024 bytes. Este valor não é mágico;

corresponde ao n´umero 210_{; ´}_{e a potˆ}_{encia de 2 mais pr´}_{oxima do valor decimal 1000}

ou 103_.

megabyte (MB): um megabyte ´e o agrupamento de 10242 _{bytes. Segue o racioc´ınio de}

potˆencia de 2 mais pr´oximo 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.

exabyte (EB): um exabyte ´e o agrupamento de 10246 _bytes.

e por a´ı vai...

2.1.1 Representação de Números 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´e aqui, o byte ´

e apenas um agrupamento de 8 bits, sendo cada d´ıgito, 0 ou 1, valores compreendidos como positivos. Ent˜ao, 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 (inter-nacional e aceito pela maioria das indústrias de componentes eletrônicos) que definisse a representação de números positivos e negativos em binário. Uma da agências interna-cionais que recomendam padrões é a IEEE (do inglˆes, Institute of Electrical and Electronic

Engineering). Nas recomendac¸ões de representação de números binárias, consta que o

bit mais significativo (abreviado em inglˆes para msb) do agrupamento de bytes, o bit mais a esquerda, pode ser interpretado como o bit de sinal, seguindo a seguinte codificac¸˜ao:

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

(18)

Neste padr˜ao, pensando em um n´umero com 1 byte, o bit mais a esquerda, o

msb, se torna o indicador de sinal. Sobram 7 bits ent˜ao para representar os n´umeros propriamente ditos.

msb

b7 b6 b5 b4 b3 b2 b1 b0

Usando aritm´etica bin´aria, 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çando capaci-dade computacional. Então, para superar esta dificuldade, propôs-se um mecanismo de cálculo de números negativos chamado decálculo por complemento a 2. Este meca-nismo funciona assim: pegue a representação binário do n´umero positivo; retire o bit de sinal; inverta cada bit da representaç˜ao, isto é, troque os 0’s por 1’s e vice-versa (isto se chamacálculo de complemento a 1); adicione 1 ao resultado das inversões; acrescente o digito 1 como msb, o bit de sinal; este novo resultado ´e a representação negativa do número positivo inicial.

Um exemplo: o número +9 em binário é 0|0001001(b). Colocamos o sufixo “(b)” para lembrarmos que o número está em binário e o car´acter “|” para separar o bit de sinal – isso ajuda na visualização da representação binária. A representaçã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 qual-quer agrupamento de bytes, sempre lembrando que o bit de sinal é o msb, o bit 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.

(19)

2.1.2 Representação de Números 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 outra forma de padronização de representação para números reais. Da´ı que, novamente, a IEEE1gerou uma outra recomendação. Os números reais são organizados na forma de mantissa

e expoente. A mantissa do n´umero 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ç˜}_{ao m´ınima}

para n´umeros reais com 4 bytes de comprimento. Este ´e o chamado “n´umero real de precis˜ao simples”. Dos 4 bytes, o byte mais significativo ´e o expoente e os demais s˜ao a mantissa. O expoente e a mantissa possuem, cada um, um bit de sinal.

O formato binário de um n´umero real usa o ponto decimal e cada bit ap´os 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−1_{, isto ´}_{e, 0, 5 reais. O n´}_{umero 1|.11(b) vale}

−(1 × 2−1+ 1 × 2−2), ou seja, −0, 5 − 0, 25 = −0, 75 reais. O n´umero 0|0000001 0|.1100000 00000000 00000000 vale 21_{× (1 × 2}−1_{+ 1 × 2}−2_{) = 2 × 0, 75 = 1, 5, ou}

0|0000000 0|1.100000 00000000 00000000

O d´ıgito 1 antes do ponto é uma unidade e o d´ıgito 1 após o ponto corresponde a 0, 5. Logo, este numerão também vale 1, 5 reais e o expoente corresponde, na prática, ao deslocamento de todos os bits para a direita ou esquerda, dependendo o sinal do expoente. Neste caso, como o expoente é positivo, o deslocamento é para a esquerda.

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´e precisão qu´adrupla com 4 bytes para o expoente e 12 bytes para a mantissa. Na pr´atica, o maior formato para n´umeros 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´umeros inteiros podem ser representados agrupando um ou mais bytes. Cada agrupamento pode conter n´umeros com limites distintos. Um n´umero

(20)

inteiro representado por 1 byte pode armazenar valores entre 0 e 28_{− 1 (= 255) se for}

sem sinal e entre −27 _{(= −128) e 2}7_{− 1 (= 127) se for com sinal. Se a representac¸˜}_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 2}15_{− 1 (= 32.767) para}

n´umeros com sinal.

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

Quanto aos números reais, as linguagem “tipificam” a precisão segundo a quanti-dade 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ção, os dados lógicos e os literais. Algumas linguagens implementam os valores lógicosfalso e verdadeiro. 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.

E os dados literais (caracteres), estes são codificados segundo um padrão inter-nacional chamado ASCII (que é a abreviatura de uma organização de padronização americana). Cada carácter é indexado na tabela ASCII. Logo, quando a linguagem C (e provavelmente muitas outras) precisa armazenar um carácter, ela armazena o ´ındice do car´acter. Como a tabela ASCII tem 256 caracteres, uma palavra de 8 bits ´e suficiente para acessá-la completamente. Então, os caracteres em C são representados por um tipo de dado com 1 byte de comprimento.

2.1.4 Organização dos Dados na Memória

Por fim, e n˜ao menos importante, quando um agrupamento de bytes represen-tando um número inteiro ou real é armazenado na memória do computador, o mesmo precisa reservar uma sequˆencia cont´ınua de bytes para esta tarefa. A ordem com que os

(21)

bytes componentes destes agrupamento s˜ao arranjados tamb´em precisa ser definido de alguma forma.

Durante muito tempo, esta ordem era definida pelo fabricante do dispositivo (fosse ele um computador, um videogame, uma calculadora, um rel´ogio digital ou qualquer outra coisa que usasse dados digitais). Com a popularização dos computadores, sua miniaturização, seu barateamento e o aumento da complexidade das redes de compu-tadores, fez-se necessário uma padronização (que ainda não é admitida por todos). O padrão mais comum ´e armazenar dados a partir do byte menos significativo (abreviado em inglˆes como lsb) para o mais significativo (msb). Cada byte de um agrupamento (de um tipo de dado) é armazenado em um endereço de mem´oria e o endereço do byte menos significativo é o que se chama de endereço base. A partir do endereço base, os demais bytes do dado s˜ao 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ço de memória com um determinado comprimento em bytes (suficiente para armazenar o dado) e que associe o nome da variável ao endereço 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ço referente à variável declarada. O computador pega o dado, vê o nome da variável (que é um identificador), recupera o endereço associado à variável e transfere o dado para este endereço.

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

Serão apresentados, nas seções seguintes, os nomes formais dos tipos de dados definidos pela linguagem C. Você deve reparar que cada tipo de dado tem um compri-mento diferente em bytes. Ser˜ao apresentados os tipos intr´ınsecos, ou seja, pré-definidos, os ponteiros, os vetores e matrizes e os tipos de dados que o usuário pode elaborar. A linguagem C é muito versátil, permitindo ao programador uma liberdade de trabalho muito grande como poderá ser constatado.

(22)

2.2 Tipos Definidos de Dado

2.2.1 Tipo Literal: char

O tipo de vari´avel em C usado para armazenar caracteres se chama char. Este tipo tem comprimento de 1 byte e ´e equivalente ao tipo character do Fortran. Os caracteres v´alidos que podem ser associados as vari´aveis char s˜ao os caracteres da tabela ASCII (fig.2.1).

Figura 2.1: Tabela ASCII de valores literais.

O fragmento de código abaixo mostra a declaração de duas vari´aveis char cha-madas ch e letra. Estas variáveis ser˜ao preenchidas com as constantes literais ‘a’ e

(23)

‘+’. C´odigo 2.1: exemplo2.c v o i d m a i n (v o i d) { c h a r ch ; c h a r l e t r a ; ch = ’ a ’; l e t r a = ’ + ’; }

Como no Fortran, as variáveis podem ser inicializadas diretamente na declaração de variável como a seguir:

C´odigo 2.2: exemplo3.c v o i d m a i n (v o i d) {

c h a r ch = ’ a ’; c h a r l e t r a = ’ + ’; }

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

A linguagem C reserva algumas constantes literais especiais para controle de edição e exibição de caracteres tais como os exibidos na tabela a seguir.

(24)

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ão \t 0x09 HT tabulação horizontal \v 0x0b VT tabulação vertical \\ 0x5c \ backslash \’ 0x27 ’ apóstrofo \” 0x22 ” aspas \? 0x3f ? interrogação

Fora desta tabela, existe um outro car´acter especial chamado NULL que ´e ‘\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´udo de vari´aveis do tipo char quando o conte´udo ´e uma constante literal, usamos o seguinte comando:

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

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

C´odigo 2.3: exemplo4a.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r ch = ’ a ’; c h a r l e t r a = ’ + ’; p r i n t f (" % c ", ch ); p r i n t f (" % c ", l e t r a ); }

(25)

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

C´odigo 2.4: exemplo4b.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r ch = ’ a ’; c h a r l e t r a = ’ + ’; p r i n t f (" % c % c \ n ", ch , l e t r a ); }

2.2.2 Tipo Inteiro: char e int

Em C, vari´aveis que armazenam valores inteiros s˜ao do tipo char e int. O tipo char ´

e o mesmo usado para armazenar caracteres e, neste caso, o tipo character do Fortran não possui correspondˆencia. Quando usado para armazenar valores inteiros, o tipo char pode assumir valores entre -128 e 127, que são os valores poss´ıveis para um número inteiro de 8 bits, sendo um deles o bit de sinal.

C´odigo 2.5: exemplo5.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r x = -100; c h a r i = 54; p r i n t f (" % d % d \ n ",x , i ); }

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

(26)

# i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r x = ’ a ’; c h a r i = ’ 1 ’; p r i n t f (" % d % d \ n ",x , i ); }

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

O tipo int tem comprimento de 32 bits (4 bytes) e pode armazenar n´umeros entre -2.147.483.648 e 2.147.483.647, ou seja, 31 bits para representar o n´umero e 1 bit de sinal. Este tipo equivale ao tipo integer do Fortran.

C´odigo 2.7: exemplo6.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { int k = 10000 , a , h ; a = - 1 2 3 4 5 6 7 ; h = 8 5 7 4 8 4 0 3 ; p r i n t f (" % d \ t % d \ t % d \ n ",k , a , h ); }

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

2.2.3 Tipo Real: float e double

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

(27)

# i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { f l o a t f = 0 . 0 3 4 5 3 ; f l o a t x = 1.2 e - 1 0 ; f l o a t y = -0.4356 e23 ; f l o a t z = 10; p r i n t f (" % f , % f , % f , % f \ n ",f , x , y , z ); }

O código de controle de formataç˜ao para o tipo float ´e “%f”. O número real é impresso na forma decimal. A questão é que nem sempre este estilo de formatação ´

e 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ção cient´ıfica. O código de formatação é “%e”. Experimente trocar a formatação no exemplo anterior para ver o efeito.

Al´em do tipo float, a linguagem C possui outro tipo de vari´avel para armazenar um número real com um número maior de d´ıgitos que ´e o double. Sua precis˜ao é de 15 d´ıgitos e possui 64 bits (ou 8 bytes) de comprimento. Seus valores limites s˜ao ±1, 7×10±308_{. O double n˜}_{ao possui equivalente direto no Fortran. ´}_{E necess´}_{ario modificar}

o tipo de precisão através da instruç˜ao select kind precision. Código 2.9: exemplo8.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { d o u b l e G , k , g , Na ; G = 6 . 6 7 2 e - 1 1 ; /* c o n s t a n t e g r a v i t a c i o n a l */ k = 1 . 3 8 0 7 e - 2 3 ; /* 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 p a d r a o */ Na = 6 . 0 2 2 0 e23 ; /* n u m e r o de A v o g a d r o */ p r i n t f (" n u m e r o 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 "

(28)

" g r a v i d a d e p a d r a o = % lf \ n ", Na , k , G , g ); }

O código de controle de formataç˜ao para o tipo double é “%lf” (long float). Nova-mente, a formatação pode não ser apropriada para a impressão do número em função de sua magnitude. Experimente trocar “%lf” para “%g” que ajusta a formatação auto-maticamente.

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 ´e case sensitive, ou seja, “sens´ıvel `a caixa”. Portanto, as variáveis G e g são distintas.

2.2.4 Tipo Indefinido: void

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

2.2.5 Tipo L´ogico

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

O tipo lógico é muito útil no caso de tomada de decisão. Dependendo do conteúdo de uma variável ou do resultado de uma expressão lógica, o algoritmo que está sendo executado pode ser desviado para uma posição espec´ıfica dentro do código. O teste lógico também está presente nas instruções de repetiçã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ção prossegue ou para.

(29)

C´odigo 2.10: exemplo9.c v o i d m a i n (v o i d) { c h a r a = 0 , b = 1; c h a r c = ’ \0 ’, d = ’ z ’; int g = 0 , h = -100; f l o a t f = 0 , r = 0.1 e - 1 0 ; d o u b l e x = 0 , y = 1 e - 3 0 ; }

Se os testes lógicos fossem realizados com as variáveis declaradas acima, os re-sultados 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˜ao usadas para controlar o uso ou n˜ao do bit de sinal em um n´umero inteiro. Estas palavras s˜ao signed e unsigned. Toda vari´avel inteira ´

e, a princ´ıpio, uma variável inteira com sinal (usando-se ou n˜ao a palavra signed). Se há a necessidade de se declarar uma variável inteira sem sinal, deve-se usar a palavra reservada unsigned antes da declaração do tipo (somente os tipos char e int aceitam o prefixo signed e unsigned). Em Fortran, n˜ao há equivalência para este mecanismo.

Uma vari´avel declarada como unsigned char aceita valores entre 0 e 255 e uma vari´avel do tipo unsigned int assume valores entre 0 e 4.294.967.295. Se uma vari´avel for declarada como unsigned (sem a declarac¸˜ao int), o compilador entende que a vari´avel declarada ´e do tipo unsigned int. Exemplo:

C´odigo 2.11: exemplo10.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r r ; /* 1 b y t e com s i n a l */ u n s i g n e d c h a r t ; /* 1 b y t e sem s i n a l */ int i ; /* 4 b y t e s com s i n a l */ u n s i g n e d j ; /* 4 b y t e s sem s i n a l */

(30)

p r i n t f (" s i z e o f ( c h a r )=% d \ n s i z e o f ( u n s i g n e d c h a r )=% d \ n " " s i z e o f ( int )=% d \ n s i z e o f ( u n s i g n e d )=% d \ n ", s i z e o f(c h a r) ,s i z e o f(u n s i g n e d c h a r) ,

s i z e o f(int) ,s i z e o f(u n s i g n e d)); }

A func¸˜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?

C´odigo 2.12: exemplo11.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r ch = 1 2 9 ; /* ? */ p r i n t f (" % d \ n ", ch ); }

Para responder isto, é necess´ario analisar o byte que representa a vari´avel ch. O número 129(d) em binário ´e 10000001(b). Mas o bit mais significativo (msb: most

signi-ficant bit), que é o bit mais a esquerda, é o bit de sinal. Portanto, 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 en-tenderá internamente que “char ch = 129;” é, na verdade, “char ch = -127;”.

2.2.7 Modificadores de Tipo short e long

Outras duas palavra que interferem na declaração de variáveis são as palavras

(31)

um comprimento em bytes menor ou maior respectivamente. O tipo short int possui 2

bytes e, como tem sinal, pode assumir valores desde -32.768 at´e 32.767. Se o tipo da vari´avel for declarado como unsigned short int, ent˜ao a vari´avel possuir´a os mesmos 2

bytes de comprimento, mas aceitar´a valores entre 0 e 65.535. Uma vari´avel do tipo long

int mant´em o mesmo n´umero de bytes de comprimento que o tipo int, isto é, 4 bytes. Portanto, pode armazenar valores entre -2.147.483.648 e 2.147.483.647. A linguagem C aceita a declaração de vari´aveis usando-se somente as palavras reservadas short e long. Ela entende que as variáveis ser˜ao do tipo short int e long int respectivamente, mas esta não é uma boa regra de programaçã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˜ao.

Os compiladores Fortran possuem um mecanismo que permite definir o compri-mento de uma variável inteira, mas este mecanismo não é padronizado. Alguns com-piladores aceitam a declaraç˜ao integer*8 como um inteiro de 8 bytes, outros declaram

integer 8, e h´a aqueles que definem integer(8). Substituindo o n´umero 8 por 4 ou 2, seria poss´ıvel declarar-se vari´aveis inteiras com 4 ou 2 bytes respectivamente.

2.2.8 Type Casting

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

C´odigo 2.13: exemplo12.c # i n c l u d e < s t d i o . h > v o i d m a i n (v o i d) { c h a r c ; int i ; f l o a t f = 2 0 0 . 0 ; i = (int) f ; /* C o n v e r t e r 2 0 0 . 0 p a r a i n t e i r o

(32)

s i g n i f i c a t r u n c a r a p a r t e d e c i m a l . */ c = (c h a r) f ; /* Aqui , a l e m do n u m e r o 2 0 0 . 0 ser t r u n c a d o , p o i s o t i p o c h a r so a c e i t a n u m e r o s i n t e i r o s , o n u m e r o 200 u l t r a p a s s a o l i m i t e de r e p r e s e n t a c a o do c h a r . Logo , o n u m e r o 200 s e r a i n t e r p r e t a d o c o m o -56. */ p r i n t f (" % f \ t % d \ t % d \ n ",f , i , c ); }

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±38

double 64 ±1, 7 × 10±308

long double 80 ±3, 4 × 10±4932

2.3 Vetores, Matrizes e Strings

2.3.1 Declarac¸˜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 ´

e declarado definindo-se o seu tipo de vari´avel e o nome do vetor seguido de sua di-mens˜ao:

(33)

C´odigo 2.14: exemplo13.c v o i d m a i n (v o i d) { u n s i g n e d v _ i n t [ 1 0 0 ] ; /* T i p o : u n s i g n e d int N o m e : v _ i n t 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 di-mensões. Mas cada dimensão é apresentada individualmente entre colchetes:

C´odigo 2.15: exemplo14.c v o i d m a i n (v o i d) { d o u b l e d m a t [ 1 0 ] [ 1 0 ] ; /* T i p o : d o u b l e N o m e : d m a t D i m e n s a o : 10 x10 . */ }

Como mencionado, elementos individuais nos vetores e matrizes são acessados através de ´ındices. É importante destacar que os vetores e matrizes em C começam com o ´ındice zero. Portanto, v int[0] é o primeiro elemento do vetor v int e dmat[0][0] é o elemento inicial da matriz. O ´ındice final do 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 significa 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 dispon´ıvel. Para se calcular a quantidade de memória ocupada por um vetor ou matriz, basta multiplicar as dimensões da estru-tura (vetor ou matriz) pelo total de bytes correspondente ao tipo de dado que define a estrutura. Ent˜ao, o vetor v int com 100 elementos ocupa 100 × 4 bytes ou 400 bytes. A matriz dmat ocupa 10 × 10 × 8 bytes ou 800 bytes de mem´oria.

2.3.2 Cadeia de Caracteres (Strings)

As cadeias de caracteres (strings) em Fortran s˜ao declaradas usando-se o tipo

(34)

cadeia pode assumir. Em C, o tipo char ´e usado para declarar a cadeira de caracteres, que não é mais que um vetor de caracteres. E como vetor, sua declaração em C é igual à usada em qualquer outra situação:

/* d u a s s t r i n g s : f r a s e e p a l a v r a . */

c h a r f r a s e [100] , p a l a v r a [ 3 0 ] ; }

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

Em C, o car´acter que indica o fim da string é 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´acter NULL.

Quando o programador usar a função “printf(“%s”,palavra);” que imprime na tela (idêntico ao comando “write” do Fortran), serão impressos somente os 14 caracteres da palavra “paralelepipedo”. Se n˜ao houver o terminador NULL, ser´a impresso a palavra “paralelepipedo” e um monte de outros caracteres. A sequência de “lixos” só irá parar quando o computador encontrar um car´acter NULL perdido na mem´oria.

Veja que o nome da string (que é um vetor) é um ponteiro. Portanto, a função “printf( )” recebe um ponteiro contendo o in´ıcio da string e começa imprimindo na tela a sequência de caracteres at´e encontrar o NULL. Enquanto a funç˜ao não encontrar o

NULL, ela continuar´a imprimindo. Mas o importante aqui não é a função “printf()”, mas a importância do car´acter terminador NULL e que o programador deve sempre prever que um dos caracteres de sua string ser´a 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).

(35)

das duas dever´a ter, no m´ınimo, a soma dos comprimentos delas mais 1. Uma string nula, isto ´e, sem caracteres (“”), deve ter pelo menos um byte de comprimento, para acomodar o car´acter NULL.

Duas funções em C que são muito úteis na manipulação de strings são: “strcpy( )” e “strlen()”. A função “strcpy( )” usa dois argumentos: um ponteiro que aponta para a ´

area de memória que cont´em a string e outro que aponta para o endereço de destino. A função “strlen()” retorna o total de caracteres que comp˜oem uma string, passada como argumento, exclusive o terminador NULL. O exemplo a seguir mostra como copiar a

string “paralelepipedo” 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ção de tipos mais com-plexos que os intr´ınsecos através de agrupamentos (campos) em estruturas de dados. Uma situação t´ıpica de aplicação de estrutura de dados é a criação de bancos de dados. Normalmente, deseja-se cadastrar pessoas agrupando, de alguma forma, seus dados de identificação, tais como: nome completo, identidade, endereço, profissão, etc.

A palavra reservada em C que define uma estrutura ´e struct. Por exemplo, se o programador deseja criar uma estrutura chamada “tDadosPessoais” e que contenha os campos nome, identidade e enderec¸o, ele deveria escrever o seguinte fragmento de c´odigo: struct tDadosPessoais { char nome[256]; char endereco[256]; int identidade; };

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

(36)

struct tDadosPessoais Usuario;

/* variavel: Usu´ario

tipo : struct tDadosPessoais */

struct tDadosPessoais Funcionario; /* variavel: Funcionario

struct tDadosPessoais Biblioteca; /* variavel: Biblioteca

Para preencher qualquer um dos campos de uma estrutura em C, é necessá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:

C´odigo 2.17: exemplo16.c v o i d m a i n (v o i d) { s t r u c t t D a d o s P e s s o a i s { c h a r n o m e [ 2 5 6 ] ; c h a r e n d e r e c o [ 2 5 6 ] ; int i d e n t i d a d e ; }; s t r u c t 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 ; /* t i p o : s t r u c t 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 : c a m p o 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 dimensão do vetor após o nome da variável estrutura:

(37)

s t r u c t t D a d o s P e s s o a i s { c h a r n o m e [ 2 5 6 ] ; c h a r e n d e r e c o [ 2 5 6 ] ; int i d e n t i d a d e ; }; /* d e c l a r a c a o do v e t o r de e s t r u t u r a U s u a r i o com 1 0 0 0 e n t r a d a s */ s t r u c t t D a d o s P e s s o a i s U s u a r i o [ 1 0 0 0 ] ; s t r c p y ( U s u a r i o [ 0 ] . nome ," J o a o das N e v e s "); s t r c p y ( U s u a r i o [ 0 ] . e n d e r e c o ," Av . A t l a n t i d a , 1 0 0 / 1 0 1 "); U s u a r i o [ 0 ] . i d e n t i d a d e = 1 2 3 4 ; s t r c p y ( U s u a r i o [ 1 0 0 ] . nome ," P a t r i c i a A r a u j o "); s t r c p y ( U s u a r i o [ 1 0 0 ] . e n d e r e c o ," R . Xavier , 3 1 2 / 7 0 8 "); U s u a r i o [ 1 0 0 ] . i d e n t i d a d e = 2 3 4 5 ; s t r c p y ( U s u a r i o [ 1 2 ] . nome ," C a r l o s P a r r e i r a "); s t r c p y ( U s u a r i o [ 1 2 ] . e n d e r e c o ," R . Da Cruz , c a s a 100 "); U s u a r i o [ 1 2 ] . i d e n t i d a d e = 6 3 4 3 ; /* u l t i m a e n t r a d a de um v e t o r de 1 0 0 0 p o s i c o e s */ s t r c p y ( U s u a r i o [ 9 9 9 ] . nome ," R a q u e l de Q u e i r o z "); s t r c p y ( U s u a r i o [ 9 9 9 ] . e n d e r e c o ," R . Paiva , 3 9 8 / 1 1 0 2 "); U s u a r i o [ 9 9 9 ] . i d e n t i d a d e = 4 4 4 4 ; }

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

C´odigo 2.19: exemplo18.c v o i d m a i n (v o i d) { /* 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 */ s t r u c t t D a d o s P e s s o a i s { c h a r n o m e [ 2 5 6 ] ;

(38)

c h a r e n d e r e c o [ 2 5 6 ] ; int i d e n t i d a d e ; } U s u a r i o [1000] , F u n c i o n a r i o ; s t r c p y ( U s u a r i o [ 0 ] . nome ," J o a o das N e v e s "); s t r c p y ( U s u a r i o [ 0 ] . e n d e r e c o ," Av . A t l a n t i d a , 1 0 0 / 1 0 1 "); U s u a r i o [ 0 ] . i d e n t i d a d e = 1 2 3 4 ; 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 ; s t r c p y ( F u n c i o n a r i o . e n d e r e c o ," R . S . F r a n c i s c o " " Xavier , 524 "); s t r c p y ( F u n c i o n a r i o . nome ," P i q u e t C a r n e i r o Jr . "); }

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

2.4.2 Enumerac¸˜oes: enum

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

enum Posicao { PARA_CIMA, PARA_BAIXO,

PARA_ESQUERDA, PARA_DIREITA };

Nesta declaração de enumeração, a constante PARA CIMA é vista pelo

compila-dor como o n´umero 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ções é facilitar a rotulação de determinados números que tenham um signifi-cado especial. E a enumeração impede que uma variável do tipo enumeração assuma outros valores que não tenham sido declarados na enumeraçã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 o enum Posicao. Veja o trecho de código a seguir:

(39)

C´odigo 2.20: exemplo19.c v o i d m a i n (v o i d) { /* d e c l a r a c a o da e n u m e r a c a o */ e n u m P o s i c a o { P A R A _ C I M A , P A R A _ B A I X O , P A R A _ E S Q U E R D A , 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 t i p o e n u m e r a c a o */ e n u m P o s i c a o posicao , s i t u a c a o , c o m a n d o ; p o s i c a o = P A R A _ C I M A ; s i t u a c a o = P A R A _ D I R E I T A ; c o m a n d o = P A R A _ B A I X O ; }

2.4.3 Uni˜oes: union

As uni˜oes (unions) s˜ao estruturas onde os campos compartilham o mesmo espaço da memória, isto é, os campos que compõem a união estão “superpostos”. Por exemplo, uma união que define dois campos: uma vari´avel do tipo int e um vetor de 4 elementos do tipo unsigned char.

union char4int {

unsigned char c[4]; int i;

};

A declaração de variáveis do tipo união segue o mesmo modelo das declaraçõ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´avel Byte4,

usa-se o operador ‘.’.

C´odigo 2.21: exemplo20.c # i n c l u d e < s t d i o . h >

v o i d m a i n (v o i d) {

(40)

u n i o n c h a r 4 i n t { u n s i g n e d c h a r c [ 4 ] ; int i ; }; /* d e c l a r a c a o da v a r i a v e l */ u n i o n c h a r 4 i n t B y t e 4 ; /* a c e s s a n d o o c a m p o ’ i ’ da u n i a o */ B y t e 4 . 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 v e t o r ’ c ’ c o m o n u m e r o s h e x a d e c i m a i s */ p r i n t f (" % x \ t % x \ t % x \ t % x \ n ", B y t e 4 . c [0] , B y t e 4 . c [1] , B y t e 4 . c [2] , B y t e 4 . c [ 3 ] ) ; }

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

O vetor c e a variável i ocupam o mesmo espaço na memória. O esquema repre-sentando a memória ajudará a visualizar o que se passa no programa.

Endereço Memória Variável

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

Na mem´oria, o byte menos significativo ´e o primeiro a ser escrito: 0x03. O pr´oximo

byte ´e 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 e c[3] com o quarto.

(41)

2.4.4 Campo de Bits

O campo de bits ´e 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ˆencia de bits que pode variar de 1 at´e o limite de 32 bits. O tipo de cada entrada na estrutura de campo de bits deve ser do tipo unsigned, pois o elemento bit n˜ao 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 de bits da estrutura ´e 8 que equivale a uma vari´avel char. O acesso a cada bit ´e tratado de forma natural como de qualquer outra estrutura:

C´odigo 2.22: exemplo21.c v o i d m a i n (v o i d) { s t r u c t C a m p o B i t s { u n s i g n e d b0 :1; /* 0 ,1 */ u n s i g n e d b1 :1; /* 0 ,1 */ u n s i g n e d b 2 _ 3 :2; /* 0 . . 3 */ u n s i g n e d b 4 _ 7 :4; /* 0 . . 1 5 */ }; s t r u c t C a m p o B i t s b i t s ; b i t s . b0 = 0;

(42)

b i t s . b1 = 1;

b i t s . b 2 _ 3 = 2; /* 2 d e c i m a l em b i n a r i o eh 10. */

b i t s . b 4 _ 7 = 6; /* 6 d e c i m a l em b i n a r i o eh 0 1 1 0 . */

Se o campo de bits for utilizado dentro de uma uni˜ao, cria-se a possibilidade de se converter números declarados “binariamente” em decimais e vice-versa. É interessante perceber que o campo de bits ´e muito apropriado para geração de “máscaras” (muito utilizado quando se precisa acessar o hardware e testar/acionar bits individualmente).

C´odigo 2.23: exemplo22.c v o i d m a i n (v o i d) { s t r u c t 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 b 2 _ 3 :2; u n s i g n e d b 4 _ 7 :4; }; u n i o n S t a t u s M o u s e { /* o c a m p o de b i t s e a v a r i a v e l u n s i g n e d c h a r */ /* c o m p a r t i l h a m a m e s m a a r e a da m e m o r i a . */ s t r u c t C a m p o B i t s b i t s ; u n s i g n e d c h a r ch ; }; u n i o n S t a t u s M o u s e sm ; sm . ch = 12; /* 12 em b i n a r i o eh 0 0 0 0 1 1 0 0 . O bit b0 eh o */ /* m a i s a d i r e i t a e os b i t s de b4_7 , os m a i s */ /* a e s q u e r d a . P o r t a n t o , b0 eh 0 , b1 eh 0 , */ /* b 2 _ 3 eh 3 (11 em b i n a r i o eh 3 d e c i m a l ) , e */ /* b 4 _ 7 eh 0 ( 0 0 0 0 b i n a r i o ). */ }

Por exemplo: se o bit b0 corresponde ao botão esquerdo do mouse e o bit b1 ´e o botão direito, para testar se o usuário está pressionando o botão esquerdo, bastaria

(43)

verificar se o bit b0 ´e 1; para testar o botão direito, é s´o verificar o bit b1 (o mecanismo que liga o bit b0 e o bit b1 ao status do mouse n˜ao está mostrado; assuma que exista um mecanismo que faça isso).

2.4.5 Declarac¸˜ao typedef

typedef ´e uma palavra reservada da linguagem C que simplifica a declaração de estruturas, uniões, enumeraç˜oes e campos de bits. Através do typedef, declara-se formal-mente o nome de novos tipos. A sintaxe do typedef ´e simples:

C´odigo 2.24: exemplo23.c /* cria - se a e s t r u t u r a M e u C a d a s t r o . */ s t r u c t M e u C a d a s t r o { c h a r n o m e [ 2 5 6 ] ; c h a r e n d e r e c o [ 2 5 6 ] ; u n s i g n e d t e l e f o n e ; }; /* defini - se o n o v o t i p o p a r a s t r u c t M e u C a d a s t r o c o m o s e n d o s i m p l e s m e n t e C a d a s t r o . */ t y p e d e f s t r u c t M e u C a d a s t r o C a d a s t r o ; v o i d m a i n (v o i d) { /* v e t o r de 100 e l e m e n t o s do t i p o C a d a s t r o ( que eh , na verdade , s t r u c t M e u C a d a s t r o ). */ C a d a s t r o cad [ 1 0 0 ] ; }

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 Ca-dastro é o novo nome de struct MeuCadastro. Cadastro é muito mais compacto que struct MeuCadastro.

(44)

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 linguagens, será apresentado de forma cuidadosa nesta seção. Antecipando uma informação crucial, os ponteiros estão intimamente relacionados aos vetores e matrizes.

2.5.1 Ponteiros e Enderec¸o de Mem´oria

Resgatando o que já foi apresentado na subseção2.1.4, quando o programador de-clara uma variável, compila o código-fonte e o programa é executado, ele sabe que a sua variável será alocada em algum endereço na memória do computador. O programador não precisa, a princ´ıpio, saber o endereço 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ço no qual ela foi alocada, e “copiar para” ou “ler de” lá os dados.

Para facilitar a visualização do mecanismo de funcionamento dos ponteiros, ima-gine a memória do computador como uma grande pilha de caixas onde cada uma possui um endereço espec´ıfico e um byte de comprimento. Quando o programador declara uma variável e executa o programa (depois da compilação), o computador associa uma dessas caixas com o como da variável; é como se o nome da variável e o endereço na memória fossem sinônimos. Quando o programador acessa uma variável, é o endereço 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

(45)

ch2 no endereço 0x1101. Quando a linha de instrução “ch1 = 10;” é executada, o com-putador copia o número 10 no endereço da variável ch1, ou seja, no endereço 0x1100.

A linha de instrução seguinte é “ch2 = 2*ch1;”. O computador irá ler o dado no endereço da variável ch1, irá multiplicar este dado por 2 e, depois, escreverá o resultado desta multiplicação no endereço da variável ch2. Note que, em nenhum momento, o programador precisou saber o endereço das suas variáveis.

int i1, i2;

0x1100 i1

0x1104 i2

0x1107 0x1108

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

Se o programador declara duas vari´aveis int, i1 e i2, o computador reserva 4

bytes para cada uma delas. A vari´avel i1 é alocada no endereço 0x1100. A variável i2 só poder´a ser alocada 4 bytes depois. Isto significa que seu endereço de mem´oria será 0x1104. Além disso, qualquer outra variável que tiver de ser alocada na memória, só poder´a estar a partir do endereço 0x1108, uma vez que o byte do endereço 0x1107 ainda faz parte da variável i2.

A relação entre uma variável e seu endereço é biun´ıvoca, de um para um: toda variável possui um endereço espec´ıfico, assim como todo endereço corresponde a uma

(46)

vari´avel.

2.5.2 Declarac¸˜ao de Ponteiros

A variável ponteiro é declarada a partir de um dos tipos válidos em C, isto é, é v´alido declarar ponteiros para: char, unsigned char, short, unsigned short, int, unsigned,

long, unsigned long, float, double e long double. O compilador reconhece como definic¸ão de ponteiro a declaração de uma variável de qualquer um destes tipos válidos prece-dido 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 arbi-trariamente).

char *ch;

unsigned char *uch;

short *si; /* mesmo que ‘short int’ */

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´aveis ponteiros ocupam 4 bytes de mem´oria, independente do tipo de dado apontado. O conteúdo da variável ponteiro é um endereço de memória. Qualquer endereço 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´aveis ponteiros ocupar˜ao 8 bytes cada. Nos exemplos apresentados nesta seção, ser´a assumido um computador de 32 bits.

(47)

2.5.3 Operador de Enderec¸amento de Dado(&)

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

int *iptr, i; /* iptr ´e um ponteiro para int e

i ´e uma vari´avel 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˜ao retornando endereço. Ponteiros do tipo int recebem endereços de vari´aveis do tipo

int; ponteiros do tipo double recebem enderec¸os de vari´aveis do tipo double e assim por diante.

2.5.4 Operador de Referenciamento de Dado (*)

Mostrou-se até agora o mecanismo de extração de endereço de uma variável e sub-sequente armazenamento em um ponteiro. Para acessar o dado apontado 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çã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 declaração de três variáveis: i1, iptr e i2. Ele aloca as variáveis, na ordem de declaração, em espaços da memória. Suponha que a variável i1 seja alocada no endereço 0x1a3c22, a