linguagem progr c

Linguagem de Programação C

Esta apostila foi elaborada a partir da versão .doc da apostila que foi foi elaborada por Henrique José dos Santos (Eng. da Computação, UNISANTOS, Santos‐SP) e posteriormente utilizada pela UFMG e atualmente mantida por pelo professor Renato Cardoso Mesquita

Alguns capítulos foram modificados e/ou inseridos pelos professores Roberto Teixeira Alves e Rodrigo Janasievicz Gomes Pinheiro para atender o conteúdo que desejamos abordar no curso de extensão da UTFPR.

ÍNDICE

1. INTRODUÇÃO ................................................................................................................................................... 5

1.1. VISÃO GERAL DE UM PROGRAMA C ............................................................................................................... 6

2. SINTAXE ............................................................................................................................................................. 8

2.1. O C É "CASE SENSITIVE" .............................................................................................................................. 8 2.2. PALAVRAS RESERVADAS DO C ..................................................................................................................... 9 2.3. IDENTIFICADORES ......................................................................................................................................... 9 2.4. TIPOS ............................................................................................................................................................ 9 2.5. DECLARAÇÃO E INICIALIZAÇÃO DE VARIÁVEIS .......................................................................................... 10 2.6. CONSTANTES .............................................................................................................................................. 13 2.7. CARACTERES DE CONTROLE DA LINGUAGEM C ........................................................................................... 14 2.8. INSTRUÇÕES ................................................................................................................................................ 15 2.9. OPERADORES ARITMÉTICOS ....................................................................................................................... 15 2.10. OPERADORES RELACIONAIS E LÓGICOS ...................................................................................................... 17 2.11. OPERADORES LÓGICOS BIT A BIT ............................................................................................................... 18 2.12. EXPRESSÕES ............................................................................................................................................... 19 2.13. TABELA DE PRECEDÊNCIAS DO C ................................................................................................................ 21 2.14. ESPAÇAMENTO E PARÊNTESES .................................................................................................................... 21 2.15. ESTRUTURA DE UM PROGRAMA EM C .......................................................................................................... 21

3. FUNÇÕES BÁSICAS DE ENTRADA E SAÍDA ........................................................................................... 23

3.1. FUNÇÃO PRINTF( ) (BIBLIOTECA STDIO.H) ............................................................................................. 23 3.2. DOIS PRIMEIROS PROGRAMAS .................................................................................................................... 26

4. ESTRUTURAS DE CONTROLE ................................................................................................................... 29

4.1. COMANDO SIMPLES ..................................................................................................................................... 29 4.2. BLOCO DE COMANDOS ................................................................................................................................ 29 4.3. ESTRUTURAS DE SELEÇÃO .......................................................................................................................... 29 4.4. ESTRUTURAS DE REPETIÇÃO ....................................................................................................................... 34

5. VETORES, MATRIZES E STRING .............................................................................................................. 41

5.1. VETORES ..................................................................................................................................................... 41 5.2. STRINGS ...................................................................................................................................................... 43 5.3. MATRIZES ................................................................................................................................................... 46

6. PONTEIROS ..................................................................................................................................................... 49

6.1. INTRODUÇÃO .............................................................................................................................................. 49 6.2. COMO FUNCIONAM OS PONTEIROS ............................................................................................................. 49 6.3. DECLARAÇÃO DE PONTEIROS ..................................................................................................................... 50 6.4. OPERADORES & E * ..................................................................................................................................... 50 6.5. PROBLEMAS NO USO DE PONTEIROS ............................................................................................................ 51 6.6. OPERAÇÕES ELEMENTARES COM PONTEIROS .............................................................................................. 52 6.7. PONTEIROS E VETORES ............................................................................................................................... 53 6.8. PONTEIROS E STRINGS ................................................................................................................................ 55 6.9. VETORES DE PONTEIROS ............................................................................................................................. 55 6.10. PONTEIROS PARA PONTEIROS ...................................................................................................................... 56

7. FUNÇÕES ......................................................................................................................................................... 57

7.1. VALORES DE RETORNO POR FUNÇÕES ........................................................................................................ 58 7.2. LOCALIZAÇÃO DAS FUNÇÕES ...................................................................................................................... 59 7.3. ESCOPO DE VARIÁVEIS ............................................................................................................................... 62 7.4. PASSAGEM POR VALOR ............................................................................................................................... 64 7.5. PASSAGEM POR REFERÊNCIA ...................................................................................................................... 65 7.6. PASSANDO VETORES PARA FUNÇÕES .......................................................................................................... 66 7.7. PASSAGEM DE MATRIZ PARA FUNÇÃO ......................................................................................................... 67 7.8. RECURSIVIDADE ......................................................................................................................................... 68 7.9. ARGUMENTOS ARGC E ARGV DO MAIN ........................................................................................................ 69

8. DIRETIVAS DE COMPILAÇÃO ................................................................................................................... 71

8.1. A DIRETIVA INCLUDE .................................................................................................................................. 71 8.2. AS DIRETIVAS DEFINE E UNDEF ................................................................................................................... 71 8.3. AS DIRETIVAS IFDEF E ENDIF ..................................................................................................................... 73 8.4. A DIRETIVA IFNDEF .................................................................................................................................... 74 8.5. A DIRETIVA IF ............................................................................................................................................ 74 8.6. A DIRETIVA ELSE ........................................................................................................................................ 74 8.7. A DIRETIVA ELIF ........................................................................................................................................ 75

9. MANIPULAÇÃO DE ARQUIVOS ................................................................................................................. 77

9.1. INTRODUÇÃO .............................................................................................................................................. 77 9.2. LENDO E ESCREVENDO CARACTERES EM ARQUIVOS .................................................................................. 80 9.3. OUTROS COMANDOS DE ACESSO A ARQUIVOS ........................................................................................... 83 9.4. FLUXOS PADRÃO ........................................................................................................................................ 87

10. TIPOS DE DADOS AVANÇADOS ............................................................................................................ 89

10.1. MODIFICADORES DE ACESSO ...................................................................................................................... 89 10.2. CONVERSÃO DE TIPOS ................................................................................................................................ 91 10.3. MODIFICADORES DE FUNÇÕES .................................................................................................................... 92 10.4. PONTEIROS PARA FUNÇÕES ......................................................................................................................... 93 10.5. ALOCAÇÃO DINÂMICA ................................................................................................................................ 94 10.6. ALOCAÇÃO DINÂMICA DE VETORES E MATRIZES ....................................................................................... 97

11. TIPOS DE DADOS DEFINIDOS PELO USUÁRIO. ............................................................................. 101

11.1. ESTRUTURAS - PRIMEIRA PARTE ............................................................................................................... 101 11.2. ESTRUTURAS - SEGUNDA PARTE ............................................................................................................... 103 11.3. DECLARAÇÃO UNION ................................................................................................................................ 106 11.4. ENUMERAÇÕES ......................................................................................................................................... 107 11.5. O COMANDO SIZEOF ................................................................................................................................. 108 11.6. O COMANDO TYPEDEF ............................................................................................................................... 109 11.7. UMA APLICAÇÃO DE STRUCTS: AS LISTAS SIMPLESMENTE ENCADEADAS .................................................. 110

12. CONCEITOS BÁSICOS DE C++ ............................................................................................................. 114

12.1. O QUE É PROGRAMAÇÃO ORIENTADA À OBJETOS? ..................................................................................... 114 12.2. CARACTERÍSTICAS PRINCIPAIS DE UMA LINGUAGEM ORIENTADA AO OBJETO ................ 115 12.3. ELEMENTOS DA LINGUAGEM C++ ................................................................................................... 115

5

1. INTRODUÇÃO Um programa de computador é um conjunto instruções que representam um algoritmo para

a resolução de algum problema. Estas instruções são escritas através de um conjunto de códigos (símbolos e palavras). Este conjunto de códigos possui regras de estruturação lógica e sintática própria. Dizemos que este conjunto de símbolos e regras formam uma linguagem de programação.

Podemos dividir, genericamente, as linguagens de programação em dois grandes grupos: as linguagens de baixo nível e as de alto nível:

Linguagens de baixo nível: São linguagens voltadas para a máquina, isto é, são escritas usando as instruções do microprocessador do computador. São genericamente chamadas de linguagens Assembly.

Vantagens: Programas são executados com maior velocidade de processamento. Os programas ocupam menos espaço na memória.

Desvantagens: Em geral, programas em Assembly têm pouca portabilidade, isto é, um código gerado para um tipo de processador não serve para outro. Códigos Assembly não são estruturados, tornando a programação mais difícil.

Linguagens de alto nível: São linguagens voltadas para o ser humano. Em geral utilizam sintaxe estruturada tornando seu código mais legível. Necessitam de compiladores ou interpretadores para gerar instruções do microprocessador. Interpretadores fazem a interpretação de cada instrução do programa fonte executando‐a dentro de um ambiente de programação, Basic e AutoLISP por exemplo. Compiladores fazem a tradução de todas as instruções do programa fonte gerando um programa executável. Estes programas executáveis (*.exe) podem ser executados fora dos ambientes de programação, C e Pascal por exemplo. As linguagens de alto nível podem se distinguir quanto a sua aplicação em genéricas como C, Pascal e Basic ou específicas como Fortran (cálculo matemático), GPSS (simulação), LISP (inteligência artificial) ou CLIPPER (banco de dados).

Vantagens: Por serem compiladas ou interpretadas, tem maior portabilidade podendo ser executados em varias plataformas com pouquíssimas modificações. Em geral, a programação torna‐se mais fácil por causa do maior ou menor grau de estruturação de suas linguagens.

Desvantagens: Em geral, as rotinas geradas (em linguagem de maquina) são mais genéricas e portanto mais complexas e por isso são mais lentas e ocupam mais memória.

Mas o que é C? C é o nome de uma linguagem atualmente utilizada em diferentes áreas e propósitos. Faz parte hoje de uma linguagem considerada avançada, desenvolvida nos laboratórios Bell nos anos 70.

A definição formal da linguagem pode ser encontrada no livro “The C Programming Language” de Brian W. Kernighan e Dennis M. Ritchie (os pais da linguagem). Nos anos 80 iniciou‐se

6

um trabalho de criação de um padrão chamado C ANSI (American National Standardization Institute).

É uma linguagem de nível médio, pois pode‐se trabalhar em um nível próximo ao da máquina ou como uma linguagem de alto nível como outras existentes.

Com o C podemos escrever programas concisos, organizados e de fácil entendimento, mas infelizmente a falta de disciplina pode gerar programas mal escritos, difíceis de serem lidos e compreendidos. Não se deve esquecer que C é uma linguagem para programadores, pois impõe poucas restrições ao que pode ser feito. O C é amigável e estruturado para encorajar bons hábitos de programação; cabe ao programador exercitar esses hábitos.

A necessidade de escrever programas, que façam uso de recursos da linguagem de máquina de uma forma mais simples e portátil, fez com que a principal utilização do C fosse a reescrita do sistemas operacional UNIX e deu origem a outras linguagens de programação, entre elas a linguagem C++ e Java. Sua indicação é principalmente no desenvolvimento de programas, tais como: compiladores, interpretadores, editores de texto; banco de dados. Computação gráfica, manipulação e processamento de imagens, controle de processos, …

Principais características da linguagem C a serem ponderadas:

• Portabilidade

• Geração de códigos executáveis compactos e rápidos

• Interação com o sistema operacional

• Facilidade de uso (através de ambientes como o Borland C++ 5.0)

• Linguagem estruturada

• Confiabilidade

• Simplicidade

1.1. Visão geral de um programa C

A geração do programa executável a partir do programa fonte obedece a uma seqüência de operações antes de tornar‐se um executável. Depois de escrever o módulo fonte em um editor de textos, o programador aciona o compilador que no UNIX é chamado pelo comando cc. Essa ação desencadeia uma seqüência de etapas, cada qual traduzindo a codificação do usuário para uma forma de linguagem de nível inferior, que termina com o executável criado pelo lincador.

7

Editor (módulo fonte em C)

Pré‐processador (novo fonte expandido)

Compilador (arquivo objeto)

Lincador (executável)

8

2. Sintaxe A sintaxe são regras detalhadas para cada construção válida na linguagem C. Estas regras

estão relacionadas com os tipos, as declarações, as funções e as expressões.

Os tipos definem as propriedades dos dados manipulados em um programa.

As declarações expressam as partes do programa, podendo dar significado a um identificador, alocar memória, definir conteúdo inicial, definir funções.

As funções especificam as ações que um programa executa quando roda.

A determinação e alteração de valores, e a chamada de funções de entrada e saída (imput/output ‐ I/O) são definidas nas expressões.

As funções são as entidades operacionais básicas dos programas em C, que por sua vez são a união de uma ou mais funções executando cada qual o seu trabalho. Há funções básicas que estão definidas na biblioteca C. As funções printf() e scanf() por exemplo, permitem respectivamente escrever na tela e ler os dados a partir do teclado. O programador também pode definir novas funções em seus programas, como rotinas para cálculos, impressão, etc.

Todo programa C inicia sua execução chamando a função main(), sendo obrigatória a sua declaração no programa principal.

Comentários no programa são colocados entre /* e */ não sendo considerados na compilação.

Cada instrução encerra com ; (ponto e vírgula) que faz parte do comando.

Exemplo:

main() /* função obrigatória */ {

printf("oi"); }

2.1. O C é "Case Sensitive"

Vamos começar o nosso curso ressaltando um ponto de suma importância: o C é "Case Sensitive", isto é, maiúsculas e minúsculas fazem diferença. Se declarar uma variável com o nome

soma ela será diferente de Soma, SOMA, SoMa ou sOmA. Da mesma maneira, os comandos do C

if e for, por exemplo, só podem ser escritos em minúsculas pois senão o compilador não irá interpretá‐los como sendo comandos, mas sim como variáveis.

9

2.2. Palavras Reservadas do C

Todas as linguagens de programação têm palavras reservadas. As palavras reservadas não podem ser usadas a não ser nos seus propósitos originais, isto é, não podemos declarar funções ou

variáveis com os mesmos nomes. Como o C é "case sensitive" podemos declarar uma variável For, apesar de haver uma palavra reservada for, mas isto não é uma coisa recomendável de se fazer pois pode gerar confusão.

Apresentamos a seguir as palavras reservadas do ANSI C. Veremos o significado destas palavras chave à medida que o curso for progredindo:

auto break case char const

continue default

do

double else enum extern float for goto if

int long

register return short signed sizeof static

struct switch typedef union

unsigned void

volatile while

2.3. Identificadores

São utilizados para dar nomes a constantes, variáveis, funções e vários objetos definidos pelo usuário. As regras para formação desses nomes são:

• Todo identificador deve iniciar por uma letra (a..z ou A..Z) ou um sublinhado

• Não pode conter símbolos especiais. Após o primeiro caracter pode ser utilizado: letras, sublinhados e/ou dígitos.

• Utiliza‐se identificadores de, no máximo, 32 caracteres por estes serem significativos.

• Não pode ser palavra reservada e nem nome de funções de bibliotecas.

2.4. Tipos

Quando você declara um identificador dá a ele um tipo. O C tem 5 tipos básicos: char, int, float, void, double. Objetos do tipo char representam caracteres, objetos do tipo int representam valores inteiros e objetos do tipo float representam números reais (ponto

flutuante). O double é o ponto flutuante duplo e pode ser visto como um ponto flutuante com

muito mais precisão. O void é o tipo vazio, ou um "tipo sem tipo". A aplicação deste "tipo" será vista posteriormente.

10

Para cada um dos tipos de variáveis existem os modificadores de tipo. Os modificadores de tipo do C são quatro: signed, unsigned, long e short. Ao float não se pode aplicar nenhum

e ao double pode‐se aplicar apenas o long. Os quatro modificadores podem ser aplicados a

inteiros. A intenção é que short e long devam prover tamanhos diferentes de inteiros onde isto

for prático. Inteiros menores (short) ou maiores (long). int normalmente terá o tamanho

natural para uma determinada máquina. Assim, numa máquina de 16 bits, int provavelmente terá 16 bits. Numa máquina de 32 bits, int deverá ter 32 bits. Na verdade, cada compilador é livre para

escolher tamanhos adequados para o seu próprio hardware, com a única restrição de que shorts ints e ints devem ocupar pelo menos 16 bits, longs ints pelo menos 32 bits, e short int não pode ser maior que int, que não pode ser maior que long int. O modificador unsigned serve para especificar variáveis sem sinal. Um unsigned int será um inteiro que assumirá apenas valores positivos. A seguir estão listados os tipos de dados permitidos e seu valores máximos e mínimos em um compilador típico para um hardware de 16 bits. Também nesta tabela está especificado o formato que deve ser utilizado para ler os tipos de dados com a função scanf():

Tipo Num de bits Formato para leitura com

scanf

Intervalo

Inicio Fim

char 8 %c ‐128 127 unsigned char 8 %c 0 255 signed char 8 %c ‐128 127

Int 16 %i ‐32.768 32.767 unsigned int 16 %u 0 65.535 signed int 16 %i ‐32.768 32.767 short int 16 %hi ‐32.768 32.767

unsigned short int 16 %hu 0 65.535 signed short int 16 %hi ‐32.768 32.767

long int 32 %li ‐2.147.483.648 2.147.483.647signed long int 32 %li ‐2.147.483.648 2.147.483.647

unsigned long int 32 %lu 0 4.294.967.295 float 32 %f 3,4E‐38 3.4E+38 double 64 %lf 1,7E‐308 1,7E+308

long double 80 %Lf 3,4E‐4932 3,4E+4932

O tipo long double é o tipo de ponto flutuante com maior precisão. É importante observar que os intervalos de ponto flutuante, na tabela acima, estão indicados em faixa de expoente, mas os números podem assumir valores tanto positivos quanto negativos.

2.5. Declaração e Inicialização de Variáveis

As variáveis no C devem ser declaradas antes de serem usadas. A forma geral da declaração de variáveis é:

tipo_da_variável lista_de_variáveis;

11

As variáveis da lista de variáveis terão todas o mesmo tipo e deverão ser separadas por vírgula. Como o tipo default do C é o int, quando vamos declarar variáveis int com algum dos

modificadores de tipo, basta colocar o nome do modificador de tipo. Assim um long basta para declarar um long int.

Por exemplo, as declarações

char ch, letra; long count; float pi;

declaram duas variáveis do tipo char (ch e letra), uma variável long int (count) e um float pi.

Onde as variáveis podem ser declaradas

Há três lugares nos quais podemos declarar variáveis.

O primeiro é fora de todas as funções do programa. Estas variáveis são chamadas variáveis globais e podem ser usadas a partir de qualquer lugar no programa. Pode‐se dizer que, como elas estão fora de todas as funções, todas as funções as vêem. Estas variáveis são alocadas estaticamente na memória RAM.

O segundo lugar no qual se pode declarar variáveis é no início de um bloco de código. Estas variáveis são chamadas locais e só têm validade dentro do bloco no qual são declaradas, isto é, só a função à qual ela pertence sabe da existência desta variável, dentro do bloco no qual foram declaradas. Estas variáveis são alocadas dinamicamente na memória RAM. Depois que uma função é executada, estas variáveis são desalocadas.

O terceiro lugar onde se pode declarar variáveis é na lista de parâmetros de uma função. Mais uma vez, apesar de estas variáveis receberem valores externos, estas variáveis são conhecidas apenas pela função onde são declaradas e também são alocadas dinamicamente na memória RAM.

Veja o programa abaixo:

#include <stdio.h> int contador; int func1(int j) {

/* aqui viria o código da funcao ... */

} int main(){

char condicao; int i; for (i=0; i<100; i=i+1){

/* Bloco do for */ float f2; /* etc ...

... */

12

func1(i); }

/* etc ... */ return(0);

}

A variável contador é uma variável global, e é acessível de qualquer parte do programa.

As variáveis condicao e i, só existem dentro de main(), isto é são variáveis locais de main. A variável float f2 é um exemplo de uma variável de bloco, isto é, ela somente é conhecida dentro

do bloco do for, pertencente à função main. A variável inteira j é um exemplo de declaração na

lista de parâmetros de uma função (a função func1).

As regras que regem onde uma variável é válida chamam‐se regras de escopo da variável. Há mais dois detalhes que devem ser ressaltados. Duas variáveis globais não podem ter o mesmo nome. O mesmo vale para duas variáveis locais de uma mesma função. Já duas variáveis locais, de funções diferentes, podem ter o mesmo nome sem perigo algum de conflito.

Alocação de memória: Reserva de espaço de memória (RAM) para alocar uma variável.

• Alocação estática de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM durante toda a execução do programa. Este espaço de memória é desalocado somente quando o programa acaba.

• Alocação dinâmica de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM temporariamente. Este espaço de memória é desalocado quando o espaço não é mais necessário.

Podemos inicializar variáveis no momento de sua declaração. Para fazer isto podemos usar a forma geral

tipo_da_variável nome_da_variável = constante;

Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto significa que até que um primeiro valor seja atribuído à nova variável ela tem um valor indefinido e que não pode ser utilizado para nada. Nunca presuma que uma variável declarada vale zero ou qualquer outro valor. Exemplos de inicialização são dados abaixo :

char ch='D'; int count=0; float pi=3.141;

Ressalte‐se novamente que, em C, uma variável tem que ser declarada no início de um bloco de código. Assim, o programa a seguir não é válido em C (embora seja válido em C++).

int main(){ int i; int j; j = 10;

13

int k = 20; /* Esta declaracao de variável não é válida, pois não está sendo feita no início do bloco */

return(0); }

2.6. Constantes

Muitas vezes identificamos uma constante numérica por um símbolo: Pi = 3,14159 por exemplo. Podemos definir um nome simbólico para esta constante, isto é, podemos definir uma constante simbólica que represente valor. O programador pode definir constantes simbólicas em qualquer programa, e sua sintaxe é a seguinte:

#define nome valor

onde #define é uma diretiva de compilação que diz ao compilador para trocar as

ocorrências do texto nome por valor. Observe que não há ; no final da instrução pois se trata de um comando para o compilador e não para o processador. A instrução #define deve ser escrita antes da instrução de declaração da rotina principal.

Exemplo: a seguir definimos algumas constantes simbólicas.

#define PI 3.14159 #define ON 1 #define OFF 0 #define ENDERECO 0x378 int main(){ ...

No exemplo acima, definimos PI como 3.14159. Isto significa que todas as ocorrências do texto PI será trocado por 3.14159. Assim se escrevemos uma instrução:

área = PI * raio * raio;

o compilador vai interpretar esta instrução como se fosse escrita assim:

área = 3.14159 * raio * raio;

Poderíamos escrever estas instruções assim:

float pi = 3.14159; área = pi * área * área;

porém este tipo de instrução tem duas desvantagens: Primeiro, reserva 4 bytes de memória desnecessariamente. Segundo, esta instrução é executada mais lentamente pois o processador precisa acessar a memória para verificar qual é o valor de pi.

Observe também que no exemplo definimos os nomes simbólicos com letras maiúsculas. Isto não é necessário, podemos perfeitamente definir nomes simbólicos usando letras minúsculas, porém faz parte do jargão dos programadores C usar letras maiúsculas para definir constantes simbólicas.

14

O uso da diretiva #define não se restringe apenas ao apresentado acima, podemos usá‐la para definir macro instruções. Este uso será detalhado nas próximas seções.

Constantes dos tipos básicos do C

Tipo de Dado Exemplos de Constantes

char 'b' '\n' '\0' int 2 32000 ‐130

long int 100000 ‐467 short int 100 ‐30

unsigned int 50000 35678 float 0.0 23.7 ‐12.3e‐10double 12546354334.0 ‐0.0000034236556

Constantes octais e hexadecimais

Muitas vezes precisamos inserir constantes hexadecimais (base dezesseis) ou octais (base oito) no nosso programa. O C permite que se faça isto. As constantes hexadecimais começam com 0x. As constantes octais começam em 0.

Alguns exemplos:

Constante Tipo0xEF Constante Hexadecimal (8 bits)

0x12A4 Constante Hexadecimal (16 bits) 03212 Constante Octal (12 bits)

034215432 Constante Octal (24 bits)

Nunca escreva portanto 013 achando que o C vai compilar isto como se fosse 13. Na linguagem C 013 é diferente de 13!

2.7. Caracteres de controle da linguagem C

Estes caracteres devem ser representados como caracteres alfanuméricos (entre ‘ ‘) ou como conteúdo de uma string.

Código Significado\b Retrocesso ("back")\f Alimentação de formulário ("form feed")\n Nova linha ("new line")\t Tabulação horizontal ("tab") \" Aspas \' Apóstrofo \0 Nulo (0 em decimal)\\ Barra invertida

15

\v Tabulação vertical\a Sinal sonoro ("beep")\N Constante octal (N é o valor da constante)\xN Constante hexadecimal (N é o valor da constante)

2.8. Instruções

Uma instrução em linguagem C é uma expressão seguida de um ponto e vírgula. Pode ser uma atribuição, uma chamada de função, um teste de desvio ou um teste de laço.

Exemplo de instrução de atribuição:

x = 12;

onde o sinal de igual (=) é o operador de atribuição. Note‐se que o operando do lado esquerdo do operador de atribuição é sempre uma variável, e que o operando do lado direito deve ser de um tipo de dado compatível com o tipo da variável.

A linguagem de programação C permite utilizar o operador de atribuição em expressões, junto com operadores matemáticos, lógicos, relacionais, chamada de funções, e outros.

if ((produto = x * y) < 0)

Funcionamento: Primeiramente C atribui o valor x * y a variável produto, para depois avaliar a expressão, ou seja, comparar se o produto é menor (<) que zero.

2.9. Operadores Aritméticos

Os operadores aritméticos são usados para desenvolver operações matemáticas. A seguir apresentamos a lista dos operadores aritméticos do C:

Operador Ação + Soma (inteira e ponto flutuante) - Subtração ou Troca de sinal (inteira e ponto flutuante) * Multiplicação (inteira e ponto flutuante) / Divisão (inteira e ponto flutuante)

% Resto de divisão (de inteiros) ++ Incremento (inteiro e ponto flutuante) -- Decremento (inteiro e ponto flutuante)

O C possui operadores unários e binários. Os unários agem sobre uma variável apenas, modificando ou não o seu valor, e retornam o valor final da variável. Os binários usam duas variáveis e retornam um terceiro valor, sem alterar as variáveis originais. A soma é um operador binário, pois pega duas variáveis, soma seus valores, sem alterar as variáveis, e retorna esta soma. Outros operadores binários são os operadores ‐ (subtração), *, / e %. O operador ‐ como troca de sinal é um

16

operador unário que não altera a variável sobre a qual é aplicado, pois ele retorna o valor da variável multiplicado por ‐1.

O operador / (divisão) quando aplicado a variáveis inteiras, nos fornece o resultado da divisão inteira; quando aplicado a variáveis em ponto flutuante nos fornece o resultado da divisão “real”. O operador % fornece o resto da divisão de dois inteiros.

Assim seja o seguinte trecho de código:

int a = 17, b = 3; int x, y; float z = 17., z1, z2; x = a / b; y = a % b; z1 = z / b; z2 = a/b;

ao final da execução destas linhas, os valores calculados seriam x = 5, y = 2, z1 = 5.666666 e z2 = 5.0. Note que, na linha correspondente a z2, primeiramente é feita uma divisão inteira (pois os dois operandos são inteiros). Somente após efetuada a divisão é que o resultado é atribuído a uma variável float.

Os operadores de incremento e decremento são unários que alteram a variável sobre a qual estão aplicados. O que eles fazem é incrementar ou decrementar, a variável sobre a qual estão aplicados, de 1. Então:

x++;

x--;

são equivalentes a:

x=x+1;

x=x-1;

Estes operadores podem ser pré‐fixados ou pós‐ fixados. A diferença é que quando são pré‐fixados eles incrementam e retornam o valor da variável já incrementada. Quando são pós‐fixados eles retornam o valor da variável sem o incremento e depois incrementam a variável. Então, em:

x=23;

y=x++;

teremos, no final, y=23 e x=24. Em:

x=23;

y=++x;

teremos, no final, y=24 e x=24.

17

Observações:

• Todos os operadores são definidos para os tipos inteiros e não inteiros, exceto o operador resto (%) que não é definido para variáveis dos tipos não inteiros.

• Para qualquer tipo inteiro, a adição de um ao maior número da faixa daquele tipo produz o menor número da faixa. Os erros de estouro nem sempre são detectados, cabendo ao programador tomar cuidado ao dimensionar as variáveis do programa para que eles não ocorram.

Exemplo:

unsigned char x; x = 255; x = x + 1; /* x deveria assumir 256, no entanto estoura a faixa e retorna para o menor valor que é 0 */

2.10. Operadores relacionais e Lógicos

São operadores que permitem comparar valores, ou seja, são utilizados principalmente em comandos que possuem condições:

Operador Ação> Maior do que>= Maior ou igual a< Menor do que<= Menor ou igual a== Igual a!= Diferente de

Os operadores relacionais retornam verdadeiro (1) ou falso (0). Para verificar o funcionamento dos operadores relacionais, execute o programa abaixo:

/* Este programa ilustra o funcionamento dos operadores relacionais. */ #include <stdio.h> int main(){

int i, j; printf("\nEntre com dois números inteiros: "); scanf("%d%d", &i, &j); printf("\n%d == %d é %d\n", i, j, i==j); printf("\n%d != %d é %d\n", i, j, i!=j); printf("\n%d <= %d é %d\n", i, j, i<=j); printf("\n%d >= %d é %d\n", i, j, i>=j); printf("\n%d < %d é %d\n", i, j, i<j); printf("\n%d > %d é %d\n", i, j, i>j); return(0);

}

18

Você pode notar que o resultado dos operadores relacionais é sempre igual a 0 (falso) ou 1 (verdadeiro).

Para fazer operações com valores lógicos (verdadeiro e falso) temos os operadores lógicos:

Operador Ação&& AND (E)|| OR (OU)! NOT (NÃO)

Exemplo: No trecho de programa abaixo a operação j++ será executada, pois o resultado da expressão lógica é verdadeiro:

int i = 5, j =7; if ( (i > 3) && ( j <= 7) && ( i != j) ) j++; V AND V AND V = V

2.11. Operadores Lógicos Bit a Bit

O C permite que se faça operações lógicas "bit‐a‐bit" em números. Ou seja, neste caso, o número é representado por sua forma binária e as operações são feitas em cada bit dele. Imagine um número inteiro de 16 bits, a variável i, armazenando o valor 2. A representação binária de i, será: 0000000000000010 (quinze zeros e um único 1 na segunda posição da direita para a esquerda). Poderemos fazer operações em cada um dos bits deste número. Por exemplo, se fizermos a negação

do número (operação binária NOT, ou operador binário ~ em C), isto é, ~i, o número se transformará em 1111111111111101. As operações binárias ajudam programadores que queiram trabalhar com o computador em "baixo nível". As operações lógicas bit a bit só podem ser usadas nos tipos char, int e long int. Os operadores são:

Operador Ação& AND| OR^ XOR (OR exclusivo)~ NOT>> Deslocamento de bits à direita<< Deslocamento de bits à esquerda

Os operadores &, |, ^ e ~ são as operações lógicas bit a bit. A forma geral dos operadores de deslocamento é:

valor>>número_de_deslocamentos

valor<<número_de_deslocamentos

O número_de_deslocamentos indica o quanto cada bit irá ser deslocado. Por exemplo, para a variável i anterior, armazenando o número 2:

19

i << 3;

fará com que i agora tenha a representação binária: 0000000000010000, isto é, o valor armazenado em i passa a ser igual a 16.

2.12. Expressões

Expressões são combinações de variáveis, constantes e operadores. Quando montamos expressões temos que levar em consideração a ordem com que os operadores são executados, conforme a tabela de precedências da linguagem C.

Exemplos de expressões:

Anos=Dias/365.25; i = i+3; c = a*b + d/e; c = a*(b+d)/e;

Conversão de tipos em expressões

Quando o C avalia expressões onde temos variáveis de tipos diferentes o compilador verifica se as conversões são possíveis. Se não são, ele não compilará o programa, dando uma mensagem de erro. Se as conversões forem possíveis ele as faz, seguindo as regras abaixo:

• Todos os chars e short ints são convertidos para ints. Todos os floats

são convertidos para doubles.

• Para pares de operandos de tipos diferentes: se um deles é long double o outro é convertido para long double; se um deles é double o outro é convertido para double; se um é long o outro é convertido para long; se um é unsigned o outro é convertido para unsigned.

Exemplo:

float x, res; char c; ... res = x/c; /* o valor de x/c é convertido para um float, embora c

seja originalmente um char */

Conversão explícita de tipos (type casts)

É possível forçar uma expressão a ser de um tipo específico, sem no entanto mudar os tipos das variáveis envolvidas nesta expressão. Esse tipo de operação chama‐se conversão explícita de tipo, ou type cast.

A forma geral de um type cast é:

20

(tipo) expressão;

onde tipo é um dos tipos de dado padrão da linguagem C.

As operações de type cast são muito úteis em expressões nas quais alguma operação resulta em perda de precisão devido ao tipo das variáveis ou constantes envolvidas. Por exemplo:

float res; int op1,op2; op1 = 3; op2 = 2; res = op1 / op2; /* res recebe 1, já que op1 e op2 são ambos números do tipo int e o resultado da sua divisão também é int */ res = (float)op1 / op2; /* res recebe 1.5, já que o type cast forçou o operando op1 a ser um float nesta operação. O resultado da divisão, por consequência, também é float */

Expressões que Podem ser Abreviadas

O C admite as seguintes equivalências, que podem ser usadas para simplificar expressões ou para facilitar o entendimento de um programa:

Expressão Original Expressão Equivalentex=x+k; x+=k;x=x‐k; x‐=k;x=x*k; x*=k;x=x/k; x/=k;x=x>>k; x>>=k;x=x<<k; x<<=k;x=x&k; x&=k;

etc...

Encadeando expressões: o operador ,

O operador , determina uma lista de expressões que devem ser executadas seqüencialmente. Em síntese, a vírgula diz ao compilador: execute as duas expressões separadas pela vírgula, em seqüência. O valor retornado por uma expressão com o operador , é sempre dado pela expressão mais à direita. No exemplo abaixo:

x=(y=2,y+3);

o valor 2 vai ser atribuído a y, se somará 3 a y e o retorno (5) será atribuído à variável x . Pode‐se encadear quantos operadores , forem necessários.

21

2.13. Tabela de Precedências do C

Esta é a tabela de precedência dos operadores em C. Alguns (poucos) operadores ainda não foram estudados, e serão apresentados em aulas posteriores.

Maior () [] -> ! ~ ++ -- . -(unário) * / % + - << >> <<= >>= == != & ^ | && || ? = += -= *= /= Menor ,

2.14. Espaçamento e parênteses

Podemos colocar espaços em uma expressão para torná‐la mais legível. O uso de parênteses redundantes ou adicionais não causará erros ou diminuirá a velocidade de execução da expressão.

Exemplo:

a=b/9.67-56.89*x-34.7; a = (b / 9.67) – (56.89 * x) – 34.7; /* equivalente */

2.15. Estrutura de um programa em C

Uma particularidade interessante no programa C é seu aspecto modular e funcional, em que o próprio programa principal é uma função. Esta forma de apresentação da linguagem facilita o desenvolvimento de programas, pois permite o emprego de formas estruturadas e modulares encontradas em outras linguagens.

22

A estrutura de um programa em C possui os seguintes elementos, sendo que aqueles delimitados por colchetes são opcionais:

[ definições de pré-processamento ] [ definições de tipo ] [ declarações de variáveis globais ] [ protótipos de funções ] [ funções ] int main ( ){

/* definições de variáveis */ /* corpo da função principal, com declarações de suas variáveis, seus comandos e funções */

}

Definições de pré‐processamento são comandos interpretados pelo compilador, em tempo de compilação, que dizem respeito a operações realizadas pelo compilador para geração de código. Geralmente iniciam com uma cerquilha (#) e não são comandos da linguagem C (detalhados posteriormente).

Exemplo:

#include <stdio.h> /* comando de pré-processador, utilizado para indicar ao compilador que ele deve ´colar´ as definições do arquivo stdio.h neste arquivo antes de compilá-lo */

Definições de tipos são definições de estruturas ou tipos de dados especiais, introduzidos pelo usuário para facilitar a manipulação de dados pelo programa (detalhados posteriormente).

Declarações de variáveis globais são feitas quando é necessário utilizar variáveis globais no programa. O conceito de variável global e as vantagens e desvantagens do seu uso dizem respeito à modularização (funções) de um programa em C.

Protótipos de funções e funções também dizem respeito a questões de modularização.

main() é a função principal de um programa em C, contendo o código que será inicialmente executado quando o programa em si for executado. Todo programa em C deve conter a

função main(), do contrário será gerado um erro durante o processo de geração do programa (mais especificamente, na etapa de ligação).

23

3. Funções básicas de entrada e saída Esta seção descreve algumas das funções básicas de E/S, que serão utilizadas inicialmente

para prover o programador de um canal de entrada de dados via teclado e um canal de saída de dados via monitor.

3.1. Função printf( ) (biblioteca stdio.h)

A função printf( ) é basicamente utilizada para enviar informações ao monitor, ou seja, imprimir informações. O seu protótipo é o seguinte:

printf("string de controle", lista de variáveis);

String de controle: é uma máscara que especifica (formata) o que será impresso e de que maneira será impresso na tela.

Exemplo:

Instrução Saída printf(“Ola’, Mundo!“); Ola’, Mundo! printf(“linha 1 \nlinha 2 “); linha 1

linha 2

Observe que na primeira instrução, a saída é exatamente igual à string de controle. Já na

segunda instrução a impressão se deu em duas linhas. Isto se deve ao \n que representa o código ASCII para quebra de linha .

Nesta mascara é possível reservar espaço para o valor de alguma variável usando especificadores de formato. Um especificador de formato marca o lugar e o formato de impressão das variáveis contidas na lista variáveis. Deve haver um especificador de formato para cada variável a ser impressa. Todos os especificadores de formato começam com um %.

Exemplo:

Código Imprime printf ("%-5.2f",456.671); | 456.67| printf ("%5.2f",2.671); | 2.67|printf ("%-10s","Ola"); |Ola |

Nos exemplos o "pipe" ( | ) indica o início e o fim do campo mas não são escritos na tela.

Depois do sinal %, seguem‐se alguns modificadores, cuja sintaxe é a seguinte:

% [flag] [tamanho] [.precisão] espeficadores_formato

[flag] justificação de saída: (Opcional)

24

• (-) : Alinha o resultado à esquerda. Preenche o restante do campo com brancos. Se não é colocado, alinha o resultado à direita e preenche o restante à esquerda com zeros ou brancos.

• (+): O resultado sempre começa com o sinal + ou ‐

• (#): Especifica que o argumento será impresso usando uma das formas alternativas

[tamanho] especificação de tamanho (Opcional)

• n: pelo menos n dígitos serão impressos (dígitos faltantes serão completados por brancos).

• 0n: pelo menos n dígitos serão impressos (dígitos faltantes serão completados por zeros).

[.precisão] especificador de precisão, dígitos a direita do ponto decimal. (Opcional)

• (nada) padrão: 6 dígitos para reais.

• .0: nenhum digito decimal.

• .n: são impressos n dígitos decimais.

especificadores_formado: comando de formatação de tipo (Requerido)

Código Tipo Formatos char * String (vetor de caracteres) d int Inteiro decimal com sinal i int Inteiro decimal com sinalo int Inteiro octal sem sinal u int Inteiro decimal sem sinal x int Inteiro hexadecimal sem sinal (com a, b, c, d, e, f) X int Inteiro hexadecimal sem sinal (com A, B, C, D, E, F)f float Valor com sinal da forma [‐]dddd.dddd e float Valor com sinal da forma [‐]d.dddd e [+/‐]ddd g float Valor com sinal na forma e ou f baseado na precisão do valor dado E float Mesmo que e, mas com E para expoenteG float Mesmo que g, mas com E para expoente c char Um caracter % nada O caracter % é impresso n int * Armazena o número de caracteres escritos até o momento p ponteiro imprime como um ponteiro

25

Os principais caracteres de controle especiais que auxiliam a formação da impressão na tela são:

Código Significado \a sinal audível \b retrocesso do cursor\f alimentação de formulário \n nova linha \r retorno de carro\t tabulação horizontal\’ aspas \’ apóstrofo \0 nulo (zero)\\ barra invertida \v tabulação vertical \a sinal sonoro \N constante octal (onde N é um octal)\xN constante hexadecimal (onde N é um hexadecimal)

Exemplos:

1)

int n = 15; printf(“O valor de n eh %d”, n); /* exibe Ó valor de n eh 15´. Note-se que todo o conteúdo da string de dados e formato é exibido literalmente, com exceção do especificador %d, que é substituído pelo valor em formato inteiro da variável n */

2)

char carac = Á´; float num = 3.16; printf(“A letra eh %c e o numero eh %f”, carac, num); /* exibe Á letra eh A e o numero eh 3.16´. Neste caso, o especificador %c (primeiro da string) é substituído pelo valor da variável carac e o especificador %f é substituído pelo valor da variável num. Note-se que os tipos dos especificadores e das variáveis são compatíveis */

Função scanf() (biblioteca stdio.h)

A função scanf é utilizada para receber dados de uma entrada de dados padrão. Consideraremos, para fins de simplificação, que essa entrada padrão é sempre o teclado. O protótipo de scanf é o seguinte:

scanf (string de formato, &var1, &var2, …, &varN);

26

onde a string de formato contém os especificadores de formato na seqüência e relativos a cada um dos dados que se pretende receber. Para uma lista dos especificadores de formato mais utilizados, ver seção 3.1.

var1 a varN identificam as variáveis nas quais serão armazenados os valores recebidos por scanf, na mesma ordem determinada pelos especificadores de formato. O número N deve ser igual ao número de especificadores de formato fornecidos.

IMPORTANTE: o operador de endereço (&) DEVE obrigatoriamente ser utilizado diante dos identificadores das variáveis, do contrário ocorre um erro. Para maiores detalhes, consultar a teoria sobre ponteiros.

Exemplos:

1)

int t; printf(“Digite um inteiro: “); scanf(“%d”, &t); /* aguarda a digitação de um número do tipo int. O número digitado é armazenado na variável t quando o usuário digita ENTER */

2)

char carac1; float i; printf(“Digite um caracter e um float, separados por vírgula: “); scanf(“%c, %f”, &carac1, &i); /* neste caso, os especificadores de formato %c e %f estão separados por vírgula, o que significa que o usuário deve digitar os valores também separados por vírgula e na ordem correta */

3.2. Dois Primeiros Programas

Vejamos um primeiro programa em C:

#include <stdio.h> /* Um Primeiro Programa */ int main () {

printf ("Ola! Eu estou vivo!\n"); return(0);

}

Compilando e executando este programa você verá que ele coloca a mensagem Ola! Eu estou vivo! na tela.

27

Análise do Programa

A linha #include <stdio.h> diz ao compilador que ele deve incluir o arquivo‐cabeçalho stdio.h. Neste arquivo existem declarações de funções úteis para entrada e saída de dados (std = standard, padrão em inglês; io = Input/Output, entrada e saída ==> stdio = Entrada e saída padronizadas). Toda vez que você quiser usar uma destas funções deve‐se incluir este comando. O C possui diversos Arquivos‐cabeçalho.

Ao fazer um programa, uma boa idéia é usar comentários que ajudem a elucidar o funcionamento do mesmo. No caso acima temos um comentário: /* Um Primeiro Programa */. O compilador C desconsidera qualquer coisa que esteja começando com /* e terminando com */. Um comentário pode, inclusive, ter mais de uma linha.

A linha int main() indica que estamos definindo uma função de nome main. Todos os programas em C têm que ter uma função main, pois é esta função que será chamada quando o programa for executado. O conteúdo da função é delimitado por chaves { }. O código que estiver dentro das chaves será executado seqüencialmente quando a função for chamada. A palavra int indica que esta função retorna um inteiro. O que significa este retorno será visto posteriormente, quando estudarmos um pouco mais detalhadamente as funções do C. A última linha do programa, return(0); , indica o número inteiro que está sendo retornado pela função, no caso o número 0.

A única coisa que o programa realmente faz é chamar a função printf(), passando a string (uma string é uma seqüência de caracteres, como veremos brevemente) "Ola! Eu estou vivo!\n" como argumento. É por causa do uso da função printf() pelo programa que devemos incluir o arquivo‐ cabeçalho stdio.h. A função printf() neste caso irá apenas colocar a string na tela do computador. O \n é uma constante chamada de constante barra invertida. No caso, o \n é a constante barra invertida de "new line" e ele é interpretado como um comando de mudança de linha, isto é, após imprimir Ola! Eu estou vivo! o cursor passará para a próxima linha. É importante observar também que os comandos do C terminam com ; .

Podemos agora tentar um programa mais complicado:

#include <stdio.h> int main (){ int Dias; /* Declaracao de Variaveis */

float Anos; printf ("Entre com o número de dias: "); /* Entrada de Dados */ scanf ("%d",&Dias); Anos=Dias/365.25; /* Conversao Dias->Anos */ printf ("\n\n%d dias equivalem a %f anos.\n",Dias,Anos); return(0);

}

Análise do Programa

São declaradas duas variáveis chamadas Dias e Anos. A primeira é um int (inteiro) e a segunda um float (ponto flutuante). As variáveis declaradas como ponto flutuante existem para armazenar números que possuem casas decimais, como 5,1497.

É feita então uma chamada à função printf(), que coloca uma mensagem na tela.

28

Queremos agora ler um dado que será fornecido pelo usuário e colocá‐lo na variável inteira Dias. Para tanto usamos a função scanf(). A string "%d" diz à função que iremos ler um inteiro. O segundo parâmetro passado à função diz que o dado lido deverá ser armazenado na variável Dias. É importante ressaltar a necessidade de se colocar um & antes do nome da variável a ser lida quando se usa a função scanf(). O motivo disto só ficará claro mais tarde. Observe que, no C, quando temos mais de um parâmetro para uma função, eles serão separados por vírgula.

Temos então uma expressão matemática simples que atribui a Anos o valor de Dias dividido por 365.25 (365.25 é uma constante ponto flutuante 365,25). Como Anos é uma variável float o compilador fará uma conversão automática entre os tipos das variáveis (veremos isto com detalhes mais tarde).

A segunda chamada à função printf() tem três argumentos. A string "\n\n%d dias equivalem a %f anos.\n" diz à função para pular duas linhas, colocar um inteiro na tela, colocar a mensagem "dias equivalem a", colocar um valor float na tela, colocar a mensagem "anos." e pular outra linha. Os outros parâmetros são as variáveis, Dias e Anos, das quais devem ser lidos os valores do inteiro e do float, respectivamente.

29

4. Estruturas de controle As estruturas de controle de fluxo são fundamentais para qualquer linguagem de

programação. Sem elas só haveria uma maneira do programa ser executado: de cima para baixo comando por comando. Não haveria condições, repetições ou saltos. A linguagem C possui diversos comandos de controle de fluxo. É possível resolver todos os problemas sem utilizar todas elas, mas devemos nos lembrar que a elegância e facilidade de entendimento de um programa dependem do uso correto das estruturas no local certo.

4.1. Comando simples

São comandos, que no fluxo de controle do programa, são sempre executados passando a execução para a próxima instrução, ou seja, todos os comandos de seqüência são executados desde que eles não dependem de um comando de seleção.

Exemplo: (todas as instruções abaixo são de seqüência)

system(“clear”); // limpa a tela printf("Digite um valor: "); scanf("%f",&valor); // entrada de dados via teclado resp = valor * 1.25; // atribuição é um comando de seqüência

4.2. Bloco de comandos

Utiliza‐se chaves ( { } ) para delimitar blocos de comando em um programa em C. Estes são mais utilizados no agrupamento de instruções para execução pelas cláusulas das estruturas condicionais e de repetição.

4.3. Estruturas de Seleção

Estrutura if-else

Sintaxe:

if ( condição ){ bloco de comandos 1;

} else {

bloco de comandos 2; }

30

condição é qualquer expressão que possa ser avaliada com o valor verdadeiro (“true”) ou falso (“false”). No caso de expressões que possuam um valor numérico ao invés de um valor lógico, se o valor é diferente de zero a expressão é avaliada com valor lógico “true”, do contrário é avaliada com o valor lógico “false”.

Caso a condição possua um valor lógico “true”, bloco de comandos 1 é executado. Se o valor lógico da condição for “false”, bloco de comandos 2 é executado. Para qualquer um dos blocos, se este for formado por um único comando as chaves são opcionais.

A estrutura if-else é semelhante a uma estrutura condicional composta, em que um ou outro bloco de comandos é executado; a cláusula else, no entanto, é opcional, e se for omitida a estrutura passa a funcionar como uma estrutura condicional simples, em que um bloco de comandos (no caso, o bloco 1) somente é executado se a condição for verdadeira.

Exemplos:

1)

int num; printf(“Digite um numero: “); scanf(“%d”, &num); if (num < 0){ /*testa se num é menor que zero */

/* bloco de comandos executado se a condição é verdadeira. Neste caso, como printf é um único comando as chaves poderiam ser omitidas */

printf(“\nO número é menor que zero”);

} else {

/* bloco de comandos executado se a condição é falsa. Neste caso, como printf é um único comando as chaves poderiam ser omitidas */

printf(“\nO número é maior que zero”);

}

2)

if ((a == 2) && (b == 5)) /* condição com operação lógica */ printf(“\nCondição satisfeita”); /* bloco de comandos */

system(“clear”); /* esta instrução não faz parte da estrutura condicional, logo é sempre executada */

Estrutura if-else-if

31

A estrutura if-else-if é apenas uma extensão da estrutura if-else. Sua forma geral pode ser escrita como sendo:

if (condição_1){ bloco de comandos 1;

} else if (condição_2){

bloco de comandos 2; } else if (condição_3){

bloco de comandos 3; } . . . else if (condição_n) {

bloco de comandos n; } else declaração_default;

A estrutura acima funciona da seguinte maneira: o programa começa a testar as condições começando pela 1 e continua a testar até que ele ache uma expressão cujo resultado dê diferente de zero. Neste caso ele executa a declaração correspondente. Só uma declaração será executada, ou seja, só será executada a declaração equivalente à primeira condição que der diferente de zero. A última declaração (default) é a que será executada no caso de todas as condições darem zero e é opcional.

Um exemplo da estrutura acima:

#include <stdio.h> int main (){

int num; printf ("Digite um numero: "); scanf ("%d",&num); if (num>10) printf ("\n\nO numero e maior que 10"); else if (num==10){ printf ("\n\nVoce acertou!\n"); printf ("O numero e igual a 10."); } else if (num<10) printf ("\n\nO numero e menor que 10"); return(0); }

ifs aninhados

O if aninhado é simplesmente um if dentro da declaração de um outro if externo. O único cuidado que devemos ter é o de saber exatamente a qual if um determinado else está ligado.

32

Exemplo:

#include <stdio.h> int main (){ int a, m; printf ("Digite um ano e mês: "); scanf ("%d%d",&a, &m); if (m == 3){ if ((a >=1) && (a <= 31)){ /* este if faz parte do bloco de

comandos do if anterior */ printf(“Data OK”); } else{ /* este else é do if mais proximo (que faz parte do bloco de comandos) */ printf(“Data inválida”);

} }

return(0); }

O Operador ?

Uma expressão como:

if (a>0) b=-150;

else b=150;

pode ser simplificada usando‐se o operador ? da seguinte maneira:

b=a>0?-150:150;

De uma maneira geral expressões do tipo:

if (condição) expressão_1;

else expressão_2;

podem ser substituídas por:

condição ? expressão_1 : expressão_2;

O operador ? é limitado (não atende a uma gama muito grande de casos) mas pode ser usado para simplificar expressões complicadas. Uma aplicação interessante é a do contador circular.

33

Exemplo:

#include <stdio.h> int main(){

int index = 0, contador; char letras[5] = "Joao"; for (contador=0; contador < 1000; contador++){

printf("\n%c",letras[index]); (index==3) ? index=0: ++index;

} }

O nome Joao é escrito na tela verticalmente até a variável contador determinar o término do programa. Enquanto isto a variável index assume os valores 0, 1, 2, 3, , 0, 1, ... progressivamente.

Estrutura Switch

O comando if-else e o comando switch são os dois comandos de tomada de decisão. Sem dúvida alguma o mais importante dos dois é o if, mas o comando switch tem aplicações valiosas. Mais uma vez vale lembrar que devemos usar o comando certo no local certo. Isto assegura um código limpo e de fácil entendimento. O comando switch é próprio para se testar uma variável em relação a diversos valores pré‐estabelecidos. Sua forma geral é:

switch (variável){ case constante_1 : seqüência de comandos; break; case constante_2 : seqüência de comandos;

break; . . .

default: seqüência de comandos; }

O programa testa uma variável sucessivamente contra uma lista de constantes inteiras ou caracteres (int ou char). Depois de encontrar uma coincidência, o programa executa o comando ou bloco de comandos que estejam associados àquela constante. O comando default é executado se não houver nenhuma coincidência. O comando break é utilizado para obrigar a saída do comando switch, se o comando break for esquecido ao final de uma seqüência de comandos, a execução continuará pela próxima declaração case até que um break ou o final do switch seja encontrado, o que normalmente é indesejado. A opção default é opcional. Uma declaração switch é mais eficiente que um encadeamento if-else, além do que pode ser escrito de forma muito mais “elegante”. Observação: A variável não pode ser uma string (char *) e nem real (float).

34

Exemplo


int digito; printf("Dígito [0 .. 9]: "); scanf("%d", &digito); switch (digito){

case 0: printf("Zero\n"); break;

case 1: printf("Um\n"); break;

case 2: printf("Dois\n"); break;

case 3: printf("Três\n"); break;

case 4: printf("Quatro\n"); break;

case 5: printf("Cinco\n"); break;

case 6: printf("Seis\n"); break;

case 7: printf("Sete\n"); break;

case 8: printf("Oito\n"); break;

case 9: printf("Nove\n"); break;

default: printf("ERRO: Não é um digito\n"); } }

4.4. Estruturas de Repetição

Estrutura while

Sintaxe:

while (condição){

sequência de comandos; }

O comando while avalia o valor lógico de condição; se o valor lógico for verdadeiro (true) a seqüência de comandos é executada, caso contrário a execução do programa continua após a estrutura while. Caso a seqüência de comandos seja formada por um único comando, o uso das chaves é opcional.

Após a execução da seqüência de comandos, o valor lógico de condição é reavaliado, e se continuar sendo verdadeiro (true) a seqüência de comandos é executada novamente. Este comportamento se repete até que o valor lógico da condição seja falso (false), quando a execução da estrutura while é interrompida e continua na instrução seguinte.

35

Cada uma das execuções da seqüência de comandos é chamada de iteração do laço. No caso da estrutura while o número de iterações pode variar de 0 até N, sendo N o número da iteração após a qual o teste da condição resulta em um valor lógico falso.

Observação: caso a condição seja verdadeira no primeiro teste e a seqüência de comandos seja executada, é necessário que esta torne a condição falsa em algum momento; do contrário, a condição sempre será reavaliada como verdadeira e a seqüência de comandos será executada em um número infinito de iterações.

O programa abaixo é executado enquanto i for menor que 100.


int i = 0; while ( i < 100){

printf(" %d", i); i++; } return(0); }

O programa abaixo espera o usuário digitar a tecla 'q' e só depois finaliza:


char Ch; Ch='\0'; while (Ch!='q'){ scanf("%c", &Ch); } return(0); }

Estrutura do – while

Sintaxe:

do {

sequência de comandos

} while (condição);

A seqüência de comandos sempre é executada inicialmente em uma estrutura do-while. Após a sua execução, o valor lógico da condição é avaliado, e se for verdadeiro (true) a seqüência de comandos é executada novamente. O ciclo se repete até que o valor lógico da

36

condição seja falso (false), quando a execução continua na instrução seguinte à estrutura do-while. Caso a seqüência de comandos seja formada por um único comando, o uso das chaves é opcional.

Diferentemente do que ocorre na estrutura while, na estrutura do-while o número de iterações varia entre 1 e N, onde N é o número da iteração após a qual o teste da condição resulta em um valor lógico falso.

Observação: assim como na estrutura while, caso a condição seja verdadeira no primeiro teste é necessário que a seqüência de comandos torne a condição falsa em algum momento.

Um dos usos da estrutura do-while é em menus, nos quais você quer garantir que o valor digitado pelo usuário seja válido, conforme apresentado abaixo:

#include <stdio.h> int main () {

int i; do{

printf ("\n\nEscolha a fruta pelo numero:\n\n"); printf ("\t(1)...Mamao\n"); printf ("\t(2)...Abacaxi\n"); printf ("\t(3)...Laranja\n\n"); scanf("%d", &i);

} while ((i<1)||(i>3)); switch (i){

case 1: printf ("\t\tVoce escolheu Mamao.\n"); break;

case 2: printf ("\t\tVoce escolheu Abacaxi.\n"); break;

case 3: printf ("\t\tVoce escolheu Laranja.\n"); break; }

return(0); }

Estrutura for

Formato:

for (inicialização; condição; incremento){

seqüência de comandos;

}

A inicialização é executada uma única vez, no início da execução da estrutura for, e normalmente é uma atribuição utilizada para inicializar alguma variável de controle do laço.

Após a inicialização, o valor lógico da condição é testado. Se for verdadeiro (true), a seqüência de comandos é executada, do contrário a execução continua após a estrutura for. Ao

37

final da execução da seqüência de comandos, o comando correspondente ao incremento é executado, e a condição volta a ser testada. O ciclo se repete até que o teste da condição resulte em um valor lógico falso (false), quando então a execução prossegue após a estrutura for. Caso a seqüência de comandos seja formada por um único comando, o uso das chaves é opcional.

A estrutura for é equivalente a uma estrutura while com o seguinte formato:

inicialização

while (condição){

seqüência de comandos;

incremento;

}

Observações:

• Qualquer uma das cláusulas do cabeçalho (inicialização, condição ou incremento) pode ser omitida; no caso da omissão da inicialização ou do incremento considera‐se que estes são comandos nulos (ou seja, não executam nada), já na omissão da condição considera‐se que o seu valor lógico é sempre verdadeiro. Os sinais de ponto‐e‐vírgula que separam cada uma das cláusulas não podem ser omitidos.

• As cláusulas de inicialização e incremento podem se constituir de vários comandos cada uma; nesse caso, os comandos devem ser separados entre si por vírgulas.

Exemplos:

1)

/* neste caso, x é usado como variável de controle do laço (controla a execução entre 1 e 100) e também tem o seu valor impresso pela função printf */ for (x = 1; x <= 100; x++){

printf(“%d”, x); }

2) /* neste caso a sequência de comandos é nula, e o laço é utilizado somente para “gastar tempo” contando de 0 a 999 */ for (x = 0; x< 1000; x++);

3)

38

/* não há incremento, e o laço é executado até que o valor digitado pelo usuário seja 10 */ for (x = 0; x != 10;)

scanf(“%d”, &x);

4)

/* duas variáveis são inicializadas, testadas e incrementadas */ for (x = 0, y = 0; x + y < 100; x++, y++)

printf(“%d”, x + y);

O Comando break

O comando break pode quebrar a execução de um comando (como no caso do switch) ou interromper a execução de qualquer loop (como no caso do for, do while ou do do while). O break faz com que a execução do programa continue na primeira linha seguinte ao laço ou bloco que está sendo interrompido.

Observe que um break causará uma saída somente do laço mais interno. Por exemplo:

for(t=0; t<100; ++t){ count=1; for(;;){ printf("%d", count); count++; if(count==10) break; }

}

O código acima imprimirá os números de 1 a 10 cem vezes na tela. Toda vez que o break é encontrado, o controle é devolvido para o laço for externo.

Outra observação é o fato que um break usado dentro de uma declaração switch afetará somente os dados relacionados com o switch e não qualquer outro laço em que o switch estiver.

O Comando continue

O comando continue pode ser visto como sendo o oposto do break. Ele só funciona dentro de um laço. Quando o comando continue é encontrado, o laço pula para a próxima iteração, sem o abandono do laço, ao contrário do que acontecia no comando break. O programa abaixo exemplifica o uso do continue:

39


int opcao; while (opcao != 5){ printf("\n\n Escolha uma opcao entre 1 e 5: "); scanf("%d", &opcao); if ((opcao > 5)||(opcao <1))

continue; /* Opcao invalida: volta ao inicio do loop */ switch (opcao){ case 1: printf("\n --> Primeira opcao.."); break; case 2: printf("\n --> Segunda opcao.."); break; case 3: printf("\n --> Terceira opcao.."); break; case 4: printf("\n --> Quarta opcao.."); break; case 5: printf("\n --> Abandonando.."); break; } }

return(0); }

O programa acima ilustra uma aplicação simples para o continue. Ele recebe uma opção do usuário. Se esta opção for inválida, o continue faz com que o fluxo seja desviado de volta ao início do laço. Caso a opção escolhida seja válida o programa segue normalmente.

O Comando goto

O goto é o último comando de controle de fluxo. Ele pertence a uma classe à parte: a dos comandos de salto incondicional. O goto realiza um salto para um local especificado. Este local é determinado por um rótulo. Um rótulo, na linguagem C, é uma marca no programa. Você dá o nome que quiser a esta marca. Podemos tentar escrever uma forma geral:

nome_do_rótulo: .... goto nome_do_rótulo; ....

Devemos declarar o nome do rótulo na posição para a qual vamos dar o salto seguido de :. O goto pode saltar para um rótulo que esteja mais à frente ou para trás no programa. Uma observação importante é que o rótulo e o goto devem estar dentro da mesma função.

O comando goto deve ser utilizado com parcimônia, pois o abuso no seu uso tende a tornar o código confuso. O goto não é um comando necessário, podendo sempre ser substituído por outras estruturas de controle. Recomendamos que o goto nunca seja usado.

Existem algumas situações muito específicas onde o comando goto pode tornar um código mais fácil de se entender se ele for bem empregado. Um caso em que ele pode ser útil é quando

40

temos vários laços e ifs aninhados e se queira, por algum motivo, sair destes laços e ifs todos de uma vez. Neste caso um goto resolve o problema mais elegantemente que vários breaks, sem contar que os breaks exigiriam muito mais testes. Ou seja, neste caso o goto é mais elegante e mais rápido.

O exemplo da página anterior pode ser reescrito usando‐se o goto:


int opcao; while (opcao != 5){ REFAZ: printf("\n\n Escolha uma opcao entre 1 e 5: "); scanf("%d", &opcao); if ((opcao > 5)||(opcao <1))

goto REFAZ; /* Opcao inval.: volta ao rotulo REFAZ */

switch (opcao){ case 1: printf("\n --> Primeira opcao..");

break; case 2: printf("\n --> Segunda opcao..");

break; case 3: printf("\n --> Terceira opcao..");

break; case 4: printf("\n --> Quarta opcao..");

break; case 5: printf("\n --> Abandonando..");

break; } } return(0); }

41

5. Vetores, Matrizes e String 5.1. Vetores

Em muitas aplicações queremos trabalhar com conjuntos de dados que são semelhantes em tipo. Por exemplo o conjunto das alturas dos alunos de uma turma, ou um conjunto de seus nomes. Nestes casos, seria conveniente poder colocar estas informações sob um mesmo conjunto, e poder referenciar cada dado individual deste conjunto por um número índice. Em programação, este tipo de estrutura de dados é chamada de vetor (ou array, em inglês) ou, de maneira mais formal estruturas de dados homogêneas.

O vetor é declarado da seguinte maneira:

tipo_dos_dados nome_do_vetor [número_de_elementos];

onde tipo_dos_dados é o tipo de cada um dos elementos do vetor e numero_de_elementos é o número de elementos do vetor.

Para acessar um elemento do vetor a sintaxe é:

nome [índice];

Na linguagem C a numeração começa sempre em zero. A maneira mais simples de entender um vetor é através da visualização de uma lista de elementos com um nome coletivo e um índice de referência aos valores da lista.

n nota

0 8.4

1 6.9

2 4.5

3 4.6

4 7.2

Nesta lista, n representa um número de referência (índice) e nota é o nome do conjunto. Assim podemos dizer que a 2a nota é 6.9 ou representar nota[1] = 6.9. Neste caso, o vetor nota possui 5 elementos é indexado de 0 a 4. Mas ninguém o impede de escrever:

nota[5] nota[100]

Por quê? Na linguagem C, devemos ter cuidado com os limites de um vetor. Embora na sua declaração, tenhamos definido o tamanho de um vetor, o C não faz nenhum teste de verificação de acesso a um elemento dentro do vetor ou não. Portanto, os testes de limite devem ser feitos logicamente dentro do programa. Este fato se deve a maneira como o C trata vetores. A memória do

42

microcomputador é um espaço (físico) particionado em porções de 1 byte. Se declaramos um vetor como int vet[3], estamos reservando 6 bytes (3 segmentos de 2 bytes) de memória para armazenar os seus elementos. O primeiro segmento será reservado para vet[0], o segundo segmento para vet[1] e o terceiro segmento para vet[2]. O segmento inicial é chamado de segmento base, de modo que vet[0] será localizado no segmento base. Quando acessamos o elemento vet[i], o processador acessa o segmento localizado em base+i. Se i for igual a 2, estamos acessando o segmento base+2 ou vet[2](o ultimo segmento reservado para o vetor). Porém, se i for igual a 7, estamos a acessando segmento base+7 que não foi reservado para os elementos do vetor e que provavelmente está sendo usado por uma outra variável ou contém informação espúria (lixo).

Observe que acessar um segmento fora do espaço destinado a um vetor pode destruir informações reservadas de outras variáveis. Estes erros são difíceis de detectar pois o compilador não gera nenhuma mensagem de erro. A solução mais adequada é sempre avaliar os limites de um vetor antes de manipulá‐lo. A princípio este fato poderia parecer um defeito da linguagem, mas na verdade trata‐se de um recurso muito poderoso do C. Poder manipular sem restrições todos os segmentos de memória é uma flexibilidade apreciada pelos programadores.

Quando o C vê uma declaração de vetor ele reserva um espaço na memória suficientemente grande para armazenar o número de células especificadas em tamanho. Por exemplo, se declararmos:

float exemplo [20];

o C irá reservar 4x20=80 bytes. Estes bytes são reservados de maneira contígua.

Vamos ver agora um exemplo de utilização de vetores:

#include <stdio.h> int main () { int num[100]; /* Declara um vetor de inteiros de 100 posicoes */ int count=0; int totalnums; do{

printf ("\nEntre com um numero (-999 p/ terminar): "); scanf ("%d",&num[count]); count++; } while (num[count-1]!=-999); totalnums=count-1; printf ("\n\n\n\t Os números que você digitou foram:\n\n"); for (count=0;count<totalnums;count++) printf (" %d",num[count]); return(0); }

No exemplo acima, o inteiro count é inicializado em 0. O programa pede pela entrada de números até que o usuário entre com o Flag ‐999. Os números são armazenados no vetor num. A cada número armazenado, o contador do vetor é incrementado para na próxima iteração escrever na próxima posição do vetor. Quando o usuário digita o flag, o programa abandona o primeiro laço e

43

armazena o total de números gravados. Por fim, todos os números são impressos. É bom lembrar aqui que nenhuma restrição é feita quanto à quantidade de números digitados. Se o usuário digitar mais de 100 números, o programa tentará ler normalmente, mas o programa os escreverá em uma parte não alocada de memória, pois o espaço alocado foi para somente 100 inteiros. Isto pode resultar nos mais variados erros no instante da execução do programa.

5.2. Strings

Strings são vetores de chars. Nada mais e nada menos. As strings são o uso mais comum para os vetores. Devemos apenas ficar atentos para o fato de que as strings têm o seu último elemento como um '\0'. A declaração geral para uma string é:

char nome_da_string [tamanho];

Devemos lembrar que o tamanho da string deve incluir o '\0' final. A biblioteca padrão do C possui diversas funções que manipulam strings. Estas funções são úteis pois não se pode, por exemplo, igualar duas strings:

string1=string2; /* NAO faca isto */

Fazer isto é um desastre. Quando você terminar de ler a seção que trata de ponteiros você entenderá o porquê. As strings devem ser igualadas elemento a elemento.

Quando vamos fazer programas que tratam de string muitas vezes podemos fazer bom proveito do fato de que uma string termina com '\0' (isto é, o número inteiro 0). Veja, por exemplo, o programa abaixo que serve para igualar duas strings (isto é, copia os caracteres de uma string para o vetor da outra) :

#include <stdio.h> int main (){ int count; char str1[100],str2[100]; .... /* Aqui o programa le str1 que sera copiada para str2 */ for (count=0;str1[count];count++) str2[count]=str1[count]; str2[count]='\0'; .... /* Aqui o programa continua */ }

A condição no loop for acima é baseada no fato de que a string que está sendo copiada termina em '\0'. Quando o elemento encontrado em str1[count] é o '\0', o valor retornado para o teste condicional é falso (nulo). Desta forma a expressão que vinha sendo verdadeira (não zero) continuamente, torna‐se falsa.

Vamos ver agora algumas funções básicas para manipulação de strings.

gets

A função gets() lê uma string do teclado. Sua forma geral é:

44

gets (nome_da_string);

O programa abaixo demonstra o funcionamento da função gets():

#include <stdio.h> int main (){ char string[100]; printf ("Digite o seu nome: "); gets (string); printf ("\n\n Ola %s",string); return(0); }

Repare que é válido passar para a função printf() o nome da string. Você verá mais adiante porque isto é válido. Como o primeiro argumento da função printf() é uma string também é válido fazer:

printf (string);

isto simplesmente imprimirá a string.

strcpy

Sua forma geral é:

strcpy (string_destino,string_origem);

A função strcpy() copia a string‐origem para a string‐ destino. Seu funcionamento é semelhante ao da rotina apresentada na seção anterior. As funções apresentadas nestas seções estão no arquivo cabeçalho string.h. A seguir apresentamos um exemplo de uso da função strcpy():

#include <stdio.h> #include <string.h> int main (){ char str1[100],str2[100],str3[100]; printf ("Entre com uma string: "); gets (str1); strcpy (str2,str1); /* Copia str1 em str2 */ strcpy (str3,"Voce digitou a string "); /* Copia "Voce digitou a string" em str3 */ printf ("\n\n%s%s",str3,str2); return(0); }

strcat

A função strcat() tem a seguinte forma geral:

strcat (string_destino,string_origem);

A string de origem permanecerá inalterada e será anexada ao fim da string de destino. Um exemplo:

45

#include <stdio.h> #include <string.h> int main (){ char str1[100],str2[100]; printf ("Entre com uma string: "); gets (str1); strcpy (str2,"Voce digitou a string "); strcat (str2,str1); /* str2 armazenara' Voce digitou a string + o conteudo de str1 */ printf ("\n\n%s",str2); return(0); }

strlen

Sua forma geral é:

strlen (string);

A função strlen() retorna o comprimento da string fornecida. O terminador nulo não é contado. Isto quer dizer que, de fato, o comprimento do vetor da string deve ser um a mais que o inteiro retornado por strlen().

Um exemplo do seu uso:

#include <stdio.h> #include <string.h> int main (){ int size; char str[100]; printf ("Entre com uma string: "); gets (str); size=strlen (str); printf ("\n\nA string que voce digitou tem tamanho %d",size); return(0); }

strcmp

Sua forma geral é:

strcmp (string1,string2);

A função strcmp() compara a string 1 com a string 2 e retorna:

Valor positivo string1 > string2 Valor negativo string1 < string2 0 string1 == string2 !=0 string1 != string2

46

Um exemplo da sua utilização:

#include <stdio.h> #include <string.h> int main(void){ char s1[41],s2[41];

printf("String 1: "); scanf(“%s”,s1); printf("String 2: "); scanf(“%s”,s2); if (strcmp(s1,s2) == 0) printf("String 1 é IGUAL a String 2"); else if (strcmp(s1,s2) > 0)

printf("String 1 é MAIOR a String 2"); else

printf("String 1 é MENOR a String 2"); }

5.3. Matrizes

Matrizes bidimensionais

Já vimos como declarar matrizes unidimensionais (vetores). Vamos tratar agora de matrizes bidimensionais. A forma geral da declaração de uma matriz bidimensional é muito parecida com a declaração de um vetor:

tipo_da_variável nome_da_variável [altura][largura];

É muito importante ressaltar que, nesta estrutura, o índice da esquerda indexa as linhas e o da direita indexa as colunas. Quando vamos preencher ou ler uma matriz no C o índice mais à direita varia mais rapidamente que o índice à esquerda. Mais uma vez é bom lembrar que, na linguagem C, os índices variam de zero ao valor declarado, menos um; mas o C não vai verificar isto para o usuário. Manter os índices na faixa permitida é tarefa do programador.

A representação gráfica de uma matriz M 3x2 se dá da seguinte maneira:

M[0][0] M[0][1] M[1][0] M[1][1] M[2][0] M[2][1]

Na memória ela pode ser vista da seguinte forma (obs: os valores da esquerda representam endereços arbitrários de memória, considerando uma matriz de elementos char de um byte):

0100 M[0][0] 0101 M[0][1] 0102 M[1][0] 0103 M[1][1]0104 M[2][0] 0105 M[2][1]

47

Abaixo damos um exemplo do uso de uma matriz:


int mtrx [20][10]; int i,j,count; count=1; for (i=0;i<20;i++)

for (j=0;j<10;j++){ mtrx[i][j]=count; count++; }

return(0); }

No exemplo acima, a matriz mtrx é preenchida, seqüencialmente por linhas, com os números de 1 a 200. Você deve entender o funcionamento do programa acima antes de prosseguir.

Matrizes multidimensionais

O uso de matrizes multidimensionais na linguagem C é simples. Sua forma geral é:

tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];

Uma matriz N‐dimensional funciona basicamente como outros tipos de matrizes. Basta lembrar que o índice que varia mais rapidamente é o índice mais à direita.

Matrizes de strings

Matrizes de strings são matrizes bidimensionais. Uma string é um vetor. Se fizermos um vetor de strings estaremos fazendo uma lista de vetores. Esta estrutura é uma matriz bidimensional de chars. Podemos ver a forma geral de uma matriz de strings como sendo:

char nome_da_variável [num_de_strings][compr_das_strings];

Representação gráfica de uma matriz char m[3][8]:

0 1 2 3 4 5 6 7 0 ‘U’ ‘T’ ‘F’ ‘P’ ‘R’ ‘\0’ lixo lixo 1 ‘E’ ‘N’ ‘G’ ‘\0’ lixo lixo lixo lixo 2 ‘c’ ‘e’ ‘f’ ‘e’ ‘t’ ‘P’ ‘R’ ‘\0’

Aí surge a pergunta: como acessar uma string individual? Fácil. É só usar apenas o primeiro índice. Então, para acessar uma determinada string faça:

nome_da_variável [índice]

48

Aqui está um exemplo de um programa que lê 5 strings e as exibe na tela:


char strings [5][100]; int count; for (count=0;count<5;count++){

printf ("\n\nDigite uma string: "); gets (strings[count]); } printf ("\n\n\nAs strings que voce digitou foram:\n\n"); for (count=0;count<5;count++) printf ("%s\n",strings[count]);

return(0); }

49

6. Ponteiros 6.1. Introdução

Toda informação (dado armazenado em variável simples ou vetor) que manipulamos em um programa está armazenado na memória do computador. Cada informação é representada por um

certo conjunto de bytes. Por exemplo: caracter (char): 1 byte, inteiro (int): 2 bytes, etc.

Cada um destes conjuntos de bytes, que chamaremos de bloco, tem um nome e um endereço de localização especifica na memória.

Exemplo: Observe a instrução abaixo:

int num = 17;

ao interpretar esta instrução, o processador pode especificar:

Nome da informação: num

Tipo de informação: int

Tamanho do bloco (número de bytes ocupados pela informação): 2

Valor da informação: 17

Endereço da informação (localização do primeiro byte): 8F6F:FFF2 (hexadecimal)

Em geral, interessa ao programador apenas os nomes simbólicos que representam as informações, pois são com estes nomes que são realizadas as operações do seu algoritmo. Porém, ao processador interessa os endereços dos blocos de informação pois é com estes endereços que vai trabalhar.

6.2. Como Funcionam os Ponteiros

Os ints guardam inteiros. Os floats guardam números de ponto flutuante. Os chars guardam caracteres. Ponteiros são variáveis que contém endereços. Neste sentido, estas variáveis apontam para algum determinado endereço da memória. Em geral, o ponteiro aponta para o endereço de alguma variável declarada no programa.

Ponteiros são usados freqüentemente para:

• Acesso a E/S mapeada em memória

• Uso de alocação dinâmica de memória.

• Alternativa para passagem de parâmetros por referência (em C++)

50

6.3. Declaração de Ponteiros

Para declarar um ponteiro temos a seguinte forma geral:

tipo_do_ponteiro *nome_da_variável;

É o asterisco (*) que faz o compilador saber que aquela variável não vai guardar um valor mas sim um endereço para aquele tipo especificado. Vamos ver exemplos de declarações:

int *p; float* s_1, s_2;

A primeira instrução declara um ponteiro chamado p que aponta para um inteiro. Este ponteiro aponta para o primeiro endereço de um bloco de dois bytes. Sempre é necessário declarar o tipo do ponteiro. Neste caso dizemos que declaramos um ponteiro tipo int.

A segunda instrução declara dois ponteiros (s_1 e s_2) do tipo float. Observe que o * está justaposto ao tipo: assim todos os elementos da lista serão declarados ponteiros.

6.4. Operadores & e *

Quando trabalhamos com ponteiros, queremos fazer duas coisas basicamente:

• conhecer endereço de uma variável;

• conhecer o conteúdo de um endereço.

Para realizar estas tarefas a linguagem C nos providencia dois operadores especiais:

• o operador de endereço: &

• o operador de conteúdo: *

O operador de endereço (&) determina o endereço de uma variável (o primeiro byte do

bloco ocupado pela variável). Por exemplo, &val determina o endereço do bloco ocupado pela variável val. Esta informação não é totalmente nova pois já a usamos antes: na função scanf().

Exemplo: Quando se escreve a instrução:

scanf("%d", &num);

estamos nos referimos endereço do bloco ocupado pela variável num. A instrução significa: "leia o buffer do teclado, transforme o valor lido em um valor inteiro (2 bytes) e o armazene no bloco localizado no endereço da variável num".

Exemplo: Para se atribuir a um ponteiro o endereço de uma variável escreve‐se:

int *p, val=5; /* declaração de ponteiro e variável */ p = &val; /* atribuição */

51

Observe que o ponteiro p deve ser declarado anteriormente com o mesmo tipo da variável

para a qual ele deve apontar. O operador conteúdo (*) determina o conteúdo (valor) do dado

armazenado no endereço de um bloco apontado por um ponteiro. Por exemplo, *p determina

conteúdo do bloco apontado pelo ponteiro p. De forma resumida: o operador (*) determina o conteúdo de um endereço.

Exemplo: Para se atribuir a uma variável o conteúdo de um endereço escreve‐se:

int *p = 0x3f8, val; // declaração de ponteiro e variável val = *p; // atribuição

Observações:

• O operador endereço (&) somente pode ser usado em uma única variável. Não pode

ser usado em expressões como, por exemplo, &(a+b).

• O operador conteúdo (*) somente pode ser usado em variáveis ponteiros.

O programa mostra atribuições utilizando dois ponteiros.

#include <stdio.h> int main (void){

int x = 7; int *p1, *p2; p1 = &x; /* p1 recebe o endereço de x */ p2 = p1; /* p2 recebe o endereço de x */ printf("%p\n", &x); /* impresso endereço de x */ printf("%p\n", p1); /* impresso endereço de x */ printf("%p\n", p2); /* impresso endereço de x */ printf("%d\n", *p1); /* impresso valor de x (conteúdo de p1) */

}

6.5. Problemas no uso de ponteiros

Ponteiros sempre devem apontar para endereços correspondentes a variáveis que tenham sido declaradas ou a regiões de memória nas quais não existam dados ou código de outros

programas. Por exemplo, o seguinte código armazena o conteúdo da variável x em um endereço qualquer, que pode ser um endereço inválido.

int *ptr; int x = 3; *ptr = x; /* ERRO! Para onde o ptr aponta??? */

Ponteiros devem apontar para dados do mesmo tipo de sua declaração, do contrário podem ocorrer interpretações erradas na operação de derrenferenciação. Por exemplo, o seguinte código

não armazena o valor 56 na variável f, já que o ponteiro para float tentará ler o tamanho de um

dado float a partir do endereço de memória da variável x e não o tamanho de um int, que é o tipo declarado da variável x.

52

int x = 56; float *ptr; float f; ptr = &x; /* Ponteiro para float aponta para int */ . . . f = *ptr; /* ERRO! Valor de F não é 56 */

6.6. Operações elementares com ponteiros

Ponteiros são variáveis especiais e obedecem a regras especiais. Deste modo, existem uma série de operações (aritméticas, lógicas, etc.) envolvendo ponteiros que são permitidas e outras não. A seguir são destacadas algumas operações que podem ser executadas com ponteiros.

• A um ponteiro pode ser atribuído o endereço de uma variável comum.

Exemplo: Observe o trecho abaixo:

int *p; int s; p = &s; /* p recebe o endereço de s */

• Um ponteiro pode receber o valor de outro ponteiro, isto é, pode receber o endereço apontado por outro ponteiro, desde que os ponteiros sejam de mesmo tipo.


float *p1, *p2, val; p1 = &val; /* p1 recebe o endereço de val...*/ p2 = p1; /* e p2 recebe o conteúdo de p2 (endereço de val) */

• Um ponteiro pode receber um endereço de memória diretamente. Um endereço é um numero inteiro. Em geral, na forma hexadecimal (0x....). Nesta atribuição devemos, em geral, forçar uma conversão de tipo usando casting para o tipo de ponteiro declarado.


int *p1; float p2ç p1 = 0x03F8; /* endereço da porta serial COM1 */ p2 = (float)0x0FF6; // casting

53

• A um ponteiro pode ser atribuído o valor nulo usando a constante simbólica NULL (declarada na biblioteca stdlib.h). Um ponteiro com valor NULL não aponta para lugar nenhum!.


#include <stdlib.h> ... char *p; p = NULL;

• Uma quantidade inteira pode ser adicionada ou subtraída de um ponteiro. A adição de um inteiro n a um ponteiro p fará com que ele aponte para o endereço do n‐ésimo bloco seguinte.


int *p, *q, var; p = &var q = ++p; /* q aponta para o bloco seguinte ao ocupado por var */ p = q - 5; /* p aponta para o quinto bloco anterior a q */ (*p)++; /* incremente o conteúdo da variável apontada por p */ *(p+15); /* acessa o conteúdo apontado por p 15 posições adiante */

• Dois ponteiros podem ser comparados (usando‐se operadores lógicos) desde que sejam de mesmo tipo.


if(px == py){ /* se px aponta para o mesmo bloco que py ... */ if(px > py){ /* se px aponta para um bloco posterior a py ... */ if(px != py){ /* se px aponta para um bloco diferente de py ... */ if(px == NULL) /* se px é nulo... */

6.7. Ponteiros e Vetores

Na linguagem C, vetores são intimamente relacionados a ponteiros, pois o nome de um vetor é tratado como o endereço de seu primeiro elemento. Assim ao se passar o nome de um vetor para uma função está se passando o endereço do primeiro elemento de um conjunto de endereços de memória.

Por exemplo, se vet é um vetor, então vet e &vet[0] representam o mesmo endereço. E

mais, podemos acessar o endereço de qualquer elemento do vetor do seguinte modo: &vet[i] é equivalente a (vet + i). Aqui se deve ressaltar que (vet + i) não representa uma adição

aritmética normal mas o endereço do i‐ésimo elemento do vetor vet (endereço contado a partir do endereço inicial vet[0]).

54

Do mesmo modo que se pode acessar o endereço de cada elemento do vetor por ponteiros, também se pode acessar o valor de cada elemento usando ponteiros. Exemplo:

int a[10]; pa=&a[0]; /*passa o endereço inicial do vetor a para o ponteiro pa é a mesma coisa de pa=a; */ x=*pa; /*(passa o conteúdo de a[0] para x */

Se pa aponta para um elemento particular de um vetor a, então por definição pa+1 aponta para o próximo elemento, e em geral pa-i aponta para i elementos antes de pa; e pa+i para i elementos depois. Se *pa aponta para a[0] então: *(pa+1) aponta para a[1]. Portanto, pa+i é o endereço de a[i] e *(pa+i) é o conteúdo.

Sabemos agora que, na verdade, o nome de um vetor é um ponteiro constante. Sabemos também que podemos indexar o nome de um vetor. Como conseqüência podemos também indexar um ponteiro qualquer. O programa mostrado a seguir funciona perfeitamente:

#include <stdio.h> int main () { int matrx [10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int *p; p=matrx; printf ("O terceiro elemento do vetor e: %d",p[2]); return(0); }

Podemos ver que p[2] equivale a *(p+2).

Há uma diferença entre o nome de um vetor e um ponteiro que deve ser frisada: um ponteiro é uma variável, mas o nome de um vetor não é uma variável. Isto significa, que não se consegue alterar o endereço que é apontado pelo "nome do vetor". Seja:

int vetor[10]; int *ponteiro, i; ponteiro = &i; /* as operacoes a seguir sao invalidas */ vetor = vetor + 2; /* ERRADO: vetor nao e' variavel */ vetor++; /* ERRADO: vetor nao e' variavel */ vetor = ponteiro; /* ERRADO: vetor nao e' variavel */

Teste as operações acima no seu compilador. Ele dará uma mensagem de erro. Alguns compiladores dirão que vetor não é um Lvalue. Lvalue, significa "Left value", um símbolo que pode ser colocado do lado esquerdo de uma expressão de atribuição, isto é, uma variável. Outros compiladores dirão que tem‐se "incompatible types in assignment", tipos incompatíveis em uma atribuição.

/* as operacoes abaixo sao validas */ ponteiro = vetor; /* CERTO: ponteiro e' variavel */ ponteiro = vetor+2; /* CERTO: ponteiro e' variavel */

55

6.8. Ponteiros e Strings

Seguindo o raciocínio acima, nomes de strings, são do tipo char*. Isto nos permite escrever

a nossa função StrCpy(), que funcionará de forma semelhante à função strcpy() da biblioteca string.h:

#include <stdio.h> void StrCpy (char *destino,char *origem){

while (*origem){ *destino=*origem;

origem++; destino++;

} *destino='\0';

} int main (){

char str1[100],str2[100],str3[100]; printf ("Entre com uma string: "); gets (str1); StrCpy (str2,str1); StrCpy (str3,"Voce digitou a string "); printf ("\n\n%s%s",str3,str2); return(0);

}

Há vários pontos a destacar no programa acima. Observe que podemos passar ponteiros

como argumentos de funções. Na verdade é assim que funções como gets() e strcpy() funcionam. Passando o ponteiro você possibilita à função alterar o conteúdo das strings. Você já estava passando os ponteiros e não sabia. No comando while(*origem) estamos usando o fato

de que a string termina com '\0' como critério de parada. Quando fazemos origem++ e destino++ o leitor poderia argumentar que estamos alterando o valor do ponteiro‐base da string, contradizendo o que recomendei que se deveria fazer, no final de uma seção anterior. O que o leitor talvez não saiba ainda (e que será estudado em detalhe mais adiante) é que, no C, são passados para as funções cópias dos argumentos. Desta maneira, quando alteramos o ponteiro origem na função StrCpy() o ponteiro str2 permanece inalterado na função main().

6.9. Vetores de ponteiros

Declaração de um vetor de ponteiros de inteiros de tamanho 10.

int *x[10];

Atribuição do endereço de uma variável ao terceiro elemento do vetor de ponteiros:

x[2] = &variável; /* Para obter o valor da variável *x[2]; */

56

6.10. Ponteiros para Ponteiros

Um ponteiro para um ponteiro é como se você anotasse o endereço de um papel que tem o endereço da casa do seu amigo. Podemos declarar um ponteiro para um ponteiro com a seguinte notação:

tipo_da_variável **nome_da_variável;

Algumas considerações: **nome_da_variável é o conteúdo final da variável apontada; *nome_da_variável é o conteúdo do ponteiro intermediário.

No C podemos declarar ponteiros para ponteiros para ponteiros, ou então, ponteiros para ponteiros para ponteiros para ponteiros, e assim por diante. Para fazer isto a lógica é a mesma.

Para acessar o valor desejado apontado por um ponteiro para ponteiro, o operador asterisco deve ser aplicado duas vezes, como mostrado no exemplo abaixo:


float fpi = 3.1415, *pf, **ppf; pf = &fpi; /* pf armazena o endereco de fpi */ ppf = &pf; /* ppf armazena o endereco de pf */ printf("%f", **ppf); /* Imprime o valor de fpi */ printf("%f", *pf); /* Tambem imprime o valor de fpi */ return(0);

}

57

7. Funções Funções (também chamadas de rotinas, ou sub‐programas) são a essência da programação

estruturada. Funções são segmentos de programa que executam uma determinada tarefa específica. Algumas funções são já providenciadas pelas bibliotecas‐padrão do C, como por exemplo: sqrt() para cálculo de raiz quadrada, printf() para imprimir uma mensagem na tela, scanf() para ler um valor digitado pelo usuário, strcmp() que compara duas strings, entre tantas outras..

Entretanto, é possível ao programador, escrever suas próprias rotinas. Estas são as chamadas de funções de usuário ou rotinas de usuário. Deste modo pode‐se segmentar um programa grande em vários programas menores. Esta segmentação é chamada de modularização e permite que cada segmento seja escrito, testado e revisado individualmente sem alterar o funcionamento do programa como um todo. Permite ainda que um programa seja escrito por vários programadores ao mesmo tempo, cada um escrevendo um segmento separado. Neste capítulo, veremos como escrever funções de usuário em C.

A estrutura de uma função de usuário é muito semelhante à estrutura dos programas que escrevemos até agora. Uma função de usuário constitui‐se de um bloco de instruções que definem os procedimentos efetuados pela função, um nome pelo qual a chamamos e uma lista de argumentos passados a função. Chamamos este conjunto de elementos de definição da função. Uma função no C tem a seguinte forma geral:

tipo_de_retorno nome_da_função (declaração_de_parâmetros) { corpo_da_função

}

O tipo-de-retorno é o tipo de variável que a função vai retornar, neste caso no fim da

função deve existir um comando return (detalhado posteriormente). O default é o tipo int, ou seja, uma função para qual não declaramos o tipo de retorno é considerada como retornando um

inteiro. Caso a função não retorne valor algum, o tipo de retorno deve ser especificado como void. A declaração de parâmetros é uma lista com a seguinte forma geral:

tipo nome1, tipo nome2, ... , tipo nomeN

Repare que o tipo deve ser especificado para cada uma das N variáveis de entrada. É na declaração de parâmetros que informamos ao compilador quais serão as entradas da função (assim como informamos a saída no tipo-de-retorno).

O corpo da função é a sua alma. É nele que as entradas são processadas, saídas são geradas ou outras coisas são feitas.

O código mostrado abaixo é uma função definida pelo usuário para calcular a média aritmética de dois números reais:

58

float media2(float a, float b){ float med; med = (a + b) / 2.0; return(med);

}

No exemplo acima definimos uma função chamada media2 que recebe dois argumentos

tipo float: a e b. A média destes dois valores é calculada e armazenada na variável med declarada localmente na função, ou seja, esta variável existe apenas na função media2. A função retorna, para o programa que a chamou, um valor também do tipo float: o valor da variável med. Este retorno de valor é feito pela função return() que termina a execução da função e retorna o valor

de med para o programa que a chamou.

Depois de definirmos uma função, podemos usá‐la dentro de um programa qualquer. Dizemos que estamos fazendo uma chamada de função.

Exemplo: No exemplo abaixo chamamos a função media2() dentro de um programa principal:

#include<stdio.h> int main(){

float num_1, num_2, media; puts(”Digite dois números:”); scanf(”%f %f”, &num_1, &num_2); media = media2(num_1, num_2); /* chamada a função */ printf(”\nA media destes números e´ %f”, media);

}

7.1. Valores de Retorno por Funções

Todas as funções, exceto aquelas que são declaradas como sendo do tipo void, devolvem

um valor. O valor é devolvido (retornado) pela função através do comando return. Funções que não retornam nenhum valor (void), ou seja, são puramente procedimentos. O programa abaixo possui uma função void que limpa toda a tela em modo texto.

#include <stdio.h> void limpa_tela (void){

int c, l; for (l = 1; l <= 25; l++){

for (c = 1; c <= 80; c++) printf("%c",32); /* 32 é o código do caracter espaço */ printf(“\n”);

} } int main(void){

limpa_tela(); }

Conforme mencionado anteriormente, todo valor retornado por uma função é feito através

do uso de um comando return. Este comando tem a seguinte forma geral:

59

return valor_de_retorno; ou return;

Digamos que uma função está sendo executada. Quando se chega a uma declaração return a função é encerrada imediatamente e, se o valor de retorno é informado, a função retorna este valor. É importante lembrar que o valor de retorno fornecido tem que ser compatível com o tipo de retorno declarado para a função.

Uma função pode ter mais de uma declaração return. Isto se torna claro quando

pensamos que a função é terminada quando o programa chega à primeira declaração return. Abaixo está um programa que possui dois comandos return, porém apenas um será executado de acordo com as regras de programação realizadas.

#include <stdio.h> int EPar (int a){

if (a%2) /* Verifica se a e divisivel por dois */ return 0; /* Retorna 0 se nao for divisivel */ else return 1; /* Retorna 1 se for divisivel */ } int main (){ int num; printf ("Entre com numero: "); scanf ("%d",&num); if (EPar(num)) printf ("\n\nO numero e par.\n"); else printf ("\n\nO numero e impar.\n"); return 0; }

É importante notar que, como as funções retornam valores, podemos aproveitá‐los para fazer atribuições, ou mesmo para que estes valores participem de expressões. Mas não podemos fazer:

func(a,b)=x; /* Errado! */

Fato importante: se uma função retorna um valor você não precisa aproveitar este valor. Se você não fizer nada com o valor de retorno de uma função ele será descartado. Por exemplo, a

função printf() retorna um inteiro que nós nunca usamos para nada. Ele é descartado. Outro fato importante se deve que em C apenas um valor é retornado por funções através do comando

return, ou seja, não poderíamos escrever a seguinte expressão:

return a,b, c; /* errado */

7.2. Localização das funções

Existem basicamente duas posições possíveis para escrevermos o corpo de uma função: ou antes ou depois do programa principal. Podemos ainda escrever uma função no mesmo arquivo do programa principal ou em arquivo separado.

60

Corpo da função antes do programa principal (no mesmo arquivo)

Quando escrevemos a definição de uma função antes do programa principal e no mesmo arquivo deste, nenhuma outra instrução é necessária. A sintaxe geral para isto é a seguinte:

Sintaxe: Uma função escrita antes do programa principal:

tipo nomef(...){ /* definição da função */ [corpo de função]

} int (){ /* programa principal */

... var = nomef(...) /* chamada da função */ ...

}

Exemplo:

#include <stdio.h> int Square (int a) /* definicao da funçao*/ { return (a*a); } int main () { int num; printf ("Entre com um numero: "); scanf ("%d",&num); num=Square(num); /* chamada da função */ printf ("\n\nO seu quadrado vale: %d\n",num); return 0; }

Corpo da função depois do programa principal (no mesmo arquivo)

Quando escrevemos a definição de uma função depois do programa principal e no mesmo arquivo deste, devemos incluir um protótipo da função chamada. Um protótipo é uma instrução que define o nome da função, seu tipo de retorno e a quantidade e o tipo dos argumentos da função. O protótipo de uma função indica ao compilador quais são as funções usadas no programa principal os tipos.

Sintaxe: Uma função escrita depois do programa principal:

tipo nomef(...); // protótipo da função int main(){ // programa principal

... var = nomef(...) // chamada a função ...

} tipo nomef(...){ // definição da função

[corpo de função]

61

}

Exemplo de um programa com função prototipada.

#include <stdio.h> float media2(float,float); /* protótipo de media2() */ /* float media2(float a, float b); outra forma de protótipo*/ int main(){ /* programa principal */

float num_1, num_2, med; printf(”Digite dois números:\n”); scanf(”%f %f”, &num_1, &num_2); med = media2(num_1, num_2); // chamada a função printf(”\nA media destes números e´ %f”, med); return 0;

} float media2(float a, float b){ /* função media2() */

float med; med = (a + b) / 2.0; return(med);

}

Observe que o protótipo de uma função nada mais é que a declaração da função sem o seu corpo. Observe ainda que na lista de argumentos do protótipo podem ser escritos apenas os tipos dos argumentos, embora o ideal seja manter o protótipo idêntico à declaração da função.

Corpo da função escrito em arquivo separado

Em C, como em muitas outras linguagens, é permitido que o usuário crie uma função em um arquivo e um programa que a chame em outro arquivo distinto. Esta facilidade permite a criação de bibliotecas de usuário: um conjunto de arquivos contendo funções escritas pelo usuário. Esta possibilidade é uma grande vantagem utilizada em larga escala por programadores profissionais.

Quando escrevemos a definição de uma função em arquivo separado do programa principal devemos incluir este arquivo no conjunto de arquivos de compilação do programa principal. Esta inclusão é feita com a diretiva #include. Esta diretiva instrui o compilador para incluir na compilação do programa outros arquivos que contem a definição das funções de usuário e de biblioteca.

Sintaxe: A sintaxe de inclusão de funções de usuário é a seguinte:

#include “path” /* inclusão da função ou biblioteca */ int main(){ /* programa principal */ ... var = nomef(...) /* chamada a função */ ...

}

Na diretiva #include indicamos entre aspas duplas o caminho de localização do arquivo onde está definida a função chamada.

62

Exemplo: A função media2() está escrita em um arquivo separado.

#include ”c:\tc\userbib\stat.h” /* inclusão da função */ int main(){ // programa principal

float num_1, num_2, med; printf(”Digite dois números:\n”); scanf(”%f %f”, &num_1, &num_2); med = media2(num_1, num_2); /* chamada a função */ printf(”\nA media destes números e´ %f”, med);

}

Um arquivo pode conter a definição de uma ou mais funções. Em geral, quando o arquivo

possui apenas uma função ele é nomeado com o mesmo nome da função e extensão *.cpp ou *.c. Por exemplo, poderíamos definir a função media() no arquivo media.cpp. Quando um

arquivo possui a definição de mais de uma função, ele é nomeado com a extensão *.h ou *.lib. Por exemplo: poderíamos criar um conjunto de funções estatísticas chamadas media(), dsvpd(),

moda(), max(), min(), etc. definindo‐as em um arquivo chamado stat.h. Estes arquivos .h são chamado também de arquivos‐cabeçalhos e na verdade, não possuem os códigos completos das funções. Eles só contêm protótipos de funções. É o que basta. O compilador lê estes protótipos e, baseado nas informações lá contidas, gera o código correto. Os corpos das funções

(implementação), cujos protótipos estão no arquivo‐cabeçalho, são definidos em um arquivo .c e incluído no programa no instante da "linkagem". Este é o instante em que todas as referências a funções cujos códigos não estão nos nossos arquivos fontes são resolvidas, buscando este código

nos arquivos de bibliotecas. Portanto, o aquivo‐cabeçalho stat.h do exemplo anterior possui apenas protótipos e a implementação das funções devem ser definidas em um arquivo stat.c.

7.3. Escopo de Variáveis

Já foi dada uma introdução ao escopo de variáveis. O escopo é o conjunto de regras que determinam o uso e a validade de variáveis nas diversas partes do programa.

Variáveis locais

Variáveis locais são aquelas que só têm validade dentro do bloco onde são declaradas. Podemos declarar variáveis dentro de qualquer bloco. Só para lembrar: um bloco começa quando abrimos uma chave e termina quando fechamos a chave. Até agora só tínhamos visto variáveis locais

para funções completas. Mas um comando for pode ter variáveis locais e que não serão conhecidas fora dali. A declaração de variáveis locais é a primeira coisa que devemos colocar num bloco. A característica que torna as variáveis locais tão importantes é justamente a de serem exclusivas do

bloco. Podemos ter quantos blocos quisermos com uma variável local chamada x, por exemplo, e elas não apresentarão conflito entre elas.

63

A palavra reservada do C auto é utilizada para dizer que uma variável é local. Mas não precisaremos usá‐la pois as variáveis declaradas dentro de um bloco já são consideradas locais. Abaixo vemos um exemplo de variáveis locais:

func1 (...){ int abc,x; ... } func (...){ int abc; ... } int main (){ int a,x,y; for (...) { float a,b,c; ... } ... }

No programa acima temos três funções. As variáveis locais de cada uma delas não irão

interferir com as variáveis locais de outras funções. Assim, a variável abc de func1() não tem

nada a ver (e pode ser tratada independentemente) com a variável abc de func2(), apesar de terem o nome. A variável x de func1() é também completamente independente da variável x de main(). As variáveis a, b e c são locais ao bloco for. Isto quer dizer que só são conhecidas dentro deste bloco for e são desconhecidas no resto da função main(). Quando usarmos a variável a

dentro do bloco for estaremos usando a variável a local ao for e não a variável a da função main().

Parâmetros formais

Os parâmetros formais são declarados como sendo as entradas de uma função. Não há motivo para se preocupar com o escopo deles. É fácil: o parâmetro formal é uma variável local da função. Você pode também alterar o valor de um parâmetro formal, pois esta alteração não terá efeito na variável que foi passada à função. Isto tem sentido, pois quando o C passa parâmetros para uma função, são passadas apenas cópias das variáveis. Isto é, os parâmetros formais existem independentemente das variáveis que foram passadas para a função. Eles tomam apenas uma cópia dos valores passados para a função.

Variáveis globais

Variáveis globais são declaradas fora de todas as funções do programa. Elas são conhecidas e podem ser alteradas por todas as funções do programa. Quando uma função tem uma variável

64

local com o mesmo nome de uma variável global a função dará preferência à variável local. Vamos ver um exemplo:

int z,k; func1 (...){ int x,y; ... } func2 (...){ int x,y,z; ... z=10; ... } int main (){ int count; ... }

No exemplo acima as variáveis z e k são globais. Veja que func2() tem uma variável local

chamada z. Quando temos então, em func2(), o comando z=10 quem recebe o valor de 10 é a

variável local, não afetando o valor da variável global z.

Evite ao máximo o uso de variáveis globais. Elas ocupam memória o tempo todo (as locais só ocupam memória enquanto estão sendo usadas) e tornam o programa mais difícil de ser entendido e menos geral.

7.4. Passagem por Valor

Na linguagem C, quando chamamos uma função os parâmetros formais da função copiam os valores dos parâmetros que são passados para a função. Isto quer dizer que não são alterados os valores que os parâmetros têm fora da função. Este tipo de chamada de função é denominado chamada por valor. Isto ocorre porque são passados para a função apenas os valores dos parâmetros e não os próprios parâmetros. Veja o exemplo abaixo:

#include <stdio.h> float sqr (float num); int main (){ float num,sq; printf ("Entre com um numero: "); scanf ("%f",&num); sq=sqr(num); printf ("\n\nO numero original e: %f\n",num); printf ("O seu quadrado vale: %f\n",sq); } float sqr (float num){ num=num*num; return num; }

65

No exemplo acima o parâmetro formal num da função sqr() sofre alterações dentro da função, mas a variável num da função main() permanece inalterada: é uma chamada por valor. É

importante ressaltar que a variável num da função sqr() é diferente da variável num da função main, apesar de possuírem o mesmo nome e valor na chamada da função.

7.5. Passagem por Referência

Outro tipo de passagem de parâmetros para uma função ocorre quando alterações nos parâmetros formais, dentro da função, alteram os valores dos parâmetros que foram passados para a função. Este tipo de chamada de função tem o nome de chamada por referência. Este nome vem do fato de que, neste tipo de chamada, não se passa para a função os valores das variáveis, mas sim suas referências ou endereço (a função usa as referências para alterar os valores das variáveis fora da função).

O C só faz chamadas por valor. Isto é bom quando queremos usar os parâmetros formais à vontade dentro da função, sem termos que nos preocupar em estar alterando os valores dos parâmetros que foram passados para a função. Mas isto também pode ser ruim às vezes, porque podemos querer mudar os valores dos parâmetros fora da função também. O C++ tem um recurso que permite ao programador fazer chamadas por referência. Há entretanto, no C, um recurso de programação que podemos usar para simular uma chamada por referência.

Quando queremos alterar as variáveis que são passadas para uma função, nós podemos declarar seus parâmetros formais como sendo ponteiros. Os ponteiros são a "referência" que precisamos para poder alterar a variável fora da função. O único inconveniente é que, quando

usarmos a função, teremos de lembrar de colocar um & na frente das variáveis que estivermos passando para a função. Veja um exemplo:

#include <stdio.h> void Swap (int *a,int *b); /* protótipo */ int main (){ int num1,num2; num1=100; num2=200; Swap (&num1,&num2);/* chamada por referência */ printf ("\n\nEles agora valem %d %d\n",num1,num2); } void Swap (int *a,int *b){ /* implementação */ int temp; temp=*a; *a=*b; *b=temp; }

Não é muito difícil. O que está acontecendo é que passamos para a função Swap o endereço

das variáveis num1 e num2 através do operador &. Estes endereços são copiados nos ponteiros a e b. Através do operador * estamos acessando o conteúdo apontado pelos ponteiros e modificando‐

66

o. Mas, quem é este conteúdo? Nada mais que os valores armazenados em num1 e num2, que, portanto, estão sendo modificados!

As variável passadas como parâmetros para a função scanf() são sempre precedidas de

&. Por que motivo? Bem, a função scanf() usa chamada por referência porque ela precisa alterar as variáveis que passamos para ela! Não é para isto mesmo que ela é feita? Ela lê variáveis para nós e portanto precisa alterar seus valores. Por isto passamos para a função o endereço da variável a ser modificada!

7.6. Passando Vetores para Funções

Existem três maneiras possíveis:

tipo_retorno nome (tipo v[tam], ...); tipo_retorno nome (tipo v[], ...); tipo_retorno nome (tipo * v, ...);

Nos três casos, teremos dentro função um ponteiro para o vetor passado como parâmetro. Ao passarmos um vetor para uma função, na realidade estamos passando um ponteiro. Neste ponteiro é armazenado o endereço do primeiro elemento do vetor. Isto significa que não é feita uma cópia, elemento a elemento do vetor. Portanto, alterações feitas nos elementos do vetor dentro da função serão refletidas nos valores originais do vetor (já que se utilizará sua posição real na memória).

A chamada de uma função que possui um vetor como argumento tem a seguinte forma:

nome_da_função(nome_do_vetor);

onde nome_da_função é o nome da função que se está chamando e nome_do_vetor é o nome do vetor que queremos passar. Indicamos apenas o nome do vetor, sem índices.

67

Exemplo que um programa que possui duas funções para manipulação de vetores.

#include<stdio.h> #define TAM 5 void le_vet(int vet[]){

int i; for (i = 0; i < TAM; i++){

printf("digite o valor do elemento %d do vetor\n", i+1); scanf("%d", &vet[i]);

} } void imprime_vet(int vet[], int n){

int i; for (i = 0; i < n; i++)

printf("%d\t", vet[i]); } int main(){

int vetor[TAM]; le_vet(vetor); imprime_vet(vetor, TAM); return 0;

}

No programa acima há duas função: le_vet e imprime_vet. A primeira recebe um

vet[] como argumento e lê valores para cada posição deste vetor; a manipulação de limites do

vetor é feito através da constante TAM definida no início do código. Por definição, toda constante simbólica definida pelo programador é conhecida globalmente por todas as funções do programa. A segunda função imprime os elementos de um vetor passado como parâmetro. Além disto, a função imprime_vet possui como argumento da função um inteiro n que é utilizado para auxiliar na manipulação dos limites do vetor. É importante notar que em ambas as funções, o programador deve fornecer para uma função a informação dos limites de um vetor, uma vez que esta informação não é conhecida automaticamente.

7.7. Passagem de matriz para função

As possibilidades são as seguintes:

tipo retorno nome(tipo m[][dim2],...) tipo retorno nome(tipo *m,...)

No primeiro caso, dim2 deve ser fornecido para que o compilador possa calcular o deslocamento em bytes em relação ao endereço do primeiro elemento para uma determinada posição.

No segundo caso, m só pode ser utilizado através da aritmética de ponteiros (detalhado em anteriormente na seção de ponteiros).

68

Exemplo:

void inverte_linha(int m[][2]){ int aux1, aux2; aux1 = m[0][0]; aux2 = m[0][1]; m[0][0] = m[1][0]; m[0][1] = m[1][1]; m[1][0] = aux1; m[1][1] = aux2; } int main(){ int m[2][2]; . . . inverte_linha(m); . . . }

Bem como em vetores, o controle dos limites da matriz é de responsabilidade de programador informação para a função.

7.8. Recursividade

Na linguagem C, assim como em muitas outras linguagens de programação, uma função pode chamar a si própria. Uma função assim é chamada função recursiva. Todo cuidado é pouco ao se fazer funções recursivas. A primeira coisa a se providenciar é um critério de parada. Este vai determinar quando a função deverá parar de chamar a si mesma. Isto impede que a função se chame infinitas vezes.

Uma função que calcule o fatorial de um número inteiro n é um bom exemplo de uma função recursiva:

#include <stdio.h> int fat(int n){ if (n > 0) return n*fat(n-1); else

return 1; } int main(){ int n; printf("\n\nDigite um valor para n: "); scanf("%d", &n); printf("\nO fatorial de %d e' %d", n, fat(n)); return 0; }

69

Note que, enquanto n não for igual a 0, a função fat chama a si mesma, cada vez com um

valor menor. n=0 é critério de parada para esta função.

Há certos algoritmos que são mais eficientes quando feitos de maneira recursiva, mas a recursividade é algo a ser evitado sempre que possível, pois, se usada incorretamente, tende a consumir muita memória e ser lenta. Lembre‐se que memória é consumida cada vez que o computador faz uma chamada a uma função. Com funções recursivas a memória do computador pode se esgotar rapidamente.

7.9. Argumentos argc e argv do main

A função main possui dois argumentos argc e argv intrínsecos utilizados para receber parâmetros da linha de comando do Sistema Operacional.

• argc: contém o número de argumentos na linha de comando.

• argv: ponteiro para uma matriz (2D) de caracteres (vetor de strings).

O programa abaixo recebe parâmetros digitados pelo usuário pela linha de comando do sistema operacional e imprime a palavra em sentido inverso.

#include <stdio.h> #include <string.h> int main (int argc, char *argv[]){

int i, n; if (argc != 2)

printf("Sintaxe: INVERTE <palavra>\n"); else {

n = strlen(argv[1]); for (i = n-1; i >= 0; i--)

printf("%c", argv[1][i]); printf(“\n”);

} }

Imaginando que este programa seja compilado e gerado o executável com o nome invert.exe. Para executar este programa em um terminal do Sistema Operacional Linux, recebendo como parâmetro a string “UTFPR” para ser invertida, a linha se comando seria a seguinte:

$ inverte UTFPR <enter>

Programa recebe:

argc = 2

argv[0] = “inverte” /* nome do programa*/

agv[1] = “UTFPR” /* string que será invertida */

70

Resultado na tela: RPFTU

71

8. Diretivas de Compilação O pré‐processador C é um programa que examina o programa fonte escrito em C e executa

certas modificações nele, baseada nas Diretivas de Compilação. As diretivas de compilação são comandos que não são compilados, sendo dirigidos ao pré‐processador, que é executado pelo compilador antes da execução do processo de compilação propriamente dito.

Portanto, o pré‐processador modifica o programa fonte, entregando para o compilador um programa modificado. Todas as diretivas de compilação são iniciadas pelo caracter #. As diretivas podem ser colocadas em qualquer parte do programa. Já vimos, e usamos muito, a diretiva

#include. Sabemos que ela não gera código mas diz ao compilador que ele deve incluir um arquivo externo na hora da compilação. As diretivas do C são identificadas por começarem por #.

8.1. A Diretiva include

A diretiva #include diz ao compilador para incluir, na hora da compilação, um arquivo especificado. Sua forma geral é:

#include "nome_do_arquivo"

ou

#include <nome_do_arquivo>

A diferença entre se usar " " e < > é somente a ordem de procura nos diretórios pelo arquivo especificado. Se você quiser informar o nome do arquivo com o caminho completo, ou se o arquivo estiver no diretório de trabalho, use " ". Se o arquivo estiver nos caminhos de procura pré‐especificados do compilador, isto é, se ele for um arquivo do próprio sistema (como é o caso de arquivos como stdio.h, string.h, etc...) use < >.

Observe que não há ponto e vírgula após a diretiva de compilação. Esta é uma característica importante de todas as diretivas de compilação e não somente da diretiva #include.

8.2. As Diretivas define e undef

A diretiva #define tem a seguinte forma geral:

#define nome_da_macro sequência_de_caracteres

Quando você usa esta diretiva, você está dizendo ao compilador para que, toda vez que ele

encontrar o nome_da_macro no programa a ser compilado, ele deve substituí‐lo pela

sequência_de_caracteres fornecida. Isto é muito útil para deixar o programa mais geral. Veja um exemplo:

72

#include <stdio.h> #define PI 3.1416 #define VERSAO "2.02" int main (){ printf ("Programa versao %s",VERSAO); printf ("O numero pi vale: %f",PI); return 0; }

Se quisermos mudar o nosso valor de PI, ou da VERSAO, no programa acima, basta mexer no início do programa. Isto torna o programa mais flexível. É uma convenção de programação (que deve ser seguida, pois torna o programa mais legível) na linguagem C que as macros declaradas em

#defines devem ser todas em maiúsculas.

Outro uso da diretiva #define é o de simplesmente definir uma macro. Neste caso usa‐se a seguinte forma geral:

#define nome_da_macro

Neste caso o objetivo não é usar a macro no programa (pois ela seria substituída por nada), mas, sim, definir uma macro para ser usada como uma espécie de flag. Isto quer dizer que estamos definindo um valor como sendo "verdadeiro" para depois podermos testá‐lo.

Também é possível definir macros com argumentos. Veja o exemplo a seguir:

#define max(A,B) ((A>B) ? (A):(B)) #define min(A,B) ((A<B) ? (A):(B)) ... x = max(i,j); y = min(t,r);

Embora pareça uma chamada de função, o uso de max (ou min) simplesmente substitui, em tempo de compilação, o código especificado. Cada ocorrência de um parâmetro formal (A ou B, na definição) será substituído pelo argumento real correspondente. Assim, a linha de código:

x = max(i,j);

será substituída pela linha:

x = ((i)>(j) ? (i):(j));

A linha de código:

x = max(p+q,r+s);

será substituída pela linha:

x = ((p+q)>(r+s) ? (p+q):(r+s));

Isto pode ser muito útil. Verifique que as macros max e min não possuem especificação de tipo. Logo, elas trabalham corretamente para qualquer tipo de dado, enquanto os argumentos passados forem coerentes. Mas isto pode trazer também algumas armadilhas. Veja que a linha

73

x = max(p++,r++);

será substituída pelo código

x = ((p++)>(r++) ? (p++):(r++));

e em conseqüência, incrementará o maior valor duas vezes.

Outra armadilha em macros está relacionada com o uso de parênteses. Seja a macro:

#define SQR(X) X*X

Imagine que você utilize esta macro na expressão abaixo:

y = SQR(A+B);

Ao fazer isto, a substituição que será efetuada não estará correta. A expressão gerada será:

y = A+B*A+B;

que obviamente é diferente de (A+B)*(A+B) !

A solução para este problema é incluir parênteses na definição da macro:

#define SQR(X)(X)*(X)

Quando você utiliza à diretiva #define nunca deve haver espaços em branco no identificador. Por exemplo, a macro:

#define PRINT (i) printf(" %d \n", i)

não funcionará corretamente porque existe um espaço em branco entre PRINT e (i). Ao se tirar o espaço, a macro funcionará corretamente e poderá ser utilizada para imprimir o número inteiro i, saltando em seguida para a próxima linha.

A diretiva #undef tem a seguinte forma geral:

#undef nome_da_macro

Ela faz com que a macro que a segue seja apagada da tabela interna que guarda as macros. O compilador passa a partir deste ponto a não conhecer mais esta macro.

8.3. As Diretivas ifdef e endif

Nesta seção, e até mais a frente, veremos as diretivas de compilação condicional. Elas são muito parecidas com os comandos de execução condicional do C. As duas primeiras diretivas que veremos são as #ifdef e #endif. Suas formas gerais são:

#ifdef nome_da_macro

sequência_de_declarações

#endif

74

A seqüência de declarações será compilada apenas se o nome da macro estiver definido. A diretiva de compilação #endif é útil para definir o fim de uma seqüência de declarações para todas as diretivas de compilação condicional. As linhas

#define PORT_0 0x378 ... /* Linhas de código qualquer... */ ... #ifdef PORT_0 #define PORTA PORT_0

#include "../sys/port.h" #endif

demonstram como estas diretivas podem ser utilizadas. Caso PORT_0 tenha sido previamente definido, a macro PORTA é definida e o header file port.h é incluído.

8.4. A Diretiva ifndef

A diretiva #ifndef funciona ao contrário da diretiva #ifdef. Sua forma geral é:

#ifndef nome_da_macro


#endif

A seqüência de declarações será compilada se o nome da macro não tiver sido definido.

8.5. A Diretiva if

A diretiva #if tem a seguinte forma geral:

#if expressão_constante


#endif

A seqüência de declarações será compilada se a expressão‐constante for verdadeira. É muito importante ressaltar que a expressão fornecida deve ser constante, ou seja, não deve ter nenhuma variável.

8.6. A Diretiva else

A diretiva #else tem a seguinte forma geral:

#if expressão_constante

75


#else


#endif

Ela funciona como seu correspondente, o comando else.

Imagine que você esteja trabalhando em um sistema, e deseje que todo o código possa ser compilado em duas diferentes plataformas (i.e. Unix e Dos). Para obter isto, você "encapsula" toda a parte de entrada e saída em arquivos separados, que serão carregados de acordo com o header file carregado. Isto pode ser facilmente implementado da seguinte forma:

#define SISTEMA DOS ... /*linhas de codigo..*/ ... #if SISTEMA == DOS #define CABECALHO "dos_io.h" #else

#define CABECALHO "unix_io.h" #endif #include CABECALHO

8.7. A Diretiva elif

A diretiva #elif serve para implementar a estrutura if-else-if. Sua forma geral é:

#if expressão_constante_1

sequência_de_declarações_1

#elif expressão_constante_2


#elif expressão_constante_3


.

.

.

#elif expressão_constante_n

sequência_de_declarações_n

#endif

76

O funcionamento desta estrutura é idêntico ao funcionamento apresentado anteriormente.

77

9. Manipulação de Arquivos 9.1. Introdução

Antes de começarmos a discussão sobre como trabalhar com arquivos em C é importante saber a diferença entre fluxo e arquivo. O sistema de E/S linguagem C fornece uma interface consistente ao programador, independente do dispositivo real que é acessado. Isto é, o sistema de E/S provê um nível de abstração entre o programador e o dispositivo utilizado (discos, terminais, teclados, acionadores de fita). Esta abstração é chamada de fluxo (ou stream) e o dispositivo é chamado de arquivo. Todos os fluxos são similares em seu funcionamento e independentes do dispositivo ao qual estão associados. Assim, as mesmas funções que descrevem o acesso aos discos podem ser utilizadas para se acessar um terminal de vídeo. Todas as operações de entrada e saída são realizadas por meio de fluxos.

Na linguagem C, um arquivo é entendido como um conceito que pode ser aplicado a arquivos em disco, terminais, modens, etc ... Um fluxo é associado a um arquivo através da realização de uma operação de abertura. Uma vez aberto, informações podem ser trocadas entre o arquivo e o programa. Um arquivo é dissociado de um fluxo através de uma operação de fechamento de arquivo.

O sistema de entrada e saída do ANSI C é composto por uma série de funções, cujos

protótipos estão reunidos em stdio.h. Todas estas funções trabalham com o conceito de "ponteiro de arquivo". Este não é um tipo propriamente dito, mas uma definição usando o comando typedef. Esta definição também está no arquivo stdio.h. Podemos declarar um ponteiro de arquivo da seguinte maneira:

FILE *p; p será então um ponteiro para um arquivo. É usando este tipo de ponteiro que vamos poder

manipular arquivos no C.

fopen( )

Esta é a função de abertura de arquivos. Seu protótipo é:

FILE *fopen (char *nome_do_arquivo,char *modo);

O nome_do_arquivo determina qual arquivo deverá ser aberto. Este nome deve ser válido no sistema operacional que estiver sendo utilizado. O modo de abertura diz à função fopen( ) que tipo de uso você vai fazer do arquivo. A tabela abaixo mostra os valores de modo válidos:

78

Modo Significado

"r" Abre um arquivo texto para leitura. O arquivo deve existir antes de ser aberto.

"w" Abrir um arquivo texto para gravação. Se o arquivo não existir, ele será criado. Se já existir, o conteúdo anterior será destruído.

"a" Abrir um arquivo texto para gravação. Os dados serão adicionados no fim do arquivo ("append"), se ele já existir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.

"rb" Abre um arquivo binário para leitura. Igual ao modo "r" anterior, só que o arquivo é binário.

"wb" Cria um arquivo binário para escrita, como no modo "w" anterior, só que o arquivo é binário.

"ab" Acrescenta dados binários no fim do arquivo, como no modo "a" anterior, só que o arquivo é binário.

"r+" Abre um arquivo texto para leitura e gravação. O arquivo deve existir e pode ser modificado.

"w+" Cria um arquivo texto para leitura e gravação. Se o arquivo existir, o conteúdo anterior será destruído. Se não existir, será criado.

"a+" Abre um arquivo texto para gravação e leitura. Os dados serão adicionados no fim do arquivo se ele já existir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.

"r+b" Abre um arquivo binário para leitura e escrita. O mesmo que "r+" acima, só que o arquivo é binário.

"w+b" Cria um arquivo binário para leitura e escrita. O mesmo que "w+" acima, só que o arquivo é binário.

"a+b" Acrescenta dados ou cria uma arquivo binário para leitura e escrita. O mesmo que "a+" acima, só que o arquivo é binário.

Poderíamos então, para abrir um arquivo binário para escrita, escrever:

FILE *fp; /* Declaração da estrutura fp=fopen ("exemplo.bin","wb"); /* o arquivo se chama exemplo.bin e está localizado no diretório corrente */ if (!fp) printf ("Erro na abertura do arquivo.");

A condição !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro a

função fopen() retorna um ponteiro nulo (NULL).

Uma vez aberto um arquivo, vamos poder ler ou escrever nele utilizando as funções que serão apresentadas nas próximas páginas.

79

Toda vez que estamos trabalhando com arquivos, há uma espécie de posição atual no arquivo. Esta é a posição de onde será lido ou escrito o próximo caractere. Normalmente, num acesso seqüencial a um arquivo, não temos que mexer nesta posição pois quando lemos um caractere a posição no arquivo é automaticamente atualizada. Num acesso randômico teremos que mexer nesta posição (ver fseek()).

exit( )

Aqui abrimos um parênteses para explicar a função exit() cujo protótipo é:

void exit (int codigo_de_retorno);

Para utilizá‐la deve‐se colocar um include para o arquivo de cabeçalho stdlib.h. Esta função aborta a execução do programa. Pode ser chamada de qualquer ponto no programa e faz

com que o programa termine e retorne, para o sistema operacional, o código_de_retorno. A convenção mais usada é que um programa retorne zero no caso de um término normal e retorne um

número não nulo no caso de ter ocorrido um problema. A função exit() se torna importante em casos como alocação dinâmica e abertura de arquivos pois nestes casos, se o programa não conseguir a memória necessária ou abrir o arquivo, a melhor saída pode ser terminar a execução do

programa. Poderíamos reescrever o exemplo da seção anterior usando agora o exit() para garantir que o programa não deixará de abrir o arquivo:

#include <stdio.h> #include <stdlib.h> /* Para a função exit() */ main (void){ FILE *fp; ... fp=fopen ("exemplo.bin","wb"); if (!fp) { printf ("Erro na abertura do arquivo. Fim de programa."); exit (1); } ... return 0; }

fclose( )

Quando acabamos de usar um arquivo que abrimos, devemos fechá‐lo. Para tanto usa‐se a função fclose():

int fclose (FILE *fp);

O ponteiro fp passado à função fclose() determina o arquivo a ser fechado. A função retorna zero no caso de sucesso.

80

Fechar um arquivo faz com que qualquer caracter que tenha permanecido no "buffer" associado ao fluxo de saída seja gravado. Mas, o que é este "buffer"? Quando você envia caracteres para serem gravados em um arquivo, estes caracteres são armazenados temporariamente em uma área de memória (o "buffer") em vez de serem escritos em disco imediatamente. Quando o "buffer" estiver cheio, seu conteúdo é escrito no disco de uma vez. A razão para se fazer isto tem a ver com a eficiência nas leituras e gravações de arquivos. Se, para cada caracter que fossemos gravar, tivéssemos que posicionar a cabeça de gravação em um ponto específico do disco, apenas para gravar aquele caracter, as gravações seriam muito lentas. Assim, estas gravações só serão efetuadas quando houver um volume razoável de informações a serem gravadas ou quando o arquivo for fechado.

A função exit() fecha todos os arquivos que um programa tiver aberto.

9.2. Lendo e Escrevendo Caracteres em Arquivos

putc

A função putc é a primeira função de escrita de arquivo que veremos. Seu protótipo é:

int putc (int ch,FILE *fp);

Escreve um caractere no arquivo.

O programa a seguir lê uma string do teclado e escreve‐a, caractere por caractere em um arquivo em disco (o arquivo arquivo.txt, que será aberto no diretório corrente).

#include <stdio.h> #include <stdlib.h> int main(){ FILE *fp; char string[100]; int i; fp = fopen("arquivo.txt","w"); /* Arquivo ASCII, para escrita */ if(!fp) { printf( "Erro na abertura do arquivo"); exit(0); } printf("Entre com a string a ser gravada no arquivo:"); gets(string); for(i=0; string[i]; i++) putc(string[i], fp);/* Grava string, caractere a caractere */ fclose(fp); return 0; }

Depois de executar este programa, verifique o conteúdo do arquivo arquivo.txt (você pode usar qualquer editor de textos). Você verá que a string que você digitou está armazenada nele.

81

getc

Retorna um caractere lido do arquivo.

Protótipo:

int getc (FILE *fp);

feof

EOF ("End of file") indica o fim de um arquivo. Às vezes, é necessário verificar se um arquivo

chegou ao fim. Para isto podemos usar a função feof(). Ela retorna não‐zero se o arquivo chegou ao EOF, caso contrário retorna zero. Seu protótipo é:

int feof (FILE *fp);

Outra forma de se verificar se o final do arquivo foi atingido é comparar o caractere lido por getc com EOF. O programa a seguir abre um arquivo já existente e o lê, caracter por caracter, até

que o final do arquivo seja atingido. Os caracteres lidos são apresentados na tela:

#include <stdio.h> #include <stdlib.h> int main(){

FILE *fp; char c; fp = fopen("arquivo.txt","r");/* Arquivo ASCII, para leitura */ if(!fp){ printf( "Erro na abertura do arquivo"); exit(0); } while((c = getc(fp) ) != EOF)/* Enquanto não chegar ao final do arquivo */ printf("%c", c); /* imprime o caracter lido */ fclose(fp); return 0;

}

A seguir é apresentado um programa onde várias operações com arquivos são realizadas, usando as funções vistas nesta página. Primeiro o arquivo é aberto para a escrita, e imprime‐se algo nele. Em seguida, o arquivo é fechado e novamente aberto para a leitura. Verifique o exemplo.

#include <stdio.h> #include <stdlib.h> #include <string.h> int main() {

FILE *p; char c, str[30], frase[80] = "Este e um arquivo chamado: "; int i;

/* Le um nome para o arquivo a ser aberto: */ printf("\n\n Entre com um nome para o arquivo:\n");

82

gets(str);

if (!(p = fopen(str,"w"))) {

printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); /* Caso ocorra algum erro na abertura do arquivo o

programa aborta automaticamente */ } /* Se nao houve erro, imprime no arquivo e o fecha ...*/ strcat(frase, str); for (i=0; frase[i]; i++)

putc(frase[i],p); fclose(p);

/* Abre novamente para leitura */ p = fopen(str,"r"); c = getc(p);/* Le o primeiro caracter */ while (!feof(p))/* Enquanto não se chegar no final do arquivo

*/ {

printf("%c",c); /* Imprime o caracter na tela */ c = getc(p); /* Le um novo caracter no arquivo */

} fclose(p);/* Fecha o arquivo */

}

83

9.3. Outros Comandos de Acesso a Arquivos

Arquivos pré‐definidos

Quando se começa a execução de um programa, o sistema automaticamente abre alguns arquivos pré‐definidos:

• stdin: dispositivo de entrada padrão (geralmente o teclado)

• stdout: dispositivo de saída padrão (geralmente o vídeo)

• stderr: dispositivo de saída de erro padrão (geralmente o vídeo)

• stdaux: dispositivo de saída auxiliar (em muitos sistemas, associado à porta serial)

• stdprn : dispositivo de impressão padrão (em muitos sistemas, associado à porta paralela)

Cada uma destas constantes pode ser utilizada como um ponteiro para FILE, para acessar os periféricos associados a eles. Desta maneira, pode‐se, por exemplo, usar:

ch =getc(stdin);

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

putc(ch, stdout);

para imprimi‐lo na tela.

fgets

Para se ler uma string num arquivo podemos usar fgets() cujo protótipo é:

char *fgets (char *str, int tamanho,FILE *fp);

A função recebe 3 argumentos: a string a ser lida, o limite máximo de caracteres a serem

lidos e o ponteiro para FILE, que está associado ao arquivo de onde a string será lida. A função lê a string até que um caracter de nova linha seja lido ou tamanho-1 caracteres tenham sido lidos. Se

o caracter de nova linha ('\n') for lido, ele fará parte da string, o que não acontecia com gets. A string resultante sempre terminará com '\0' (por isto somente tamanho-1 caracteres, no máximo, serão lidos).

A função fgets é semelhante à função gets(), porém, além dela poder fazer a leitura a partir de um arquivo de dados e incluir o caracter de nova linha na string, ela ainda especifica o

tamanho máximo da string de entrada. Como vimos, a função gets não tinha este controle, o que poderia acarretar erros de "estouro de buffer". Portanto, levando em conta que o ponteiro fp pode ser substituído por stdin, como vimos acima, uma alternativa ao uso de gets é usar a seguinte construção:

fgets (str, tamanho, stdin);

onde str e' a string que se está lendo e tamanho deve ser igual ao tamanho alocado para a

string subtraído de 1, por causa do '\0'.

fputs

84

Protótipo:

char *fputs (char *str,FILE *fp);

Escreve uma string num arquivo.

ferror e perror

Protótipo de ferror:

int ferror (FILE *fp);

A função retorna zero, se nenhum erro ocorreu e um número diferente de zero se algum erro ocorreu durante o acesso ao arquivo.

ferror() se torna muito útil quando queremos verificar se cada acesso a um arquivo teve sucesso, de modo que consigamos garantir a integridade dos nossos dados. Na maioria dos casos, se um arquivo pode ser aberto, ele pode ser lido ou gravado. Porém, existem situações em que isto não ocorre. Por exemplo, pode acabar o espaço em disco enquanto gravamos, ou o disco pode estar com problemas e não conseguimos ler, etc.

Uma função que pode ser usada em conjunto com ferror() é a função perror() (print error), cujo argumento é uma string que normalmente indica em que parte do programa o problema ocorreu.

No exemplo a seguir, fazemos uso de ferror, perror e fputs


FILE *pf; char string[100]; if((pf = fopen("arquivo.txt","w")) ==NULL){

printf("\nNao consigo abrir o arquivo ! "); exit(1);

} do {

printf("\nDigite uma nova string. Para terminar, digite <enter>:"); gets(string); fputs(string, pf); putc('\n', pf); if(ferror(pf)) {

perror("Erro na gravacao"); fclose(pf); exit(1);

} } while (strlen(string) > 0); fclose(pf);

}

fread

Podemos escrever e ler blocos de dados. Para tanto, temos as funções fread() e fwrite(). O protótipo de fread() é:

85

unsigned fread (void *buffer, int numero_de_bytes, int count, FILE *fp);

O buffer é a região de memória na qual serão armazenados os dados lidos. O número de bytes é o tamanho da unidade a ser lida. count indica quantas unidades devem ser lidas. Isto significa que o número total de bytes lidos é:

numero_de_bytes*count

A função retorna o número de unidades efetivamente lidas. Este número pode ser menor que count quando o fim do arquivo for encontrado ou ocorrer algum erro.

Quando o arquivo for aberto para dados binários, fread pode ler qualquer tipo de dados.

fwrite

A função fwrite() funciona como a sua companheira fread(), porém escrevendo no arquivo. Seu protótipo é:

unsigned fwrite(void *buffer,int numero_de_bytes,int count,FILE *fp);

A função retorna o número de itens escritos. Este valor será igual a count a menos que ocorra algum erro.

O exemplo abaixo ilustra o uso de fwrite e fread para gravar e posteriormente ler uma variável float em um arquivo binário.


FILE *pf; float pi = 3.1415; float pilido; if((pf = fopen("arquivo.bin", "wb")) == NULL){ /* abre arq. binário p/ escrita */

printf("Erro na abertura do arquivo"); exit(1);

}

if(fwrite(&pi, sizeof(float), 1,pf) != 1) /* Escreve a variável pi */

printf("Erro na escrita do arquivo"); fclose(pf); /* Fecha o arquivo */

if((pf = fopen("arquivo.bin", "rb")) == NULL){ /* Abre o arquivo novamente para leitura */

printf("Erro na abertura do arquivo"); exit(1); }

if(fread(&pilido, sizeof(float), 1,pf) != 1) /* Le em pilido o valor da variável armazenada anteriormente */ printf("Erro na leitura do arquivo");

printf("\nO valor de PI, lido do arquivo e': %f", pilido);

fclose(pf);

return(0);

}

86

Note‐se o uso do operador sizeof, que retorna o tamanho em bytes da variável ou do tipo de dados.

fseek

Para se fazer procuras e acessos randômicos em arquivos usa‐se a função fseek(). Esta move a posição corrente de leitura ou escrita no arquivo de um valor especificado, a partir de um ponto especificado. Seu protótipo é:

int fseek (FILE *fp,long numbytes,int origem);

O parâmetro origem determina a partir de onde os numbytes de movimentação serão

contados. Os valores possíveis são definidos por macros em stdio.h e são:

Nome Valor Significado

SEEK_SET 0 Início do arquivo

SEEK_CUR 1 Ponto corrente no arquivo

SEEK_END 2 Fim do arquivo

Tendo‐se definido a partir de onde irá se contar, numbytes determina quantos bytes de deslocamento serão dados na posição atual.

rewind

A função rewind() de protótipo

void rewind (FILE *fp);

retorna a posição corrente do arquivo para o início.

remove

Protótipo:

int remove (char *nome_do_arquivo);

Apaga um arquivo especificado.

O exercício da página anterior poderia ser reescrito usando‐se, por exemplo, fgets() e fputs(), ou fwrite() e fread(). A seguir apresentamos uma segunda versão que se usa das

funções fgets() e fputs(), e que acrescenta algumas inovações.

#include <stdio.h> #include <string.h> #include <stdlib.h> int main() { FILE *p; char str[30], frase[] = "Este e um arquivo chamado: ", resposta[80];

87

int i; /* Le um nome para o arquivo a ser aberto: */ printf("\n\n Entre com um nome para o arquivo:\n"); fgets(str,29,stdin); /* Usa fgets como se fosse gets */ for(i=0; str[i]; i++) if(str[i]=='\n') str[i]=0; /* Elimina o \n da string lida */ if (!(p = fopen(str,"w")))

{ /* Caso ocorra algum erro na abertura do arquivo o programa aborta automaticamente */

printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); } /* Se nao houve erro, imprime no arquivo, e o fecha ...*/ fputs(frase, p); fputs(str,p); fclose(p); /* abre novamente e le */ p = fopen(str,"r"); fgets(resposta, 79, p); printf("\n\n%s\n", resposta); fclose(p); /* Fecha o arquivo */ remove(str); /* Apaga o arquivo */ return(0); }

9.4. Fluxos Padrão

Os fluxos padrão em arquivos permitem ao programador ler e escrever em arquivos da maneira padrão com a qual o já líamos e escrevíamos na tela.

fprintf

A função fprintf() funciona como a função printf(). A diferença é que a saída de fprintf() é um arquivo e não a tela do computador. Protótipo:

int fprintf (FILE *fp,char *str,...);

Como já poderíamos esperar, a única diferença do protótipo de fprintf() para o de printf() é a especificação do arquivo destino através do ponteiro de arquivo.

fscanf

A função fscanf() funciona como a função scanf(). A diferença é que fscanf() lê de um arquivo e não do teclado do computador. Protótipo:

int fscanf (FILE *fp,char *str,...);

Como já poderíamos esperar, a única diferença do protótipo de fscanf() para o de scanf() é a especificação do arquivo destino através do ponteiro de arquivo.

#include <stdio.h> #include <stdlib.h> int main() {

88

FILE *p; char str[80],c; /* Le um nome para o arquivo a ser aberto: */ printf("\n\n Entre com um nome para o arquivo:\n"); gets(str); if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do arquivo..*/ { /* o programa aborta automaticamente */ printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); } /* Se nao houve erro, imprime no arquivo, fecha ...*/ fprintf(p,"Este e um arquivo chamado:\n%s\n", str); fclose(p); /* abre novamente para a leitura */ p = fopen(str,"r"); while (!feof(p)) { fscanf(p,"%c",&c); printf("%c",c); } fclose(p); return(0); }

89

10. Tipos de Dados Avançados Já vimos que uma variável é declarada como

tipo_da_variável lista_de_variáveis;

Vimos também que existem modificadores de tipos. Estes modificam o tipo da variável

declarada. Destes, já vimos os modificadores signed, unsigned, long, e short. Estes modificadores são incluídos na declaração da variável da seguinte maneira:

modificador_de_tipo tipo_da_variável lista_de_variáveis;

Vamos discutir agora outros modificadores de tipo.

10.1. Modificadores de Acesso

Estes modificadores, como o próprio nome indica, mudam a maneira com a qual a variável é acessada e modificada.

const

O modificador const faz com que a variável não possa ser modificada no programa. Como o nome já sugere é útil para se declarar constantes. Poderíamos ter, por exemplo:

const float PI=3.141;

Podemos ver pelo exemplo que as variáveis com o modificador const podem ser

inicializadas. Mas PI não poderia ser alterado em qualquer outra parte do programa. Se o programador tentar modificar PI o compilador gerará um erro de compilação.

O uso mais importante de const não é declarar variáveis constantes no programa. Seu uso mais comum é evitar que um parâmetro de uma função seja alterado pela função. Isto é muito útil no caso de um ponteiro, pois o conteúdo de um ponteiro pode ser alterado por uma função. Para tanto, basta declarar o parâmetro como const. Veja o exemplo:

#include <stdio.h> int sqr (const int *num); int main (void){

int a=10; int b; b=sqr (&a);

} int sqr (const int *num){

return ((*num)*(*num)); }

No exemplo, num está protegido contra alterações. Isto quer dizer que, se tentássemos fazer

*num=10;

90

dentro da função sqr() o compilador daria uma mensagem de erro.

volatile

O modificador volatile é usado para informar ao compilador que o valor de uma variável pode ser alterado de uma maneira não explicitamente especificada pelo seu programa. Por exemplo, um endereço de uma variável global pode ser passado para a rotina de relógio do sistema operacional e usado para guardar o tempo real do sistema. Isto é, o valor da variável é alterado sem nenhum comando explicito no programa. Desta forma evita‐se que alguns compiladores C assumam que o valor da variável é imutável porque sua referência não aparece do lado esquerdo da expressão; logo ela pode não ser reexaminada toda vez que referenciada.

volatile float*relógio;

É possível usar const e volatile juntos. Por exemplo, se 0x30 é o valor de uma porta que é alterado somente por condições externas ao programa, podemos declarar:

const volatile unsigned char *port = 0x30;

Desta forma conseguimos prevenir qualquer efeito colateral acidental.

static

O funcionamento das variáveis declaradas como static depende se estas são globais ou locais.

Variáveis globais static funcionam como variáveis globais dentro de um módulo, ou seja, são variáveis globais que não são (e nem podem ser) conhecidas em outros módulos. Isto é útil se quisermos isolar pedaços de um programa para evitar mudanças acidentais em variáveis globais.

Variáveis locais static são variáveis cujo valor é mantido de uma chamada da função para a outra. Veja o exemplo:

int count (void){ static int num=0; num++; return num;

}

A função count() retorna o número de vezes que ela já foi chamada. Veja que a variável

local int é inicializada. Esta inicialização só vale para a primeira vez que a função é chamada pois num deve manter o seu valor de uma chamada para a outra. O que a função faz é incrementar num

a cada chamada e retornar o seu valor. A melhor maneira de se entender esta variável local static é implementando. Veja por si mesmo, executando seu próprio programa que use este conceito.

register

O computador tem a memória principal e os registradores da CPU. As variáveis (assim como

o programa como um todo) são armazenadas na memória. O modificador register diz ao compilador que a variável em questão deve ser, se possível, usada em um registrador da CPU.

91

Vamos agora ressaltar vários pontos importantes. Em primeiro lugar, porque usar o register? Variáveis nos registradores da CPU vão ser acessadas em um tempo muito menor pois os registradores são muito mais rápidos que a memória. Em segundo lugar, em que tipo de variável usar o register? O register não pode ser usado em variáveis globais. Isto implicaria que um registrador da CPU ficaria o tempo todo ocupado por conta de uma variável. Os tipos de dados onde

é mais aconselhado o uso do register são os tipos char e int, mas pode‐se usá‐lo em qualquer

tipo de dado. Em terceiro lugar, o register é um pedido que o programador faz ao compilador. Este não precisa ser atendido necessariamente.

Um exemplo do uso do register é dado:

int main (void){ register int count; for (count=0;count<10;count++){

... } return 0;

}

O laço for acima será executado mais rapidamente do que seria se não usássemos o

register. Este é o uso mais recomendável para o register: uma variável que será usada muitas vezes em seguida.

10.2. Conversão de Tipos

Em atribuições no C temos o seguinte formato:

destino=orígem;

Se o destino e a origem são de tipos diferentes o compilador faz uma conversão entre os tipos. Nem todas as conversões são possíveis. O primeiro ponto a ser ressaltado é que o valor de origem é convertido para o valor de destino antes de ser atribuído e não o contrário.

É importante lembrar que quando convertemos um tipo numérico para outro nós nunca ganhamos precisão. Nós podemos perder precisão ou no máximo manter a precisão anterior. Isto pode ser entendido de outra forma. Quando convertemos um número não estamos introduzindo no sistema nenhuma informação adicional. Isto implica que nunca vamos ganhar precisão.

92

Abaixo vemos uma tabela de conversões numéricas com perda de precisão, para um compilador com palavra de 16 bits:

De Para Informação Perdidaunsigned char char Valores maiores que 127 são alterados

short int char Os 8 bits de mais alta ordem int char Os 8 bits de mais alta ordem

long int char Os 24 bits de mais alta ordem long int short int Os 16 bits de mais alta ordem long int int Os 16 bits de mais alta ordem float int Precisão ‐ resultado arredondado double float Precisão ‐ resultado arredondado

long double double Precisão ‐ resultado arredondado

10.3. Modificadores de Funções

A forma geral de uma função é, como já foi visto,

tipo_de_retorno nome_da_função (declaração_de_parâmetros) {

corpo_da_função }

Uma função pode aceitar um modificador de tipo. Este vai modificar o modo como a função opera na passagem de parâmetros. A forma geral da função ficaria então:

modificador_de_tipo tipo_de_retorno nome_da_função (declaração_de_parâmetros) {

corpo_da_função }

O nosso curso não aborda detalhes do funcionamento interno de funções. Para saber mais, consulte o manual do seu compilador ou algum livro especializado.

pascal

Faz com que a função use a convenção de funções da linguagem de programação Pascal. Isto faz com que as funções sejam compatíveis com programas em Pascal.

cdecl

O modificador de tipo cdecl faz com que a função use a convenção para funções do C. Raramente é usado pois é o default. Pode‐se pensar no cdecl como sendo o "inverso" do pascal.

interrupt

Diz ao compilador que a função em questão será usada como um manipulador de interrupções. Isto faz com que o compilador preserve os registradores da CPU antes e depois da chamada à função. Mais uma vez este tópico está fora do escopo do curso.

93

10.4. Ponteiros para Funções

O C permite que acessemos variáveis e funções através de ponteiros! Podemos então fazer coisas como, por exemplo, passar uma função como argumento para outra função. Um ponteiro para uma função tem a seguinte declaração:

tipo_de_retorno (*nome_do_ponteiro)(); ou tipo_de_retorno (*nome_do_ponteiro)(declaração_de_parâmetros);

Repare nos parênteses que devem ser colocados obrigatoriamente. Se declaramos:

tipo_de_retorno * nome(declaração_de_parâmetros);

Estaríamos, na realidade, declarando uma função que retornaria um ponteiro para o tipo especificado.

Porém, não é obrigatório declarar os parâmetros da função. Veja um exemplo do uso de ponteiros para funções:

#include <stdio.h> #include <string.h> void PrintString (char *str, int (*func)(const char *)); int main (void){ char String [20]="Curso de C."; int (*p)(const char *); /* Declaracao do ponteiro para função Funcao apontada e' inteira e recebe como parametro uma string constante */ p=puts; /* O ponteiro p passa a apontar para a função puts que tem o seguinte prototipo: int puts(const char *) */ PrintString (String, p); /* O ponteiro é passado como parametro para PrintString */ return 0; } void PrintString (char *str, int (*func)(const char *)){ (*func)(str);/* chamada a função através do ponteiro para função */ func(str);/* maneira também válida de se fazer a chamada a função puts através do ponteiro para função func */ }

Veja que fizemos a atribuição de puts a p simplesmente usando:

p = puts;

Disto, concluímos que o nome de uma função (sem os parênteses) é, na realidade, o endereço daquela função! Note, também, as duas formas alternativas de se chamar uma função através de um ponteiro. No programa acima, fizemos esta chamada por:

(*func)(str);

e

func(str);

Estas formas são equivalentes entre si.

94

Além disto, no programa, a função PrintString() usa uma função qualquer func para imprimir a string na tela. O programador pode então fornecer não só a string mas também a função

que será usada para imprimi‐la. No main() vemos como podemos atribuir, ao ponteiro para funções p, o endereço da função puts() do C.

Em síntese, ao declarar um ponteiro para função, podemos atribuir a este ponteiro o endereço de uma função e podemos também chamar a função apontada através dele. Não podemos fazer algumas coisas que fazíamos com ponteiros "normais", como, por exemplo, incrementar ou decrementar um ponteiro para função.

10.5. Alocação Dinâmica

A alocação dinâmica permite ao programador alocar memória para variáveis quando o programa está sendo executado. Assim, poderemos definir, por exemplo, um vetor ou uma matriz cujo tamanho descobriremos em tempo de execução. O padrão C ANSI define apenas 4 funções para o sistema de alocação dinâmica, disponíveis na biblioteca stdlib.h:

No entanto, existem diversas outras funções que são amplamente utilizadas, mas dependentes do ambiente e compilador. Neste curso serão abordadas somente estas funções padronizadas.

malloc

A função malloc() serve para alocar memória e tem o seguinte protótipo:

void *malloc (unsigned int num);

A função toma o número de bytes que queremos alocar (num), aloca na memória e retorna

um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser atribuído a qualquer tipo de ponteiro. Se não houver memória suficiente para alocar a memória requisitada a

função malloc() retorna um ponteiro nulo. Veja um exemplo de alocação dinâmica com malloc():

#include <stdio.h> #include <stdlib.h> /* Para usar malloc() */ main (void){ int *p; int a; int i;

... /* Determina o valor de a em algum lugar */ p=(int *)malloc(a*sizeof(int)); /* Aloca a números inteiros p pode agora ser tratado como um vetor com a posições */ if (!p){ printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado c/ vetor com a posicoes */

p[i] = i*i; ...

return 0; }

95

No exemplo acima, é alocada memória suficiente para se armazenar a números inteiros. O operador sizeof() retorna o número de bytes de um inteiro. Ele é útil para se saber o tamanho

de tipos. O ponteiro void* que malloc() retorna é convertido para um int* pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bem sucedida. Se não tiver sido, p terá um valor nulo, o que fará com que !p retorne verdadeiro. Se a operação tiver sido bem sucedida,

podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando‐o de p[0] a p[(a-1)].

calloc

A função calloc() também serve para alocar memória, mas possui um protótipo um pouco diferente:

void *calloc (unsigned int num, unsigned int size);

A função aloca uma quantidade de memória igual a num * size, isto é, aloca memória

suficiente para um vetor de num objetos de tamanho size. Retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser atribuído a qualquer tipo de ponteiro. Se não houver memória suficiente para alocar a memória requisitada a função calloc() retorna um

ponteiro nulo. Veja um exemplo de alocação dinâmica com calloc():

#include <stdio.h> #include <stdlib.h> /* Para usar calloc() */ main (void){ int *p; int a; int i; ... /* Determina o valor de a em algum lugar */ p=(int *)calloc(a,sizeof(int)); /* Aloca a números inteiros p pode agora ser tratado como um vetor com a posições */ if (!p){ printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado vetor com a posicoes */ p[i] = i*i; ... return 0; }

No exemplo acima, é alocada memória suficiente para se colocar a números inteiros. O operador sizeof() retorna o número de bytes de um inteiro. Ele é útil para se saber o tamanho

de tipos. O ponteiro void * que calloc() retorna é convertido para um int * pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bem sucedida. Se não tiver sido, p terá

um valor nulo, o que fará com que !p retorne verdadeiro. Se a operação tiver sido bem sucedida,

podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando‐o de p[0] a p[(a-1)].

96

realloc

A função realloc() serve para realocar memória e tem o seguinte protótipo:

void *realloc (void *ptr, unsigned int num);

A função modifica o tamanho da memória previamente alocada apontada por *ptr para aquele especificado por num. O valor de num pode ser maior ou menor que o original. Um ponteiro

para o bloco é devolvido porque realloc() pode precisar mover o bloco para aumentar seu tamanho. Se isso ocorrer, o conteúdo do bloco antigo é copiado no novo bloco, e nenhuma

informação é perdida. Se ptr for nulo, aloca size bytes e devolve um ponteiro; se size é zero, a memória apontada por ptr é liberada. Se não houver memória suficiente para a alocação, um ponteiro nulo é devolvido e o bloco original é deixado inalterado.

#include <stdio.h> #include <stdlib.h> /* Para usar malloc() e realloc*/ main (void){ int *p; int a; int i; ... /* Determina o valor de a em algum lugar */ a = 30; p=(int *)malloc(a*sizeof(int)); /* Aloca a números inteiros p pode agora ser tratado como um vetor com a posicoes */ if (!p){ printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado c/ vetor com a posicoes */ p[i] = i*i; /* O tamanho de p deve ser modificado, por algum motivo ... */ a = 100; p = realloc (p, a*sizeof(int)); for (i=0; i<a ; i++) /* p pode ser tratado c/ vetor com a posicoes */ p[i] = a*i*(i-6); ... return 0; }

free

Quando alocamos memória dinamicamente é necessário que nós a liberemos quando ela não for mais necessária. Para isto existe a função free() cujo protótipo é:

void free (void *p);

Basta então passar para free() o ponteiro que aponta para o início da memória alocada. Mas você pode se perguntar: como é que o programa vai saber quantos bytes devem ser liberados? Ele sabe pois quando você alocou a memória, ele guardou o número de bytes alocados numa "tabela

97

de alocação" interna. Vamos reescrever o exemplo usado para a função malloc() usando o free() também agora:

#include <stdio.h> #include <stdlib.h> /* Para usar malloc e free */ int main (void){ int *p; int a; ... p=(int *)malloc(a*sizeof(int)); if (!p){ printf ("** Erro: Memoria Insuficiente **"); exit; } ... free(p); ... return 0; }

10.6. Alocação Dinâmica de Vetores e Matrizes

Alocação Dinâmica de Vetores

A alocação dinâmica de vetores utiliza os conceitos aprendidos na aula sobre ponteiros e as funções de alocação dinâmica apresentadas. Um exemplo de implementação para vetor real é fornecido a seguir:

98

#include <stdio.h> #include <stdlib.h> float *Alocar_vetor_real (int n) {

float *v; /* ponteiro para o vetor */ if (n < 1) { /* verifica parametros recebidos */

printf ("** Erro: Parametro invalido **\n"); return (NULL);

} /* aloca o vetor */ v = (float *) calloc (n, sizeof(float)); if (v == NULL) {

printf ("** Erro: Memoria Insuficiente **"); return (NULL);

} return (v); /* retorna o ponteiro para o vetor */

} float *Liberar_vetor_real (float *v) {

if (v == NULL) return (NULL);

free(v); /* libera o vetor */ return (NULL); /* retorna o ponteiro */

} void main (void){

float *p; int a;

... /* outros comandos, inclusive a inicializacao de a */ p = Alocar_vetor_real (a);

... /* outros comandos, utilizando p[] normalmente */ p = Liberar_vetor_real (p);

}

Alocação Dinâmica de Matrizes

A alocação dinâmica de memória para matrizes é realizada da mesma forma que para vetores, com a diferença que teremos um ponteiro apontando para outro ponteiro que aponta para o valor final, ou seja é um ponteiro para ponteiro, o que é denominado indireção múltipla. A indireção múltipla pode ser levada a qualquer dimensão desejada, mas raramente é necessário mais de um ponteiro para um ponteiro. Um exemplo de implementação para matriz real bidimensional é fornecido a seguir. A estrutura de dados utilizada neste exemplo é composta por um vetor de ponteiros (correspondendo ao primeiro índice da matriz), sendo que cada ponteiro aponta para o início de uma linha da matriz. Em cada linha existe um vetor alocado dinamicamente, como descrito anteriormente (compondo o segundo índice da matriz).

99

#include <stdio.h> #include <stdlib.h> float **Alocar_matriz_real (int m, int n) {

float **v; /* ponteiro para a matriz */ int i; /* variavel auxiliar */ if (m < 1 || n < 1) { /* verifica parametros recebidos */

printf ("** Erro: Parametro invalido **\n"); return (NULL);

} /* aloca as linhas da matriz.Um vetor de m ponteiros para float

*/ v = (float **) calloc (m, sizeof(float *)); if (v == NULL) {


} /* aloca as colunas da matriz */ for ( i = 0; i < m; i++ ) {/* m vetores de n floats */

v[i] = (float*) calloc (n, sizeof(float)); if (v[i] == NULL) {


} } return (v); /* retorna o ponteiro para a matriz */

} float **Liberar_matriz_real (int m, int n, float **v) {

int i; /* variavel auxiliar */ if (v == NULL)

return (NULL); if (m < 1 || n < 1) { /* verifica parametros recebidos */

printf ("** Erro: Parametro invalido **\n"); return (v);

} for (i=0; i<m; i++)

free (v[i]); /* libera as linhas da matriz */

free (v); /* libera a matriz (vetor de ponteiros) */ return (NULL); /* retorna um ponteiro nulo */

} void main (void) {

float **mat; /* matriz a ser alocada */

100

int l, c; /* numero de linhas e colunas da matriz */ int i, j; ... /* outros comandos, inclusive inicializacao para l e c

*/ mat = Alocar_matriz_real (l, c);

for (i = 0; i < l; i++) {

for ( j = 0; j < c; j++) {

mat[i][j] = i+j; } }

... /* outros comandos utilizando mat[][] normalmente */

mat = Liberar_matriz_real (l, c, mat);

... }

101

11. Tipos de Dados Definidos pelo Usuário.

11.1. Estruturas ‐ Primeira parte

Uma estrutura agrupa várias variáveis numa só. Funciona como uma ficha pessoal que tenha nome, telefone e endereço. A ficha seria uma estrutura. A estrutura, então, serve para agrupar um conjunto de dados não similares, formando um novo tipo de dados.

Criando estruturas

Para se criar uma estrutura usa‐se o comando struct. Sua forma geral é:

struct nome_do_tipo_da_estrutura {

tipo_1 nome_1; tipo_2 nome_2; ... tipo_n nome_n;

} variáveis_estrutura;

O nome_do_tipo_da_estrutura é o nome para a estrutura. As

variáveis_estrutura são opcionais e seriam nomes de variáveis que o usuário já estaria declarando e que seriam do tipo nome_do_tipo_da_estrutura. Um primeiro exemplo:

struct est{ int i; float f;

} a, b;

Neste caso, est é uma estrutura com dois campos, i e f. Foram também declaradas duas

variáveis, a e b que são do tipo da estrutura, isto é, a possui os campos i e f, o mesmo acontecendo com b.

Vamos criar uma estrutura de endereço:

struct tipo_endereco {

char rua [50]; int numero; char bairro [20]; char cidade [30]; char sigla_estado [3]; long int CEP;

};

102

Vamos agora criar uma estrutura chamada ficha_pessoal com os dados pessoais de uma pessoa:

struct ficha_pessoal {

char nome [50]; long int telefone; struct tipo_endereco endereco;

};

Vemos, pelos exemplos acima, que uma estrutura pode fazer parte de outra (a struct tipo_endereco é usada pela struct ficha_pessoal).

Usando estruturas

Vamos agora utilizar as estruturas declaradas na seção anterior para escrever um programa que preencha uma ficha.

#include <stdio.h> #include <string.h> struct tipo_endereco{

char rua [50]; int numero; char bairro [20]; char cidade [30]; char sigla_estado [3]; long int CEP;

}; struct ficha_pessoal{

char nome [50]; long int telefone; struct tipo_endereco endereco;

}; main (void) { struct ficha_pessoal ficha; strcpy (ficha.nome,"Luiz Osvaldo Silva"); ficha.telefone=4921234; strcpy (ficha.endereco.rua,"Rua das Flores"); ficha.endereco.numero=10; strcpy (ficha.endereco.bairro,"Cidade Velha"); strcpy (ficha.endereco.cidade,"Belo Horizonte"); strcpy (ficha.endereco.sigla_estado,"MG"); ficha.endereco.CEP=31340230; return 0; }

O programa declara uma variável ficha do tipo ficha_pessoal e preenche os seus dados. O exemplo mostra como podemos acessar um elemento de uma estrutura: basta usar o ponto (.). Assim, para acessar o campo telefone de ficha, escrevemos:

103

ficha.telefone = 4921234;

Como a struct ficha pessoal possui um campo, endereco, que também é uma struct, podemos fazer acesso aos campos desta struct interna da seguinte maneira:

ficha.endereco.numero = 10; ficha.endereco.CEP=31340230;

Desta forma, estamos acessando, primeiramente, o campo endereco da struct ficha e, dentro deste campo, estamos acessando o campo numero e o campo CEP.

Matrizes de estruturas

Uma estrutura é como qualquer outro tipo de dado no C. Podemos, portanto, criar matrizes de estruturas. Vamos ver como ficaria a declaração de um vetor de 100 fichas pessoais:

struct ficha_pessoal fichas [100];

Poderíamos então acessar a segunda letra da sigla de estado da décima terceira ficha fazendo:

fichas[12].endereco.sigla_estado[1];

Analise atentamente como isto está sendo feito

11.2. Estruturas ‐ Segunda parte

Atribuição em estruturas

Podemos atribuir duas estruturas que sejam do mesmo tipo. O C irá, neste caso, copiar uma estrutura, campo por campo, na outra. Veja o programa abaixo:

struct est1 { int i; float f;

}; void main() {

struct est1 primeira, segunda; /* Declara primeira e segunda como structs do tipo est1 */ primeira.i = 10; primeira.f = 3.1415; segunda = primeira; /* A segunda struct e' agora igual a primeira */ printf(" Os valores armazenados na segunda struct sao : %d e %f ", segunda.i , segunda.f);

}

São declaradas duas estruturas do tipo est1, uma chamada primeira e outra chamada

segunda. Atribuem‐se valores aos dois campos da struct primeira. Os valores de primeira são copiados em segunda apenas com a expressão de atribuição:

segunda = primeira;

104

Todos os campos de primeira serão copiados na segunda. Note que isto é diferente do que acontecia em vetores, onde, para fazer a cópia dos elementos de um vetor em outro, tínhamos que copiar elemento por elemento do vetor. Nas structs é muito mais fácil!

Porém, devemos tomar cuidado na atribuição de structs que contenham campos ponteiros. Veja abaixo:

#include <stdio.h> #include <string.h> #include <stdlib.h> struct tipo_end { char *rua; /* A struct possui um campo que é um ponteiro */ int numero; }; void main(){

struct tipo_end end1, end2; char buffer[50]; printf("\nEntre o nome da rua:"); gets(buffer); /* Le o nome da rua em uma string de buffer */ end1.rua = (char *) malloc((strlen(buffer)+1)*sizeof(char)); /* Aloca a quantidade de memoria suficiente para armazenar a string

*/ strcpy(end1.rua, buffer); /* Copia a string */ printf("\nEntre o numero:"); scanf("%d", &end1.numero);

end2 = end1; /* ERRADO end2.rua e end1.rua estao apontando para a

mesma regiao de memoria */

printf("Depois da atribuicao:\n Endereco em end1 %s %d \n Endereco em end2 %s %d", end1.rua,end1.numero,end2.rua, end2.numero);

strcpy(end2.rua, "Rua Mesquita"); /* Uma modificacao na memoria apontada por end2.rua causara' a modificacao do que e' apontado por end1.rua, o que, esta' errado !!! */

end2.numero = 1100; /* Nesta atribuicao nao ha problemas */ printf(" \n\nApos modificar o endereco em end2:\n Endereco em end1 %s %d \n Endereco em end2 %s %d", end1.rua, end1.numero, end2.rua, end2.numero);

}

Neste programa há um erro grave, pois ao se fazer a atribuição end2 = end1, o campo

rua de end2 estará apontando para a mesma posição de memória que o campo rua de end1. Assim, ao se modificar o conteúdo apontado por end2.rua estaremos também modificando o

conteúdo apontado por end1.rua !!!

Passando estruturas para funções

No exemplo apresentado no item usando, vimos o seguinte comando:

105

strcpy (ficha.nome,"Luiz Osvaldo Silva");

Neste comando um elemento de uma estrutura é passado para uma função. Este tipo de operação pode ser feita sem maiores considerações.

Podemos também passar para uma função uma estrutura inteira. Veja a seguinte função:

void PreencheFicha (struct ficha_pessoal ficha) {

... }

Como vemos acima é fácil passar a estrutura como um todo para a função. Devemos observar que, como em qualquer outra função no C, a passagem da estrutura é feita por valor. A estrutura que está sendo passada, vai ser copiada, campo por campo, em uma variável local da função PreencheFicha. Isto significa que alterações na estrutura dentro da função não terão efeito na variável fora da função. Mais uma vez podemos contornar este pormenor usando ponteiros e passando para a função um ponteiro para a estrutura.

Ponteiros para estruturas

Podemos ter um ponteiro para uma estrutura. Vamos ver como poderia ser declarado um ponteiro para as estruturas de ficha que estamos usando nestas seções:

struct ficha_pessoal *p;

Os ponteiros para uma estrutura funcionam como os ponteiros para qualquer outro tipo de dados no C. Para usá‐lo, haveria duas possibilidades. A primeira é apontá‐lo para uma variável struct já existente, da seguinte maneira:

struct ficha_pessoal ficha; struct ficha_pessoal *p; p = &ficha;

A segunda é alocando memória para ficha_pessoal usando, por exemplo, malloc():

#include <stdlib.h> main() {

struct ficha_pessoal *p; int a = 10; /* Faremos a alocacao dinamica de 10 fichas pessoais */ p = (struct ficha_pessoal *) malloc (a * sizeof(struct

ficha_pessoal)); p[0].telefone = 3443768; /* Exemplo de acesso ao campo telefone da

primeira ficha apontada por p */ free(p);

}

106

Há mais um detalhe a ser considerado. Se apontarmos o ponteiro p para uma estrutura

qualquer (como fizemos em p = &ficha; ) e quisermos acessar um elemento da estrutura poderíamos fazer:

(*p).nome

Os parênteses são necessários, porque o operador . tem precedência maior que o operador

* . Porém, este formato não é muito usado. O que é comum de se fazer é acessar o elemento nome através do operador seta, que é formado por um sinal de "menos" (‐) seguido por um sinal de "maior que" (>), isto é: -> . Assim faremos:

p->nome

A declaração acima é muito mais fácil e concisa. Para acessarmos o elemento CEP dentro de endereco faríamos:

p->endereco.CEP

11.3. Declaração Union

Uma declaração union determina uma única localização de memória onde podem estar armazenadas várias variáveis diferentes. A declaração de uma união é semelhante à declaração de uma estrutura:

union nome_do_tipo_da_union {

tipo_1 nome_1; tipo_2 nome_2; ... tipo_n nome_n;

} variáveis_union;

Como exemplo, vamos considerar a seguinte união:

union angulo{ float graus; float radianos;

};

Nela, temos duas variáveis (graus e radianos) que, apesar de terem nomes diferentes, ocupam o mesmo local da memória. Isto quer dizer que só gastamos o espaço equivalente a um

único float. Uniões podem ser feitas também com variáveis de diferentes tipos. Neste caso, a memória alocada corresponde ao tamanho da maior variável no union. Veja o exemplo:

#include <stdio.h> #define GRAUS 'G' #define RAD 'R' union angulo {

int graus; float radianos; }; void main() {

107

union angulo Ang char op; printf("\nNumeros em graus ou radianos? (G/R):"); scanf("%c",&op); if (op == GRAUS) {

ang.graus = 180; printf("\nAngulo: %d\n",ang.graus); } else if (op == RAD) {

ang.radianos = 3.1415; printf("\nAngulo: %f\n",ang.radianos); } else printf("\nEntrada invalida!!\n");

}

Temos que tomar o maior cuidado pois poderíamos fazer:

#include <stdio.h> union numero{ char Ch; int I; float F; }; main (void){ union numero N; N.I = 123; printf ("%f",N.F); /* Vai imprimir algo que nao e' necessariamente 123 ...*/ return 0; }

O programa acima é muito perigoso pois você está lendo uma região da memória, que foi "gravada" como um inteiro, como se fosse um ponto flutuante. Tome cuidado! O resultado pode não fazer sentido.

11.4. Enumerações

Numa enumeração podemos dizer ao compilador quais os valores que uma determinada variável pode assumir. Sua forma geral é:

enum nome_do_tipo_da_enumeração {lista_de_valores} lista_de_variáveis;

Vamos considerar o seguinte exemplo:

enum dias_da_semana {segunda, terca, quarta, quinta, sexta, sabado, domingo};

O programador diz ao compilador que qualquer variável do tipo dias_da_semana só pode ter os valores enumerados. Isto quer dizer que poderíamos fazer o seguinte programa:

#include <stdio.h> enum dias_da_semana {segunda,terca,quarta,quinta,sexta,sabado,domingo};

108

main (void){ enum dias_da_semana d1,d2; d1=segunda; d2=sexta; if (d1==d2) printf ("O dia e o mesmo."); else printf ("São dias diferentes."); return 0; }

Você deve estar se perguntando como é que a enumeração funciona. Simples. O compilador pega a lista que você fez de valores e associa, a cada um, um número inteiro. Então, ao primeiro da lista, é associado o número zero, o segundo ao número 1 e assim por diante. As variáveis declaradas são então variáveis int.

11.5. O Comando sizeof

O operador sizeof é usado para se saber o tamanho de variáveis ou de tipos. Ele retorna o tamanho do tipo ou variável em bytes. Devemos usá‐lo para garantir portabilidade. Por exemplo, o

tamanho de um inteiro pode depender do sistema para o qual se está compilando. O sizeof é um operador porque ele é substituído pelo tamanho do tipo ou variável no momento da compilação. Ele não é uma função. O sizeof admite duas formas:

sizeof nome_da_variável sizeof (nome_do_tipo)

Se quisermos então saber o tamanho de um float fazemos sizeof(float). Se declararmos a variável f como float e quisermos saber o seu tamanho faremos sizeof f. O operador sizeof também funciona com estruturas, uniões e enumerações.

Outra aplicação importante do operador sizeof é para se saber o tamanho de tipos definidos pelo usuário. Seria, por exemplo, uma tarefa um tanto complicada a de alocar a memória

para um ponteiro para a estrutura ficha_pessoal, criada na primeira página desta aula, se não fosse o uso de sizeof. Veja o exemplo:

#include <stdio.h> struct tipo_endereco { char rua [50]; int numero; char bairro [20]; char cidade [30]; char sigla_estado [3]; long int CEP; }; struct ficha_pessoal { char nome [50]; long int telefone; struct tipo_endereco endereco; }; void main(void) { struct ficha_pessoal *ex; ex = (struct ficha_pessoal *) malloc(sizeof(struct ficha_pessoal)); ...

109

free(ex); }

11.6. O Comando typedef

O comando typedef permite ao programador definir um novo nome para um determinado tipo. Sua forma geral é:

typedef antigo_nome novo_nome;

Como exemplo vamos dar o nome de inteiro para o tipo int:

typedef int inteiro;

Agora podemos declarar o tipo inteiro.

O comando typedef também pode ser utilizado para dar nome a tipos complexos, como as estruturas. As estruturas criadas no exemplo da página anterior poderiam ser definidas como tipos através do comando typedef. O exemplo ficaria:

110

#include <stdio.h> typedef struct tipo_endereco { char rua [50]; int numero; char bairro [20]; char cidade [30]; char sigla_estado [3]; long int CEP; } TEndereco;

typedef struct ficha_pessoal { char nome [50]; long int telefone; TEndereco endereco; }TFicha; void main(void) {

TFicha *ex;

... }

Veja que não é mais necessário usar a palavra chave struct para declarar variáveis do tipo ficha pessoal. Basta agora usar o novo tipo definido TFicha.

11.7. Uma aplicação de structs: as listas simplesmente encadeadas

Várias estruturas de dados complexas podem ser criadas utilizando simultaneamente structs e ponteiros. Uma destas estruturas é a lista encadeada. Uma lista encadeada é uma seqüência de structs, que são os nós da lista, ligados entre si através de ponteiros. Esta seqüência pode ser acessada através de um ponteiro para o primeiro nó, que é a cabeça da lista. Cada nó contém um ponteiro que aponta para a struct que é a sua sucessora na lista. O ponteiro da última struct da lista aponta para NULL, indicando que se chegou ao final da lista. Esta estrutura de dados é criada dinamicamente na memória (utiliza‐se malloc() e free()), de modo que se torna simples introduzir nós nela, retirar nós, ordenar os nós, etc. Não vamos entrar em detalhes sobre todos os algoritmos que poderíamos criar em uma lista encadeada, pois isto geralmente é feito em cursos de algoritmos e estruturas de dados, não se incluindo no escopo deste curso. Aqui, veremos somente formas de se criar uma lista encadeada em C e também maneiras simples de percorrer esta lista.

Supondo que queiramos criar uma lista encadeada para armazenar os produtos disponíveis em uma loja. Poderíamos criar um nó desta lista usando a seguinte struct:

struct Produto { int codigo; /* Codigo do produto */ double preco; /* Preco do produto */ struct Produto *proximo; /* Proximo elemento da lista encadeada de Produtos */ };

Note que esta struct possui, além dos campos de dados codigo e preco, um campo

adicional que é um ponteiro para uma struct do tipo Produto. É este campo que será utilizado para

apontar para o próximo nó da lista encadeada. O programa a seguir faz uso desta struct, através de um novo tipo criado por um typedef, para criar uma lista de produtos de uma loja:

#include <stdio.h> #include <stdlib.h> /* Estrutura que será usada para criar os nós da lista */

111

typedef struct tipo_produto { int codigo; /* Codigo do produto */ double preco; /* Preco do produto */ struct tipo_produto *proximo; /* Proximo elemento da lista encadeada de Produtos */ } TProduto; /* Prototipos das funcoes para inserir e listar produtos */ void inserir(TProduto **cabeca); void listar (TProduto *cabeca); int main() { TProduto *cabeca = NULL; /* Ponteiro para a cabeca da lista */ TProduto *noatual; /* Ponteiro a ser usado para percorrer a lista no momento de desalocar seus elementos*/ char q; /* Caractere para receber a opcao do usuario */ do { printf("\n\nOpcoes: \n printf("I -> para inserir novo produto\n”); printf("L -> para listar os produtos; \n”; printf("S -> para sair \n:"); scanf("%c", &q); /* Le a opcao do usuario */ switch(q) { case 'i': case 'I': inserir(&cabeca); break; case 'l': case 'L': listar(cabeca); break; case 's': case 'S': break; default: printf("\n\n Opcao nao valida"); } fflush(stdin); /* Limpa o buffer de entrada */ } while ((q != 's') && (q != 'S') ); /* Desaloca a memoria alocada para os elementos da lista */ noatual = cabeca; while (noatual != NULL) {

112

cabeca = noatual->proximo; free(noatual); noatual = cabeca; } } /* Lista todos os elementos presentes na lista encadeada */ void listar (TProduto *noatual) { int i=0; while( noatual != NULL) /* Enquanto nao chega no fim da lista */ { i++; printf("\n\nProduto numero %d\nCodigo: %d \nPreco:R$%.2lf", i, noatual->codigo, noatual->preco); noatual = noatual->proximo; /* Faz noatual apontar para o proximo no */ } } /* Funcao para inserir um novo no, ao final da lista */ void inserir (TProduto **cabeca) { TProduto *noatual, *novono; int cod; double preco; printf("\n Codigo do novo produto: "); scanf("%d", &cod); printf("\n Preco do produto:R$"); scanf("%lf", &preco); if (*cabeca == NULL)/* Se ainda nao existe nenhum produto na lista */ { /* cria o no cabeca */ *cabeca = (TProduto *) malloc(sizeof(TProduto)); (*cabeca)->codigo = cod; (*cabeca)->preco = preco; (*cabeca)->proximo = NULL; } else { /* Se ja existem elementos na lista, deve percorre-la ate' o seu final e inserir o novo elemento */ noatual = *cabeca;

while(noatual->proximo != NULL) noatual = noatual->proximo; /* Ao final do while, noatual aponta para o ultimo no */

113

novono = (TProduto *) malloc(sizeof(TProduto));/* Aloca memoria para o novo no */ novono->codigo = cod; novono->preco = preco; novono->proximo = NULL; noatual->proximo = novono; /* Faz o ultimo no apontar para o novo no */ } }

É interessante notar que, no programa anterior não existe limite para o número de produtos que se vai armazenar na lista. Toda vez que for necessário criar um novo produto, memória para ele será alocada e ele será criado no final da lista. Note que a função inserir recebe o endereço do ponteiro cabeça da lista. Qual a razão disto? A razão é que o endereço para o qual a cabeça da lista aponta poderá ser modificado caso se esteja inserindo o primeiro elemento na lista. Tente entender todos os passos deste programa, pois ele possui várias das características presentes em programas que manipulam listas encadeadas. Também é importante notar que várias outras estruturas de dados complexas podem ser criadas com structs contendo ponteiros que apontam para outras structs.

114

12. Conceitos Básicos de C++ A linguagem C++ foi criada em 1985 por Bjarne Stroustrup do Lab. AT&T com o objetivo de

suportar Abstração de Dados e Programação Orientada ao Objeto. É usada principalmente no desenvolvimento de sistemas.

O nome C++ (pronunciado C plus plus) foi adotado para significar a evolução natural da linguagem C.

Foi criada para manter as características da linguagem C

• Linguagem de baixo nível;

• Versatilidade;

• Popularidade.

Origem da linguagem C++:

• C

• Ada

• BCPL

• Simula67

12.1. O que é programação orientada à objetos?

É uma maneira diferente de abordar a tarefa de programação, que procura acomodar o aumento da complexidade dos programas, pois utilizando a programação estruturada, quando um programa atinge certo tamanho, ele torna‐se incontrolável, pois a sua complexidade excede a capacidade desta forma de programação. Atualmente, muitos projetos estão próximos ou no ponto em que o tratamento estruturado não mais funciona. Para resolver este problema, a programação orientada à objetos foi criada.

A programação orientada à objetos aproveitou as melhores idéias da programação estruturada e combinou‐as com novos conceitos, permitindo que um problema seja mais facilmente decomposto em subgrupos relacionados.

Todas as linguagem de programação orientadas à objetos possuem três características em comum: objetos, polimorfismo e herança.

115

12.2. CARACTERÍSTICAS PRINCIPAIS DE UMA LINGUAGEM ORIENTADA AO OBJETO

Objetos

Um objeto é uma entidade lógica que contêm dados e códigos para manipular estes dados. Dentro de um objeto, alguns códigos e/ou dados podem ser privados ao objeto e inacessíveis diretamente para qualquer elemento fora dele. Essa ligação de códigos e dos dados é frequentemente referenciada como encapsulação. Quando se define um objeto, cria‐se implicitamente um novo tipo de dado.

Polimorfismo

Polimorfismo significa essencialmente que um nome pode ser usado para muitos propósitos relacionados, mas ligeiramente diferentes. A intenção é permitir que um nome possa ser usado para especificar uma classe geral de ações.

Herança

Herança é o processo em que o objeto pode adquirir as propriedades de outro objeto. Sem o uso de classificações, um objeto precisa definir explicitamente todas as suas características. Usando‐se classificações, um objeto precisa definir somente aquelas qualidades que o tomam único dentro de sua classe. Pode herdar as qualidades que compartilha com a classe mais geral. E o mecanismo de herança que toma possível a um objeto ser uma instância específica de uma classe mais geral.

Sobrecarga

Urna maneira de se obter polimorfismo em C++, é pelo uso de sobrecarga de funções. Em C++, duas ou mais funções podem compartilhar o mesmo nome, contanto que as suas declarações de parâmetros sejam diferentes. As funções que compartilham o mesmo nome são conhecidas como sobrecarregadas e o processo é chamado de sobrecarga de funções.

12.3. ELEMENTOS DA LINGUAGEM C++

C++ é um superconjunto da linguagem C. Isso significa que é possível escrever programas em C++ idênticos a programas em C.

116

Exemplo:

#include<iostream.h> void main(void) {

int i; char str[80]; // este é um comentário printf("\n Você pode usar a função printf() se precisar"); cout « "C++ é fácil \n"; // equivale a printf() cout « "informe um número: "; cin » i; // equivale a scanf() cout « "informe uma string: "; cin » str; cout « str;

}

Classes e Objetos

Uma classe é similar a uma estrutura. Um exemplo de uma classe é mostrada abaixo:

#include<iostream.h> //isto cria uma classe fila class fila{ int q[100]; int sloc, rloc; public: void init( void ); void qput( int i ); int qget( void ); };

Observações:

• Uma classe é normalmente divida em duas partes: parte privada e parte publica. Qualquer

parte pode conter tanto variáveis quanto funções.

• Pelo default todos os elementos de uma classe são privados.

• Os elementos públicos são definidos após a palavra reservada public.

• As funções definidas dentro de uma classe são chamadas funções membros e podem ser de

tipo private (privadas) ou public (init(), qput() e qget() no exemplo acima). As funções privadas

só podem ser chamadas por outros membros da classe, enquanto as funções publicas podem

ser chamadas por qualquer parte do programa.

• Os elementos da parte privada não podem ser acessados por qualquer função que não seja

117

membro da classe. Somente estas funções podem manipular os dados privados da classe.

• Esta é uma maneira de se conseguir a encapsulamento. Isto é, o acesso a certos itens de

dados pode ser firmemente controlado mantendo‐os privados.

• Deve‐se tentar limitar ou eliminar o uso de elementos públicos. O ideal é tomar todos os

dados privados e controlar o acesso a eles com funções public.

A forma geral de uma declaração classe é:

class nome-de-classe { dados e funções privados public: dados e funções públicos } lista de objetos;

Criação de Objetos

Uma vez definida uma classe, podemos criar um objeto daquele tipo usando o nome da class. O nome da classe toma‐se um novo especificador de tipo de dado.

Podemos também criar objetos, quando definimos a classe, colocando os seus nomes após o fechamento das chaves, exatamente como fazemos com estruturas.

#include<iostream.h>

// isto cria uma classe fila

class fila {

int q[100];

int sloc, rloc;

public:

void init(void);

void qput(int i);

int qget(void);

}a, b; // criação de 2 objetos.

#include<iostream.h>

// isto cria uma classe fila.

class fila {

int q[100];

int sloc, rloc;

public:

void init(void);

void qput(int i);

int qget(void);

};

fila a, b; // criação de 2 objetos

118

Funções Membros

A forma geral de se definir uma função membro é:

tipo_de_dado nome_da_class :: nome_da_função (lista de parâmetros) { corpo da função........ }

• O tipo _ de_dados e lista_de ‐parâmetros são iguais àqueles usados nas funções em C.

• O operador :: é chamado de operador de escopo de resolução. Ele informa ao compilador que

essa função pertence a classe <nome_da_classe> ou, que a função qput( ) está no escopo da fila.

• Em C++ , muitas classes diferentes podem usar os mesmos nomes de função. O compilador sabe

qual função pertence a qual classe por causa do operador de escopo de resolução e do nome da

classe.

Exemplo de uma função membro

void fila::qput (int I) // fila é uma classe { if( sloc==100) cout « " a fila está cheia"; sloc++; q[sloc] = i; }

Para chamar uma função membro de uma parte do seu programa que não faz parte da classe, você deve usar o nome do objeto e o operador ponto.Exemplo: Criação de classes e objetos

// isto cria a classe fila class fila { int q [100 ], int sloc, rloc; public: void init (void); void qput (int i); int qget (void); }; void fila: :init (void) {

rloc = sloc = 0; }

119

void fila::qput (int i) {

if(sloc == 100) cout « "a fila está cheia";

sloc++; q[sloc] = i;

} int fila :: qget (void) {

if(rloc = = sloc) {

cout« "fila corrompida"; return (0);

} rloc++; return q[rloc];

} void main (void) {

fila a, b; // cria dois objetos fila a.init( ); b.init( ); a.qput(10); b.qput(19); a.qput(20); b.qput(1); cout « a.qget ()«" "; cout « a.qget ()«" "; cout « b.qget ()«" "'; cout « b.qget ()«" ";

}

Lembre‐se: As partes privadas de um objeto são acessíveis somente às funções membros daquele objeto. Por exemplo, uma declaração como: a.rloc = 0 não podia estar na‐ função main().

As funções membro da fila são definidas antes da função main( ). Embora não existam regras que ditem isso (elas podem ser definidas em qualquer lugar do programa), esse é o tratamento mais comum usado em códigos escritos em C++.

linguagem progr c

Technology