Re: Divisão do ep em vários arquivos - ep2

[Daniel André Vaquero <daniel@linux.ime.usp.br>]

Olá Leonardo,

leotrabuco@uol.com.br writes:
> Olá a todos!
> 
> Estou com uma dúvida em relação à divisão de um programa em vários arquivos.
> Quando implementamos uma pilha em outro arquivo, o STACK_LL.c, definimos a
> estrutura necessária para o funcionamento das funções da pilha neste mesmo
> arquivo. Até aí, tudo bem.
> Agora, se eu for adaptar esta implementação para que as funções de pilha
> recebam (ou devolvam) como argumento listas ligadas (e não inteiros, como
> vimos), este arquivo STACK_LL.c vai depender da implementação da minha lista
> ligada no arquivo principal. Imagine que eu implementei uma lista ligada no
> arquivo principal desta forma:
> 
> typedef struct node *link;
> struct node { int item; link next; };
> 
> Se eu for passar como argumento para um função empilhe um ponteiro que
> aponta para uma estrutura do tipo node, ou seja, um link, minhan função
> deveria empilhe seria declarada como empilhe(link p), certo?

Certo.

> Então, agora meu arquivo STACK_LL.c depende da implementação da lista (que
> está no cliente).
> Há necessidade de implementar a estrutura node (como a implementação
> anterior) também na implementação de pilhas ou basta que esteja implementada
> no cliente?

Se você organizar os arquivos da forma que você descreveu, o
compilador ao gerar código para a implementação de pilhas não saberá
da existência da estrutura node e não conseguirá compilar seu código.
Se a estrutura node e o link são usados no cliente e na pilha, o
ideal é criar uma interface (um arquivo .h) e colocar lá as
definições do link e da estrutura node.
Depois, no cliente e na implementação da pilha usar

#include "nome_da_sua_interface.h"

Assim tanto o arquivo .c da pilha e o cliente "saberão" da existência
da lista ligada. Você também precisa de uma interface com os
protótipos para as funções de pilha, e deve incluir essa interface no
arquivo .c que contém a implementação das funções de pilha e no
cliente (para poder utilizá-las).

Em geral a modularização (divisão do programa em vários arquivos)
serve para, além de organizar melhor o código, tornar as partes do
programa mais "independentes" entre si, assim você pode alterar uma
parte do programa sem precisar mexer nas outras. Por exemplo, suponha
que temos a implementação de pilhas que vocês viram em aula. Nela
temos o protótipo da função empilha(int i) definido na interface
STACK.h. No cliente deve ser incluída essa interface para usar as
funções da pilha. No arquivo STACK.c está implementada a função
empilha, suponha que a pilha foi implementada usando uma lista ligada
que está definida no arquivo STACK.c. Suponha também que no cliente
são executadas chamadas de funções da pilha, inclusive a empilha(int
i).

Se você tem o cliente, a
interface de pilha STACK.h e a implementação em STACK.c usando listas
ligadas, e você decide mudar a implementação da pilha para uma outra
que utilize vetores ao invés de listas ligadas, basta trocar o
arquivo STACK.c por outro com a nova implementação (usando os mesmos
protótipos que estão definidos em STACK.h) e o programa cliente não
precisará ser modificado, ou seja, ele continua funcionando com
chamadas de funções da pilha, mas foi preciso mexer apenas no
STACK.c. Por exemplo, empilha(int i) antes adicionava um nó ao início
da lista ligada contendo o inteiro i, agora colocaria esse inteiro i
numa posição de um vetor que estaria representando o topo da pilha,
mas para o programa cliente não muda nada, ele apenas pede para
empilhar o inteiro i, não importa se a pilha é um vetor ou uma lista
ligada.

Abraços,

Daniel