O pré-processador executa transformações controladas no arquivo fonte antes da compilação. Os comandos (sentenças) sempre são iniciados por #.

Transcrição

1 O modificador static Se o modificador static for utilizado na declaração de uma variável local em uma função, essa variável não perderá seu valor entre chamadas à função. void rot1() { static int var1=0; printf( %d\n, var1++); rot1(); rot1(); rot1(); No vídeo obteremos: Observe no exemplo acima, a variável var1 foi iniciada com zero apenas o início do programa os incrementos dentro do printf alteram o valor que permanecerá nessa variável mesmo quando a função rot1 não estiver executando. O pré-processador O pré-processador executa transformações controladas no arquivo fonte antes da compilação. Os comandos (sentenças) sempre são iniciados por #. #include Incluiu o arquivo especificado. trata o texto no arquivo especificado como se esse texto aparecesse no arquivo corrente. Formato: #include arquivo.ext Inclui o arquivo especificado, encontrado no diretório corrente. Se ele não for encontrado, a busca pelo arquivo continua no diretório de includes. #include <arquivo.ext> Por que o utilizar #include? Inclui o arquivo especificado, encontrado no diretório de includes. O #include é utilizando para incluir o arquivo que contém os protótipos das funções nas bibliotecas utilizadas. O que são protótipos? Protótipos são definições dos tipos dos parâmetros e tipo do valor retornado pela função. O compilador só é capaz de compilar as chamadas às funções as quais tem os parâmetros e o tipo retornado previamente declarados. Assim, devemos declará-la completamente ou pelo menos seu protótipo antes que ela possa antes ser chamada. printf( Hello World\n ); #define Define uma macro. Formato: #define <id1>[( <id2>,... )] < texto que substituirá > A diretiva #define define uma macro. Macros fornecem um mecanismo para substituição com ou sem um junto formal de parâmetros. Todas as instâncias subseqüentes do identificador <id1> no arquivo fonte será substituído pelo texto definido por < texto que substituirá >.

2 Se <id1> é seguido IMEDIATAMENTE por um (, o identificador após o abre parênteses (<id2>, etc.) é tratado como parâmetros de uma função. Todas as instâncias de <id2> em < texto que substituirá > serão substituídas com o texto atual para <id2> quando <id1> foi referência dado no arquivo fonte. Para continuar as definições em outra linha, termine a linha atual com \. Exemplos: Considere o programa abaixo: após o pré-processamento obteremos: #define TRUE 1 #define FALSE 0 if (TRUE) printf( VERDADEIRO ) if (!FALSE) printf( FALSO ) todas os protótipos do stdio.h, inclusive: int _Cdecl printf (const char * format,...); if (1) printf( VERDADEIRO ); if (!0) printf( FALSO ); Considere o programa abaixo: #define BEGIN { #define END void main() BEGIN printf( VERDADEIRO ); END após o pré-processamento obteremos: todas os protótipos do stdio.h, inclusive: int _Cdecl printf (const char * format,...); void main() { printf( VERDADEIRO ) #define com parâmetros Considere o programa abaixo: #define MAX(A,B) A>B?A:B int x=10, y=20; float r1=1.2, r2=2.3; printf( %d\n, MAX(x, y)); printf( %d\n, MAX(x-y, x+y)); printf( %f\n, MAX(r1, r2)); após o pré-processamento obteremos: todas os protótipos do stdio.h, inclusive: int _Cdecl printf (const char * format,...); int x=10, y=20; float r1=1.2, r2=2.3; printf( %d\n, x>y?x:y); printf( %d\n, x-y>x+y?x-y:x+y); printf( %f\n, r1>r2?r1:r2); Considere o programa abaixo: #define SQR(X) X*X int x=10; printf( %d\n, SQR(x)); printf( %d\n, SQR(x+1)); após o pré-processamento obteremos: todas os protótipos do stdio.h, inclusive: int _Cdecl printf (const char * format,...); int x=10; printf( %d\n, x*x); (resultado: 100) printf( %d\n, x+1*x+1); (resultado: 21) A precedência deve ser considerada após a substituição do #define. Assim, para evitar surpresas desagradáveis, como no exemplo acima, muitas vezes cercamos os parâmetros com parênteses. Por exemplo: #define SQR(X) (X)*(X).

3 Montagem Condicional O préprocessador permite também a utilização de diretivas para indicar partes do programa que devem ser ignoradas (não são compiladas nem geram código). As diretivas que controlam a montagem condicional são: #ifdef, #ifndef, #if, #elif, #else e #endif. O exemplo abaixo, composto por dois arquivos (principal.c e biblioteca.h), usa compilação condicional. No arquivo principal.c a compilação do printf( %d, i); ocorrerá apenas se o #define DEBUG estiver declarado. No arquivo biblioteca.h é implementado um controle que realizará a inclusão do conteúdo desse arquivo apenas uma vez, mesmo que o #include biblioteca.h aconteça diversas vezes. //arquivo principal.c #include biblioteca.h #define DEBUG int i; i=leint(); #ifdef DEBUG printf( %d, i); #endif mostraint(i); //arquivo biblioteca.h #ifndef BIBLIOTECA_H #define BIBLIOTECA_H void mostraint(int var1); int leint(); #endif Exercício: Pesquise sobre as diretivas de compilação condicional e procure na Internet exemplos de utilização dessas diretivas. Criação e Utilização de Bibliotecas de Funções Muitas vezes, por diversas razões, se deseja criar rotinas empacotadas separadamente do programa principal. A esses pacotes de rotinas costumamos chamar de bibliotecas. Duas formas de implementação são utilizadas para criar bibliotecas, uma utiliza arquivos objeto (.obj) e a outra utiliza arquivos de biblioteca (.lib). O arquivo de biblioteca é a união de vários arquivos objetos. Quanto à utilização tanto os arquivos objeto quanto os arquivos de biblioteca comportam-se da mesma forma e são utilizados seguindo os mesmos critérios. Para entender a utilização de bibliotecas de funções é necessário um entendimento prévio do funcionamento da compilação e da ligação. A compilação transforma o arquivo fonte texto escrito pelo programador em um arquivo objeto, gerado na linguagem do processador onde o programa será executado. Um arquivo objeto contém apenas o código correspondente ao que existe no arquivo fonte, isso significa que funções que são chamadas, mas não estão implementadas no arquivo fonte, não farão parte no arquivo objeto gerado, essas funções serão apenas referenciadas. A ligação junta todos os arquivos objetos gerando um arquivo executável. A ligação é responsável também pelo preenchimento dos endereços de chamada das funções juntadas. Para que o compilador consiga interpretar e gerar o código da chamada de uma função é necessário que o compilador tenha informações sobre os tipos dos parâmetros e do valor retornado pela função. Se essa função não está declarada antes da chamada no mesmo arquivo, a utilização de um protótipo da função a declaração da primeira linha da função seguida por ponto e vírgula é necessária para que a compilação possa prosseguir. O processo de ligação deve de alguma forma conhecer a localização dos arquivos que serão unidos para criação do executável. Espaço de trabalho (no Visual C ) ou projeto (no Turbo e Borland C) são estruturas utilizadas para indicar a localização dos arquivos e dessa forma permitir que partes de um programa, desenvolvidas separadamente, possam ser unidas para formar um único executável. Sempre que se deseja utilizar uma biblioteca é necessário o arquivo objeto (.obj) contendo as funções desejadas e o arquivo de cabeçalhos (.h) que define os protótipos das funções incluídas na biblioteca. Da mesma forma para se criar uma biblioteca coloca-se todas as funções desejadas em um arquivo fonte (.c) que após a compilação gerará um arquivo objeto (.obj). Cria-se também um arquivo de cabeçalhos com extensão (.h) colocando-se os protótipos das funções.

4 Exemplo: Definição da biblioteca //arquivo biblio.c void mostraint(int var1) { printf( %d\n, var1); int leint() { int i; scanf( %d, &i); return i; //arquivo biblioteca.h void mostraint(int var1); int leint(); Após a compilação será gerado o arquivo biblio.obj. Utilização da biblioteca //arquivo principal.c #include biblioteca.h int i; i=leint(); mostraint(i); Após a compilação será gerado o arquivo principal.c. A união das rotinas contidas no arquivo biblio.obj com o arquivo principal.c ocorre com o processo de ligação. Após a ligação o arquivo.exe será gerado. Estruturas struct Uma estrutura (struct) é um agrupamento de variáveis em um registro único. struct [<struct-type-name>] { <type> <variable-names> ;... [<struct-variables>] ; Onde: <struct-type-name> é um nome opcional para referenciar o tipo da estrutura. <struct-variables> declarações opcionais das variáveis do tipo da estrutura. <struct-type-name> e <struct-variables> são opcionais, mas pelo menos um deles deve aparecer.

5 Por exemplo, struct data { int dia, mês, ano; struct pessoa { char nome[30]; char ender[30]; long cep; double salario; struct data nascimento, contratacao; var1; Declaração de uma variável do tipo estrutura: struct pessoa pess; Acesso aos campos da estrutura: var1.cep= ; pess.nascimento.dia=10; Ponteiros para estruturas Declaração de um ponteiro para uma estrutura: struct data *p; Acesso aos campos da estrutura através do ponteiro: (*p).cep= ; p->nascimento.dia=10; Lembre-se que o ponteiro p deve estar indicando uma área de memória reservada para que o acesso possa ser realizado. Campos de bits Campos de bits permitem acessos para alguns bits de uma variável. Um campo de bits é um elemento de uma estrutura que é definida em termos de bits. Usando um tipo especial de definição de struct, é possivel declarar uma campo da estrutura que pode variar de 1 a 16 bits de comprimento. Por exemplo, struct bit_field { int bit_1 : 1; int bits_2_to_5 : 4; int bit_6 : 1; int bits_7_to_16 : 10; bit_var; Uniões Uma união (union) consiste de uma variável que pode conter valores de diferentes tipos compartilhando a mesma área de memória. Uma união é semelhante a uma struct, exceto que ela permite definir variáveis que compartilham o mesmo espaço de armazenamento.

6 Formato: union [<union-type-name>] { <type> <variable-names> ;... [<union-variables>] ; Por exemplo, union int_or_long { int i; long l; a_number; O compilador alocará memória suficiente para acomodar o elemento maior na união. Ao contrário da struct, as variáveis a_number.i e a_number.l ocupam a mesma localização em memória. Assim, escrevendo em uma irá escrever sobre o valor da outra. Acessos aos elementos de uma união são feitos da mesma maneira como em uma struct. Definições de Tipos Formato: typedef <type-definition> <identifier> ; Associa um nome novo de tipo <identifier> a um tipo <type-definition>. Exemplos: typedef int INTEGER; /* criação do tipo INTEGER */ INTEGER var2; /* utilização do tipo */ typedef struct { int dia, mes, ano; tipodata; tipodata aniversario; Parâmetros para a Função main Pode-se usar dois argumentos na função main(). Esses argumentos são atribuídos pelo sistema operacional no momento da iniciação do programa. O primeiro argumento é um inteiro que contém o número de elementos (cadeias de caracteres) recebidos do S.O. O segundo argumento é um vetor de ponteiros para as cadeias de caracteres recebidas. void main(int argc, char *argv[]) { printf( Exite(m) %d parâmetros\n, argc); if (argc!=2) printf( %s\n, Número inválido de parâmetros\n ); else printf( %s %s\n, Parâmetro:, argv[1]);

7 Operações com Arquivos Funções com protótipos no arquivo de cabeçalhos stdio.h. Função fopen() Abre um arquivo FILE *fopen(const char *filename, const char *mode); fopen abre o arquivo com o nome filename e retorna um ponteiro para uma estrutura de informações do arquivo aberto. Se o ponteiro é NULL, indica erro de abertura. A cadeia de caracteres mode indica o modo de abertura do arquivo. modo descrição r abre para leitura w abre para escrita a abre para escrita no fim do arquivo + leitura/escrita b arquivo binário t arquivo texto (default) Função fclose() Fecha um arquivo. int fclose(file *stream); Grava no disco todas informações associadas ao arquivo antes de fechá-lo. Retorna zero no sucesso ou EOF se um erro for detectado. Função fgetc() int fgetc(file *stream); Retorna o caracter atual do arquivo e avança o indicador para o próximo caracter ou EOF para indicar fim de arquivo. Função fputc() int fputc(int c, FILE *stream); Escreve o caracter c no arquivo. Função feof() int feof(file *stream); Retorna 1 para indicar fim do arquivo ou 0 caso contrário.

8 Exemplo: char ch; FILE *fpent, *fpsai; char arqent[80], arqsai[80]; printf("arquivo de entrada: "); gets(arqent); if (!(fpent=fopen(arqent, "rb"))) { printf("erro na abertura do arquivo %s\n", arqent); return; printf("arquivo de saida: "); gets(arqsai); if (!(fpsai=fopen(arqsai, "wb"))) { printf("erro na abertura do arquivo %s\n", arqsai); return; while (!feof(fpent)) { ch=fgetc(fpent); fputc(ch, fpsai); if (ch==' ') { while ((ch=fgetc(fpent))==' '); fputc(ch, fpsai); fclose(fpsai); fclose(fpent); Macros putc() e getc() A macros putc() e getc() são compatíveis às funções fputc() e fgetc(), respectivamente. Existem por motivos de compatibilidade. Arquivos Padrões Arquivos definidos automaticamente abertos quando o programa é iniciado. Esses arquivos são: stdin dispositivo de entrada padrão (teclado) stdout dispositivo de saída padrão (vídeo) stderr dispositivo de saída padrão de erros (vídeo) stdaux dispositivo auxiliar padrão stdprn impressora padrão Esses arquivos estão declarados no stdio.h. Exemplos: #define mostracaracter(ch) putc(ch, stdout) #define lecaracter() getc(stdin) Função exit() void exit(int status); Terminam o programa. O valor de status é retornando à função chamadora. Normalmente um valor 0 é usado para indicar uma finalização normal e o valor não zero indica algum erro.