Contents

Capítulo 14 - Programas de Grande Dimensão


botões
botões Conteúdo Capítulo anterior Capítulo seguinte

Quando se escrevem programas de grande dimensão, estes devem ser divididos em módulos. Estes módulos, em C, são simplesmente ficheiros contendo coleções de funções, de algum modo relacionadas entre si.

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 (ficheiros fonte). Estes módulos poderão depois ser partilhados por diversos programas, incluindo-os simplesmente na compilação, como se estivessem sido escritos na linguagem fonte.

Deste modo, estes módulos irão geralmente dividir-se em grupos comuns de funções, podendo ser compilados previamente e o seu código objeto agrupado numa biblioteca (library - ficheiros com a extensão .lib). Esta biblioteca poderá depois ser simplesmente ligada a outros programas que venham a utilizar um ou mais funções nela contidas.


Tópicos

setas
setas Up

Ficheiros 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 simples possível. No entanto, quando outro módulo utiliza uma das suas funções, irá necessitar das declarações das entidades a usar.

Assim, as declarações referentes a todas as entidades "exportadas" por um módulo deverão ser colocadas num ficheiro separado (o ficheiro de inclusão, normalmente com a extensão .h), que possa ser incluído e partilhado por todos os outros módulos que utilizem as mesmas entidades.

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

  #include "my_header.h"

Nota importante: Usualmente estes ficheiros 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:

Programa principal
Módulo header.h
#define MY_STRING "Hello World!"
void WriteMyString(char *);
header.h
Módulo mystring.c
#include <stdio.h>

extern char *AnotherString;

void WriteMyString(char *ThisString)
{
printf("%s\n", ThisString);
printf("Global Variable = %s\n", AnotherString);
}
mystring.c
Módulo main.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 ficheiro 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 acedidas noutro) irá ser tratado na secção seguinte.

setas
setas Up

Variáveis externas

Quando num módulo se pretende aceder a variáveis definidas noutro, estas deverão ser declaradas e precedidas da palavra-chave extern.

Esta palavra-chave indica que a respetiva variável está definida externamente a todas as funções (i.e. é global) e cuja definição se encontra noutro 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.

setas
setas Up

Alcance das variáveis

As variáveis globais não são visíveis em todo o ficheiro 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 ficheiro (módulo)."

Considere-se o seguinte código:

  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 ficheiro fonte. É também por essa razão que os protótipos de todas as funções devem aparecer também no início do ficheiro.

No exemplo anterior a função main() não pode chamar as funções what_global() e fn().

O tamanho dos arrays deverá aparecer sempre 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[];
setas
setas Up