Capítulo 14 - Programas de Grande Dimensão

Quando se escrevem programas de grande dimensão, estes devem ser divididos em módulos. Estes módulos, em C, são simplesmente arquivo contendo coleções de funções, de algum modo relacionadas. Um dos módulos, e somente um, deverá conter a função main().

Podemos criar as nossas próprias bibliotecas de funções, escrevendo conjuntos destas, relacionadas entre si, e colocadas nos seus próprios módulos (arquivos fonte). Estes módulos poderão depois ser partilhados por vários programas, incluindo-os simplesmente na compilação, ou se estiverem previamente compilados, incluindo-os apenas na fase de ligação.

Assim, estes módulos irão naturalmente dividir-se em grupos comuns de funções, podendo ser compilados previamente, e o seu código objecto agrupado numa biblioteca (library - arquivos com a extensão .lib). Esta biblioteca poderá depois ser simplesmente ligada a programas que utilizem alguma ou algumas das suas funções.

Arquivos de inclusão

Quando se adota a filosofia de programação modular, naturalmente cada módulo terá o seu conjunto de constantes, tipos, variáveis, e funções, etc. de uma forma o mais autocontida possível. No entanto, quando outro módulo utiliza alguma das suas funções, irá necessitar das declarações das entidades que usar. Assim, as declarações referentes a todas as entidades "exportadas" por um módulo deverão ser colocadas num arquivo separado - o arquivo de inclusão (usualmente com extensão .h) - que possa ser incluído e partilhado por todos os outros módulos que utilizem essas entidades.

Estes arquivos são em tudo semelhantes aos arquivos de inclusão que contêm as declarações das entidades definidas na biblioteca standard do C. Incluem-se nos arquivos que deles necessitam usando o mesmo comando do pré-processador:

#include "my_header.h"

Nota importante: Usualmente estes arquivos de inclusão apenas contêm declarações de tipos, variáveis globais, protótipos de funções e comandos do pré-processador.

Considere-se o seguinte exemplo muito simples de um programa com vários módulos:

#define MY_STRING "Hello World!"
void WriteMyString(char *); header.h

#include <stdio.h>
extern char *AnotherString;
void WriteMyString(char *ThisString)
{
    printf("%s\n", ThisString);
    printf("Global Variable = %s\n", AnotherString);
}
mystring.c

#include <stdio.h>
#include "header.h"
char *AnotherString = "Hello Everyone!";
void main(void)
{
    printf("Running ... \n");
    WriteMyString(MY_STRING);
    printf("Finished.\n");
}
main.c

Cada um dos dois módulos, main.c e mystring.c, deve ser compilado separadamente, incluindo-se em main.c as declarações referentes a mystring.c que estão no arquivo de inclusão header.h.

O problema das variáveis partilhadas por vários módulos (ou seja, definidas e inicializadas num módulo e acessadas noutro) irá ser tratado na seção seguinte.

Variáveis externas

Quando num módulo se pretende acessar a variáveis definidas noutro, estas deverão ser declaradas neste precedidas da palavra-chave extern. Esta palavra-chave indica que a respectiva variável está definida externamente a todas as funções (i.e. é global) e cuja definição se encontra em outro local. A declaração com extern não cria espaço de memória para armazenar a variável, apenas indica que a variável já existe e é do tipo indicado na declaração. Só a definição (tipo e nome da variável) cria o espaço de memória necessário para o armazenamento de valores na variável.

No exemplo da seção anterior viu-se a utilização de uma variável nestas condições.

Alcance das variáveis

As variáveis globais não são visíveis em todo o arquivo onde são definidas ou declaradas. A regra que a linguagem C segue é a seguinte:

"O alcance (scope) de uma variável global ou função começa no ponto da sua definição ou declaração e dura até ao final do arquivo (módulo)."

Considere-se o seguinte pedaço de programa:

void main(void)
{ ... }
int what_scope;
float end_of_scope[10];
void what_global(void)
{ ... }
char alone;
float fn(void)
{ ... }

A função main() não pode utilizar as variáveis what_scope e end_of_scope, mas as funções what_global() e fn() já podem. Apenas a função fn() pode utilizar a variável alone. Para que todas as funções possam usar todas as variáveis globais estas deverão ser definidas no início do arquivo fonte. É também por essa razão que os protótipos de todas as funções devem aparecer também no início do arquivo. No exemplo anterior a função main() não pode chamar as funções what_global() e fn().

O tamanho dos arrays deverá sempre aparecer na definição dos mesmos. No entanto, numa declaração com extern, não é necessário indicar o tamanho dos arrays.

Exemplo:

main.c: int array[100];

file.c: extern int array[];

Exercícios

Veja aqui os exercícios

[REV 06/2001]