Para não perder o costume, irei postar outro exercicio resolvido em uma aula. Dessa vez o exercicio é o seguinte:
- Implemenetar o sistema de contabilidade de um mafioso. (outros detalhes continue lendo o post)

O enunciado do mesmo se encontra no “read the rest of this entry” para não deixar o post muito extenso devido ao longo enunciado.

A resolução do mesmo você pode baixar aqui.

Você é um Mafioso informatizado.
Você vai criar um sistema para gerenciar os seus débitos e também as pessoas que devem a você.
Este sistema será baseado em duas listas encadeadas:

(Imagem de exemplo)

* Para isso você vai fazer um programa que manipula mais de uma lista;

* o programa fará isto com um único conjunto de funções e passagem das diversas listas como parâmetros;
* como aplicação imaginemos um sistema de contabilidade simples;
* você vai ter um Plano de Contas constituído por duas listas: débitos e créditos;
* o mesmo conjunto de funções (que você já implementou) vai poder ser utilizado para isso: você somente precisa ampliar o conjunto de parâmetros da função para passar por referência também a lista que você quer alterar.

A passagem de parâmetro da lista deve ser por referência porque você deseja que as alterações sejam persistentes.

Cada lista de débitos ou créditos é constituída por lançamentos. Cada lançamento possui:

* um valor real (positivo);
* um nome. Por exemplo, “Pagar proteção à Mafia”

Estrutura:
tipo tLançamento {
caracter *nome;
real valor;
};

A lista encadeada que conterá os lançamentos terá um elemento de lista definido da seguinte forma:
Estrutura:
tipo tLista {
tLancamento* info;
tLista* proximo;
};
A cabeça de lista de cada lista será uma variável global contendo uma estrutura como abaixo:
tipo cLista {
tLista* lista;
inteiro ultimo;
};

No programa principal você vai definir se vai realizar uma operação de débito ou de crédito e vai chamar as operações sobre listas necessárias, passando a lista correta como parâmetro (por referência) para a função que realiza a operação.

Além das operações básicas que a lIsta vai oferecer, você deve implementar uma operação adicional: totalização. Essa operação funciona assim:

* percorre a lista, escrevendo o nome e o valor correspondente a cada item (débito ou crédito)
* soma o valor em uma variável auxiliar
* escreve ao final o total de débitos ou de créditos, dependendo de qual lista você mandou totalizar.

Para ver o enunciado inteiro continue lendo (enunciado grande).

Para baixar o arquivo, clique aqui!

Reimplemente o seu programa de pilha com vetor de números inteiros usando como TOPO um ponteiro para inteiro, que você incrementa, decrementa e testa
para saber se a pilha está cheia ou vazia;
• para resolver:
– modifique a estrutura tPilha da seguinte forma:
constantes MAXPILHA = 100;
tipo tPilha {
inteiro dados[MAXPILHA];
inteiro *topo;
};

• Modifique os algoritmos de manipulação da pilha de forma que se utilize ponteiros para inteiro para referenciar os elementos da pilha.
• Exemplo:
Inteiro FUNÇÃO empilha(inteiro dado)
início
SE (pilhaCheia) ENTÃO
RETORNE(ErroPilhaCheia)
SENÃO
// Se houver espaço, incremento o
// ponteiro topo e faço o valor
// apontado por topo receber o novo
// dado.
aPilha.topo <- aPilha.topo + 1;
*(aPilha.topo) <- dado;
RETORNE(aPilha.topo);
FIM SE
fim;

• Lembre-se de adaptar a inicialização da pilha e também os testes de pilha cheia e vazia. Exemplos:

FUNÇÃO inicializaPilha()
início
// Fazemos o topo apontar para um endereço de memória
// anterior ao início do vetor dados para simbolizar
// que a pilha está vazia.
aPilha.topo <- aPilha.dados - 1;
fim;
Booleano FUNÇÃO pilhaVazia()
início
SE (aPilha.topo < aPilha.dados) ENTÃO
// O topo está apontando para um endereço de
// memória anterior ao próprio início da
// pilha. Segundo a nossa definição, isto
// significa que a pilha está vazia.
RETORNE(Verdadeiro)
SENÃO
RETORNE(Falso);
fim;