#include <stdio.

h>
#include <stdlib.h>
#include <string.h>

/*
*/

// Enumerador

typedef enum { false, true } bool;

// Estruturas

typedef struct estrada

{
char nome[10];
bool ativa = false;

} Estrada;

typedef struct categoria

{
char nome[10];
bool ativa = false;

} Categoria;

typedef struct tabela

{
char categoria[3];
float preco;

} Tabela;

typedef struct portico

{
int codigo;
char estrada[10];
float quilometro;
Tabela valorCobrar[10];
int ultimoPreco = 0;
bool ativo = false;

} Portico;

typedef struct viatura

{
char matricula[10];
char categoria[3];
bool ativa = false;
} Viatura;

typedef struct passagem

{
char data[10];
char hora[5];
char matriculaViatura[9];
 int codigoPortico;
float valorCobrado;
} Passagem;

// Procedimento

void Inserir (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias);
void GuardaEstrada (Estrada *estradas, int *numEstradas, int *i);
void GuardaCategoria (Categoria *categorias,int *numCategorias, int *i);
void GuardaPortico (Portico *porticos, int *numPorticos, Estrada *estradas, int
*numEstradas, Categoria *categorias, int *numCategorias , int *i);
void GuardaViatura (Viatura *viaturas, int *numViaturas, Categoria *categorias, int
*numCategorias, int *i);
void GuardaPassagem(Portico *porticos, int *numPorticos, int *i);

void Alterar (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias);
void AlterarPortico (Portico *porticos, int *numPorticos, Categoria *categorias,
int *numCategorias, Estrada *estradas, int *numEstradas);
void AlterarEstrada (Estrada *estradas, int *numEstradas, Portico *porticos, int
*numPorticos);
void AlterarViatura (Viaturas *viatura, int *numViaturas);

void Eliminar (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias);
void EliminarPortico (Portico *porticos, int *numPorticos);
void EliminarViatura (Viatura *viaturas, int *numViaturas);
void EliminarEstrada (Estrada *estradas, int *numEstradas, Portico *porticos, int
*numPorticos);
void EliminarCategoria (Categoria *categorias, int *numCategorias, Portico
*porticos, int *numPorticos, Viatura *viaturas, int *numViaturas );

void RelatorioEstrada(Estrada *estradas, int *numEstradas, Porticos *portico, int

*numPorticos);
void HistoricoPorticos (Passagem *passagens, int *numPassagens);
void HistoricoViaturas (Passagem *passagens, int *numPassagens);
void ValorCobrado (Passagem *passagens, int *numPassagens);

// Funes

bool VerificarCodigo (int codigo, Portico *porticos, int *numPorticos);

bool VerificarEstrada (char estrada, Estrada *estradas, int *numEstradas);
bool VerificarCategoria (char categoria, Categoria *categorias, int
*numCategorias);
bool VerificarMatricula (char matricula, Viaturas *viaturas , int *numViaturas);

int main(int argc, char *argv[]) {

// Declarao de variaveis
Portico porticos[1000];
Viatura viaturas[1000];
Estrada estradas[50];
Passagem passagens[1000];
 Categoria categorias[20];
int numViaturas = 0, numPorticos = 0;
int numEstradas = 0, numCategorias = 0, numPassagens = 0;

// Preparar ecr
puts("=============== ESTRADAS CARSSIMAS ==============");
puts("");
puts("");

// Mostrar opes ao utilizador

puts("\tEscolha a opcao pretendida");
puts("\t-> 1 - Inserir");
puts("\t-> 2 - Alterar");
puts("\t-> 3 - Eliminar");
puts("\t-> 4 - Relatrio de Estrada");
puts("\t-> 5 - Historico de Porticos, por estrada");
puts("\t-> 6 - Historico de Viaturas, por portico");
puts("\t-> 7 - Valor cobrado a determinada viatura ")
puts("\t-> 0 - Para sair.");
puts("");

// Fazer ciclo at que utilizador esclha a opo sair (0)

do
{
// Recolher opcao escolhida pelo o utilizador
printf("\t\t\t Opcao escolhida: ");
scanf("%d", &opcao);
puts("");
puts("");

// Efetuar opo escolhida

switch (opcao)
{
case 1:
Inserir (porticos, numPorticos, viaturas, numViaturas,
estradas, numEstradas, categorias, numCategorias);
break;
case 2:
Alterar (porticos, numPorticos, viaturas, numViaturas,
estradas, numEstradas, categorias, numCategorias)
break;
case 3:
Eliminar (porticos, numPorticos, viaturas, numViaturas,
estradas, numEstradas, categorias, numCategorias);
break;
case 4:
RelatorioEstrada(estradas, numEstradas, portico,
numPorticos);
break;
case 5:
HistoricoPorticos(passagens, numPassagens);
break;
case 6:
HistoricoViaturas(passagens, numPassagens);
break;
case 7:
 ValorCobrado (passagens, numPassagens);
break;

// Limpar ecra
system("cls");

} while(opcao =! 0);

// Pausa
getchar();

// Sair
return 0;

/*
Este procedimento tem a funo de mostrar as opoes que o utilizador tem para
inserir e direciona-lo para outro procedimento, consuante a opo escolhida
(repetindo cada opo dependendo da "quantidade" que o utilizador inseriu)
*/

void Inserir (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias)
{
// Variaveis locais
int opcao;
int i;

// Mostrar opes ao utilizador

puts("O que desejo inserir ?");
puts("Estradas(s) - 1 ;");
puts("Categorias(s) - 2 ;");
puts("Portico(s) - 3 ;");
puts("Viatura(s) - 4 ;");
puts("Passagem(s) - 5 ;");
puts("Sair - 0 .");

// Fazer ciclo at que utilizador esclha a opo sair (0)

do
{
// Recolher opo e numero de elementos a inserir
puts("\t\t ->")
scanf("%d", &opcao);
puts("\t Quantidade: ");
scanf("%d", &quantidade);

// Efetuar opo escolhida

switch (opcao)
{
case 1:
 // Somar numero de estradas j existente quantidade
a inserir, para assim ter o numero total de estradas
quantidade += numEstradas;

// Fazer ciclo dependendo da quantidade que quer

inserir
for (i = numEstradas; i < quantidade; i++)
GuardaEstrada (estradas, numEstradas, &i);

// Guardar numero de estradas

numEstradas = i;
break;
case 2:
// Somar numero de categorias j existente
quantidade a inserir, para assim ter o numero total de categorias
quantidade += numCategoria;

// Fazer ciclo dependendo da quantidade que quer

inserir
for (i = numCategorias; i < quantidade; i++)
GuardaCategoria (categorias, numCategorias,
&i);

// Guardar numero de categorias

numCategorias = i;
break;
case 3:
// Somar numero de porticos j existente quantidade
a inserir, para assim ter o numero total de porticos
quantidade += numPorticos;

// Fazer ciclo dependendo da quantidade que quer

inserir
for (i = numPorticos; i < quantidade; i++)
GuardaPortico (porticos, numPorticos, estradas,
numEstradas, categorias, numCategorias, &i);

// Guardar numero de porticos

numPorticos = i;
break;
case 4:
// Somar numero de viaturas j existente quantidade
a inserir, para assim ter o numero total de viaturas
quantidade += numViaturas;

// Fazer ciclo dependendo da quantidade que quer

inserir
for (i = numViaturas; i < quantidade; i++)
GuardaViatura (viaturas, numViaturas,
categorias, numCategorias, i);

// Guardar numero de viaturas

numViaturas = i;
break;
case 5:
// Somar numero de passagens j existente
quantidade a inserir, para assim ter o numero total de passagens
quantidade += numPassagens;
 // Fazer ciclo dependendo da quantidade que quer
inserir
for (i = numPassagens; i < quantidade; i++)
InserirPassagem(porticos, numPorticos, i);

// Guardar numero de passagens

numPassagens = i;

// Limpar ecra
system(cls);

}while (opcao =! 0);

}

/*
Este procedimento tem a funo de guardar todos os detalhes referentes a uma
estrada
*/

void GuardaEstrada (Estrada *estradas, int *numEstradas, int *i);

{
// Variaveis locais
char estrada;
bool existe;

// Recolher nome da estrada que o utilizador quer inserir

printf("Estrada: ");
gets(estrada);

// Verificar se estrada j existe no sistema

existe = VerificarEstrada (estrada, estradas, numEstradas);

// Se estrada existir entao mostrar ao utilizador

if (existe)
{
puts("A estrada ja' esta' inserida no sistema!");
i--;
return;
}

// Se estrada nao existir, inseri-la no sistema

else
{
strcpy(estradas[i].nome, estrada);
estradas[i].ativa = true; // Guardar existencia da estrada
return;
}

/*
Este procedimento tem a funo de guardar todos os detalhes referentes a uma
categoria
*/

void GuardaCategoria (Categoria *categorias,int *numCategorias, int *i);

{
// Variaveis locais
char categoria;
bool existe;

// Recolher categoria a inserir

printf("Categoria: ");
gets(categoria);

// Verificar se categoria existe no sistema

existe = VerificarCategoria ( categoria, categorias, numCategorias );

// Se categoria existir no sistema, ento dize-lo ao utilizador

if ( existe )
{
puts("A categoria ja' esta' inserida no sistema!");
i--;
return;
}

// Se categoria nao existir no sistema , ento inseri-la

else
{
strcpy(categorias[i].nome, categoria);

// Guardar existencia da categoria

categorias[i].ativa = true;
return;
}

/*
Este procedimento tem a funo de guardar todos os detalhes referentes a um
portico
*/

void GuardaPortico (Portico *porticos, int *numPorticos, Estrada *estradas, int

*numEstradas, Categoria *categorias, int *numCategorias , int *i)
{
// Variaveis locais
int j = 0;
int k = 0;
char estrada[10], categoria[10];
bool existe;

// Solicitar cdigo e estrada ao utilizador

printf("Codigo: ");
scanf("%d", &strcpy(porticos[i].codigo, codigo);

printf("Estrada: ");
gets(estrada)

// Verificar se estrada est no sistema

existe = VerificarEstrada (estrada, estradas, numEstradas);
 // Se estrada estiver no sistema, ento , guarda-la
if (existe)
strcpy (porticos.estrada[i], estrada);

// Se estrada nao estiver no sistema, dize-lo ao utilizador e sair

else
{
printf("A estrada nao est inserida no sistema!");
i--;
return;
}

// Recolher quilometro e tabela de preos

printf("Quilmetro: ");
scanf("%d", &porticos[i].quilometro);
puts("Tabela de Precos: ");

// Definio de condio de paragem

puts("Termine inserindo na categoria : FIM");

// Percorrer Tabela de preos, desde a ultima linha guardada

(porticos[i].ultimoPreco)
for ( j = porticos[i].ultimoPreco; j < 100; i++)
{
// Mostrar ao utilizador categorias existentes no sistema
puts("Categoria do veiculo: \n");
for (k = 0; k < numCategorias; i++)
printf("-> %c", categorias[k].nome);

// Recolher categoria
puts("\t\t ->");
gets(categoria);
puts("");

// Se inserido FIM na Categoria ento sair

if (strcimp(categoria, "FIM") == 0)
return;
// Guardar categoria na tabela
else
strcpy(porticos[i].valorCobrar[j].categoria, categoria);

// Guardar preo na tabela

printf("Preco: ");
scanf("%f", &porticos[i].valorCobrar[j].preco);
puts("");

// Guardar quantidade de preos da tabela ( numero de ciclos )

porticos[i].ultimoPreco = j;

// Guardar existencia do portico

porticos[i].ativo = true;

/*
 Este procedimento tem a funo de guardar todos os detalhes referentes a uma
viatura
*/

void GuardaViatura (Viatura *viaturas, int *numViaturas, Categoria *categorias, int

*numCategorias, int *i)
{
// Variaveis locais
char matricula[12];
bool existe;

// Recolher matricula da viatura a inserir

printf("Matricula: ");
gets(matricula);

// Verificar se matricula existe no sistema

existe = VerificarMatricula ( matricula, viaturas, numViaturas);

// Se matricula existir no sistema, dize-lo ao utilizador, subtrair 1 a i,

para que, quando voltar ao ciclo, sobrepor as carateristicas
if (existe)
{
puts("A matricula da viatura em questao j foi inserida!");
i--;
return;
}

// Se matricula nao existir, guarda-la

else
strcpy(viaturas[i].matricula, matricula);

// Recolher categoria da viatura a inserir

puts("Categoria do veiculo: ");
puts("");

// Mostrar ao utilizador as categorias existentes no sistema

for (i = 0; i < numCategorias; i++)
printf("-> %c", categorias[i].nome)

// Recolher categoria e guarda-la

puts("\t\t\t ->");
gets(viaturas[i].categoria);

// Guardar existencia da viatura

viaturas[i].ativa = true;

/*
Este procedimento tem a funo de guardar todos os detalhes referentes a uma
passagem
*/

void GuardaPassagem(Portico *porticos, int *numPorticos, int *i)

{
// Variaveis locais
int j = 0, k = 0;
 // Recolher data
puts("Data(ex: 17.01.2017): ");
gets(passagens[i].data);

puts("Hora(ex: 17:43): ");

gets(passagens[i].hora);

// Recolher matricula da viatura

puts("Matricula viatura:");
gets(passagens[i].matriculaViatura);

// Recolher categoria da viatura

puts("Categoria Viatura:");
gets(passagens[i].categoriaViatura);

// Recolher codigo relativo ao portico

puts("Codigo do portico:")
scanf("%d", &passagens[i].codigoPortico)

// Percorrer todos os porticos

for (j = 0; j < numPorticos; i++)
{
// Encontrar o portico referente ao codigo em questo
if ((strcmp(porticos[j].codigo, codigo) == 0) && porticos[j].codigo =
true)
{
// Percorrer tabela de preos do portico em questo
for (k = 0; k < porticos[j].ultimoPreco; i++ )
{
// Encontrar o preo refente categoria referida
if (strcimp(porticos[j].valorCobrar[k].categoria,
passagens[i].categoriaViatura ) == 0)
passagens[i].valorCobrado =
porticos[j].valorCobrar[k].preco;

}
}
}

// Sair
return;

/*
Este procedimento tem a funo de mostrar ao utilizador os itens possiveis
para modificar e redirecionar para um outro procedimento, consuante o item
escolhido
*/

void Alterar (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias);
{
// Variaveis locais
int opcao;
 // Recolher qual a opco escolhida

puts("O que deseja modificar ?")

puts("\tDetalhes Portico - 1 ;");
puts("\tMatricula Viatura - 2 ;");
puts("\tEstradas - 3 ;");
puts("\tSair - 0 .");

// Fazer ciclo at que utilizador esclha a opo sair (0)

do
{
// Recolher opo escolhida
puts("\t\t ->");
scanf("%d", &opcao);

// Efetuar opo escolhida

switch (opcao)
{
case 1:
AlterarPortico (porticos, numPorticos, categorias,
numCategorias, estradas, numEstradas);
break;
case 2:
AlterarViatura (viaturas, numViaturas);
break;
case 3:
AlterarEstrada (estradas, numEstradas, porticos,
numPorticos);
break;

// Limpar ecra
system(cls);

}while ( opcao =! 0);

/*
Este procedimento tem a funo de alterar dados relativos a um portico.
Depois de recolher o portico, mostra as opes relativas a esse mesmo portico,
a seguir o utilizador modifica o(s) dado(s) consuante a opo escolhida.
*/

void AlterarPortico (Portico *porticos, int *numPorticos, Categoria *categorias,

int *numCategorias, Estrada *estradas, int *numEstradas)
{
// Variaveis locais
int i, n = -1, j;
int linhasInserir = 0, linhasAtualizar = 0;
bool existeEstrada, existeCategoria, existeCodigo;

// Recolher codigo relativo ao portico a alterar

puts("Qual o codigo do portico que pretende alterar?");
puts("");
puts("\t ->");
scanf("%d", codigo);
puts("");
puts("");

// Verificar se codigo existe no sistema

existeCodigo = VerificarCodigo (codigo, porticos, numPorticos);

// Se existir, encontrar o portico em questo

if (existeCodigo)
{
// Percorrer todos os porticos
for (i = 0; i = numPorticos; i++)
{
// Guardar numero do portico em questo
if (strcmp (porticos[i].codigo, codigo) ==0)
n = i;

}
}

// Caso codigo no exista no sistema, dize-lo ao utilizador

else
{
puts("O codigo que inseriu nao esta relacionado com nenhum portico.");

// Pausa
getchar();
return;
}

// Mostrar au utilizar opes possiveis

puts("\tQue detalhes pretende alterar?");
puts("");
puts("\t\tEstrada - 1");
puts("\t\tQuilometro - 2");
puts("\t\tTabela de precos");
puts("\t\t Acrescenta - 3");
puts("\t\t Atualizar - 4");
puts("\t\tSair - 0");

// Fazer ciclo at que utilizador esclha a opo sair (0)

do
{
// Recolher opo escolhida
printf("\t\t\t ->");
scanf("%d", &opcao);

// Efetuar opo escolhida

switch (opcao)
{
case 1:
// Recolher "estrada nova"
printf("Atualizar Estrada ->");
gets(estrada);

// Verificar se estrada esxiste no sistema

 decisaoEstrada = VerificarEstrada (estrada, estradas,
numEstradas );

// Se estrada existir no sistema, ento , guarda-la e sair

if (decisaoEstrada)
{
strcpy(porticos[n].estradas.nome, estrada);

puts("A estrada foi atualizada com sucesso!");

// Pausa
getchar();
break;
}

// Se estrada no existir no sistema, dize-lo ao utilizador

e sair
else
{
puts("A estrada nao est inserida no sistema!");

// Pausa
getchar();
break;
}

case 2:
// Recolher "novo quilometro", guarda-lo e sair
printf("Atualizar Quilometro ->");
gets(porticos[n].quilometro);
break;

case 3:
puts("Atualizar Tabela de Precos");

// Recolher numero de linhas que o utilizador vai inserir

puts("\tQual o numero de linhas que vai inserir?");
printf("\t\t");
gets(linhasInserir);

// Fazer ciclo at atingir o numero de linhas a inserir

for ( i = 0; i = linhasInserir; i++)
{
//
puts("Categoria do veiculo? ");
puts("");

for (j = 0; j < numCategorias; i++)

printf("-> %c", categorias[j].nome)

// Recolher categoria
puts("\t\t ->");
gets(categoria);
puts("");

// Verificar se categoria est no sistema

existeCategoria = VerificarCategoria (categoria,
categorias, numCategorias);
 // Se categoria estiver no sistema, ento guarda-la
if ( existeCategoria )
strcpy (porticos[n].valorCobrar[i].categoria =
categoria);

// Se categoria no se encontrar no sistema ento,

dize-lo ao utilizador e voltar a repetir a linha
else
{
printf("A categoria nao est inserida no
sistema!\n");

// pausa
getchar();

i--;
break;
}

// Recolher preo
printf("Preco : ");
scanf("%f", &porticos[n].valorCobrar[i].preco);
puts("");

puts("Tabela de precos inseria com sucesso.");

// Guardar numero de linhas inseridas na tabela e sair

porticos[i].ultimoPreco = i;
break;

case 4:
puts("Aumentar a Tabela de Precos");

// Recolher o numero de linhas que utilizador quer inserir

puts("Qual o numero de linhas que vai aumentar?")
gets(linhasAtualizar);

// Somar linhas da tabela j inseridas com as que o

utilizador que inserir, tendo assim o total de linhas da tabela
linhasAtualizar += porticos[n].ultimoPreco;

// Percorrer linhas da tabela, desde a ultima linha

(ultimoPreco) at ao total de linhas(referido anteriormente)
for ( i = porticos[n].ultimoPreco; i = linhasAtualizar; i+
+)
{
puts("Categoria do veiculo? ");
puts("");

// Mostrar ao utilizador categorias do sistema

for (j = 0; j < numCategorias; i++)
printf("-> %c", categorias[j].nome)

// Recolher categoria
puts("\t\t ->");
gets(categoria);
 puts("");

// Verificar se Categoria inserida existe no sistema

existeCategoria = VerificarCategoria (categoria,
categorias, numCategorias);

// Se categoria existir, guardar

if (existeCategoria)
strcpy (porticos[n].valorCobrar[i].categoria =
categoria);

// Se categoria no existir, sair do ciclo

else
{
printf("A categoria nao est inserida no
sistema!\n");
i--;

// Pausa
getchar();
break;
}

// Recolher preo
printf("Preco : ");
scanf("%f", &porticos[n].valorCobrar[i].preco);
puts("");
}

// Guardar numero de linhas

porticos[i].ultimoPreco = i;

puts("Tabela de precos aumentada com sucesso.");

break;

// Limpar ecra
system("cls");

}while(opcao != 0);

/*
Este procedimento tem a funo de alterar a matricula de uma certa viatura.
(Assumindo que no se pode alterar a Categoria)
*/

void AlterarViatura (Viaturas *viatura, int *numViaturas)

{
// Variaveis locais
char matricula;
int i;
bool existe;

// Recolher matricula a atualizar

 puts("Qual a matricula que quer atualizar ?");
gets(matricula);

existe = VerificarMatricula ( matricula, viaturas , numViaturas);

if (existe)
{
// Percorrer todas as viaturas
for (i = 0; i < numViaturas; i++)
{
// Se escontrar a viatura com a matricula em questo ento, pedir
a "nova"
if (stricmp(viaturas[i].matricula, matricula) == 0)
{
// Recolher matricula "nova", guarda-la e sair
puts("Matricula atualizada -> ");
gets(viaturas[i].matricula);
return;
}
}
}

// Caso a matricula no esteja no sistema, dize-lo ao utilizador

else
puts("A matricula inserida nao existe no sistema, se quiser inserir,
volte atrs.");

// Pausa
getchar();

// Sair
return;

/*
Este procedimento tem a funo de alterar o nome de uma estrada, verificando
previamente se a estrada em questo no esta a ser utilizado para caraterizar algum
portico
*/

void AlterarEstrada (Estrada *estradas, int *numEstradas, Portico *porticos, int

*numPorticos)
{
// Variaveis locais
int i;
bool existe;

// Recolher nome da estrada a alterar

puts("Qual o nome da Estrada que pretende alterar?");
gets(nomeEstrada);

// Verificar se estrada em questo est no sistema

existe = VerificarEstrada (nomeEstrada, estradas numEstradas);

// Se estrada constar no sistema

if (existe)
 {
// Percorrer todos os porticos
for(i = 0; i < numPorticos ; i++)

{
// Se algum portico estiver caraterizado com a estrada em questo
ento, dize-lo e sair
if (stricmp (porticos[i].estrada, nomeEstrada) == 0)
puts("A estrada em questo, consta no registo de pelo menos
um portico, logo no pode ser alterada.");

getchar();
return;
}

// Percorrer todas as estradas

for (i = 0; i < numEstradas; i++)
{
// Encontrar estrada em questo, altera-la e sair
if (stricmp(estradas[i].nome, nomeEstrada) == 0)
{
strcpy(estradas[i].nome, nomeEstrada);
puts("Nome da estrada alterado com sucesso.");

// Pausa
getchar();
return;
}
}

// Se estrada nao constar no sistema, dize-lo e sair

else
puts("A estrada nao existe no sistema, se quiser inserir volte
atrs.");

// Pausa
getchar();

/*
Este procedimento tem a funo de mostrar ao utilizador itens possiveis a
eliminar e redirecionar o utilizador para outro procedimento consuante opo
escolhida
*/

void Eliminar (Portico *porticos, int *numPorticos, Viatura *viaturas, int

*numViaturas, Estrada *estradas, int *numEstradas, Categoria *categorias, int
*numCategorias)
{
// Variaveis locais
int opcao ;

// Mostrar opes ao utilizador

 puts("O que deseja eliminar ?")
puts("Portico - 1 ;");
puts("Viatura - 2 ;");
puts("Estrada - 3 ;");
puts("Categoria - 4 ;");
puts("Sair - 5 .");

// Fazer ciclo at que utilizador esclha a opo sair (0)

do
{
// Recolher opo escolhida
puts("\t->");
scanf("%d", opcao);

// Efetuar opo escolhida

switch (opcao)
{
case 1:
EliminarPortico (porticos, numPorticos);
break;
case 2:
EliminarViatura (viaturas, numViaturas);
break;
case 3:
EliminarEstrada (estradas, numEstradas, porticos,
numPorticos);
break;
case 4:
EliminarCategoria (categorias, numCategorias, Portico
*porticos, numPorticos, viaturas, numViaturas);
break;

// Limpar ecra
system ("cls");

}while (opcao =! 0);

/*
Este procedimento tem a funo de eliminar um portico escolhido pelo
utilizador.
*/

void EliminarPortico (Portico *porticos, int *numPorticos)

{

// Variaveis locais
int opcao, i;
bool existe;

// Recolher codigo relativo ao portico que pretende eliminar

 puts("Qual o codigo do portico que pretende eliminar?");
puts("");
puts("\t ->");
scanf("%d", codigo);
puts("");
puts("");

// Verificar se codigo se encontra relacionado com algum portico

existe = VerificarCodigo (codigo, porticos, numPorticos);

// Se o codigo em questo estiver no sitema, elemina - lo

if (existe)
{
// Percorrer todos os porticos
for (i = 0; i = numPorticos; i++)
{
// Encontrar portico em questo, elimina - lo e sair
if (strcmp (porticos[i].codigo, codigo) ==0)
{
// Guardar inxistencia do portico
porticos[i].ativo = false;
puts("Portico eliminado com sucesso.");

// Pausa
getchar();

return;
}

}
}

// Se o codigo em questo nao estiver relacionado com qualquer portico, dize-

lo
else
puts("O codigo que inseriu nao esta relacionado com nenhum portico.");

// Pausa
getchar();

// Sair
return;

/*
Este procedimento tem a funo de eliminar uma viatura escolhida pelo
utilizador
*/

void EliminarViatura (Viatura *viaturas, int *numViaturas)

{
// Variaveis locais
int i;
char matricula;
bool existe ;
 // Recolher matricula relativa viatura que o utilizador pretende eliminar
puts("Qual a matricula da viatura que pretende eliminar?");
puts("");
gets(matricula);

// Decidir se a matricula esta relacionada com alguma viatura

existe = VerificarMatricula ( viaturas , matricula, numViaturas);

// Se a viatura estiver no sistema, ento percorrer todas as viaturas e

"eliminar" a petendida
if (existe)
{
// Percorrer todas as viaturas
for (i = 0; i < numViaturas; i++)
{
// Se matricula em questo estiver relacionada com alguma viatura
ento, elimina-la e sair
if (stricmp(viaturas[i].matricula, matricula) == 0)
{
// Guardar inexistencia da viatura
viaturas[i].ativa = false;
puts("Viatura eliminada com sucesso.");

// Pausa
getchar();

return;

}
}

// Se matricula nao estiver relacionada com qualquer viatura, dize-lo

else
puts("A matricula que inseriu nao esta relacionada com nenhuma viatura.");

// Pausa
getchar();

// Sair
return;
}

/*
Este procedimento tem a funo de eliminar uma estrada inserida pelo
utilizador
*/

void EliminarEstrada (Estrada *estradas, int *numEstradas, Portico *porticos, int

*numPorticos)
{
// Variaveis locais
char estrada;
int i;
bool existe;
 // Recolher nome da estrada que pretende eliminar
puts("Qual o nome da estrada que pretende eliminar?");
puts("");
gets(estrada);

// Decidir se estrada est no sistema

existe = VerificarEstrada (estrada, estradas, numEstradas);

// Se a estrada existir no sistema, ento continuar

if (existe)
{
// Percorrer todos os porticos
for(i = 0; i < numPorticos ; i++)
{
// Se estrada estiver a ser utilizada, ento dize-lo e sair
if (stricmp (porticos[i].estrada, Estrada) == 0)
{
puts("A estrada em questo, consta no registo de pelo menos
um portico, logo no pode ser eliminada.");

// Pausa
getchar();

return;
}
}

// Percorrer todas as estradas

for (i = 0; i < numEstradas; i ++)
{
// Encontrar a estrada com o nome em questao e elimina - la
if (stricmp(estradas[i].nome, estrada) == 0)
{
// Guardar inxistencia da estrada
estradas[i].ativa = false;
puts("Estrada eliminada com sucesso!");

// Pausa
getchar();

// Sair
return;
}

}
}

// Se estrada nao existir no sistema ento, dize-lo

else
puts("No pode eliminar uma coisa que nao existe.");

//Pausa
getchar();

// Sair
return;

}
/*
Este procedimento tem a funo de eliminar uma estrada inserida pelo
utilizador.
*/

void EliminarCategoria (Categoria *categorias, int *numCategorias, Portico

*porticos, int *numPorticos, Viatura *viaturas, int *numViaturas )
{
// Variaveis locais
char categoria[4];
int i;
bool existe;

//Recolher categoria que o utilizador pretende eliminar

puts("Qual a categoria que pretende eliminar?");
puts("");
gets(categoria);

// Verificar se categoria existe no sistema

existe = VerificarCategoria (categoria, categorias, numCategorias);

// Se a categoria em questo existir, entrar

if (existe)
{

// Percorrer todas as viaturas

for (i = 0; i < numViaturas; i++)
{
// Se encontrar a categoria inserida a caraterizar alguma
viatura, dize-lo e sair
if (stricmp(viaturas[i].categoria, categoria) == 0 )
{
puts("A categoria em questao, esta a ser utilizada para
caraterizar pelo menos uma viatura, logo nao pode ser eliminada.")

// Pausa
getchar();

// Sair
return;
}
}

// Percorrer todos os porticos

for (i = 0; i < numPorticos; i++)
{
// Percorrer todas as linhas da tabela de preos de cada portico
for (j = 0; j < porticos[i].ultimoPreco)
{
// Se encontrar a categoria inserida na tabela de preos,
sair
if ( stricmp(porticos[i].tabelaPreco[j].categoria,
categoria) == 0)
{
puts("A categoria categoria em questao, esta a ser
utilizada em pelo menos uma tabela de precos, logo nao pode ser eliminada.");
 // Sair
return;
}
}
}

// (Caso nao haja qualquer impedimento em eliminar a categoria)

Percorrer todas as categorias
for (i = 0; i < numCategorias; i++)
{
// Encontrar categoria em questo, elimina-la e sair
if (stricmp(categorias[i].nome, categoria) == 0)
{
// Guardar enexistencia da categoria
categorias[i].ativa = false;
puts("Categoria eliminada com sucesso.");

// Pausa
getchar();

return;
}
}
}

// Se categoria nao constar no sistema ento, dize-lo e sair

else
puts("No pode eliminar uma coisa que nao existe.");

// Pausa
getchar();

// Sair
return;

/*
Este procedimento tem a funo de fazer um relatrio com os porticos (e
tabela de preos) existentes numa determinada estrada.

*/

void RelatorioEstrada(Estrada *estradas, int *numEstradas, Porticos *portico, int

*numPorticos)
{
// Variaveis locais
char relatorio[300];
char estrada[5];

//Recolher estrada
puts("Estrada: ");
gets(estrada);
 // Percorrer todas as estradas
for (i = 0; i < numEstradas; i++)
{
// Se estrada em questo existir e estiver em funcionamento, entrar
if ((stricmp(estradas[i].nome, estrada) == 0) && estradas[i].ativa =
true)
{
// Percorrer todos os porticos
for (j = 0; j < numPorticos; i++)
{
// Se estrada em questo constar em algum portico e esse
portico estiver em funcionamento, entrar
if ((stricmp(porticos[j].estrada, estrada) == 0) &&
porticos[j].ativo = true)
{
// Escrever codigo do portico no relatorio
sprintf(relatorio,"-> %-d ;\n",porticos[j].codigo );

// Mostrar tabela de preos

strcat(relatorio, "Tabela de precos");
strcat(relatorio, "| Categoria | Preco |");

// Percorrer tabela de preos do portico em questo e

escreve - la no relatorio
for ( k = 0; k < numPreco; i++)
sprintf(relatorio,"| %-4.9s | %-4.5d
|\n",porticos[j].valorCobrar[k].categori, porticos[j].valorCobrar[k].preco)

}
}
}

// Se estrada em questo no existir, escreve-lo no relatrio

else
strcpy(relatorio, "A estrada nao existe.");

// Pausa
getchar();

// Sair
return;

}
}

/*
Este procedimento tem a funo de calcular o valor cobrado a uma determinada
viatura numa determinada data.
*/

void ValorCobrado (Passagem *passagens, int *numPassagens)

{

// Variaveis locais
 char data[8], matricula[8];
int valorCobrado = 0;

// Recolher data
puts("Data:");
gets(data);

// Recolher matricula
puts("Matricula da viatura:")
gets(matricula);

decisaoMatricula =
// Percorrer todas as passagens
for (i = 0; i < numPassagens; i++)
{
// Encontrar passagem feita na data em questo
if (strcmp(passagens[i].data, data) == 0)
{
// Se passagem em questo tiver sido feita pela matricula
inserida, entrar
if (strcmp(passagens[i].matriculaViatura, matricula) == 0)
{
// Somar preo cobrado viatura
valorCobrado += passagens[i].valorCobrar;
}
}
}

// Mostrar valor cobrado viatura em questo

printf("O Valor cobrado a viatura %s foi de %f ", matricula, valorCobrado);

/*
Este procedimento tem a funo de fazer e apresentar o histrico (data, hora,
portico e valor cobrado) de uma determinada viatura.
*/

void HistoricoPorticos (Passagem *passagens, int *numPassagens)

{
// Variaveis locais
char matricula[8];
int i = 0;

//Recolher matricula referente a viatura, da qual o utilizador quer o

historico
puts("Matricula da Viatura: ");
gets(matricula);

// Preparar ecr
puts("| Data | Hora | Portico | Valor cobrado |\n");

// Percorrer todas as passagens

for (i = 0; i < numPassagens)
{
// Encontrar a passagem da qual a viatura faz parte e escrever o seu
// historico (data, hora, codigo do portico e valor cobrado)
if (stricmp(passagens[i].matriculaViatura, matricula) == 0)
 {
sprintf(historico, "| %-8.9s | %-4.6s | %-9.9d | %-5.15f |\n",
passagens[i].data, passagens[i].hora,
passagens[i].codigoPortico, passagens[i].valoCobrar);
}

}
// Pausa
getchar();

// Sair
return;
}

/*
Este procedimento tem a funo de fazer e apresentar o histrico (data, hora,
viatura e valor cobrado) de um determinado portico.
*/

void HistoricoViaturas (Passagem *passagens, int *numPassagens)

{
// Variaveis locais
char codigo[8];
int i = 0;

//Recolher codigo referente ao portico, do qual o utilizador quer o historico

puts("Codigo do Portico: ");
gets(codigo);

// Preparar ecr
puts("| Data | Hora | Viatura | Valor cobrado |\n");

// Percorrer todas as passagens

for (i = 0; i < numPassagens)
{
// Encontrar a passagem da qual o portico faz parte e escrever o seu
// historico (data, hora, codigo do portico e valor cobrado)
if (strcmp(passagens[i].codigoPortico, codigo) == 0)
{
sprintf(historico, "| %-8.9s | %-4.6s | %-9.9d | %-5.15f |\n",
passagens[i].data, passagens[i].hora,
passagens[i].matriculaViatura, passagens[i].valoCobrar);
}

}
// Pausa
getchar();

// Sair
return;

/*
Este procedimento tem a funo de verificar se um determinado codigo existe
*/
bool VerificarCodigo (int codigo, Portico *porticos, int *numPorticos)
{
// Variaveis locais
int i;
bool existe = false;

// Percorrer todos os porticos

for (i = 0; i = numPorticos ; i++)
{
// Se encontrar codigo em questo em algum portico que esteja em
funcionamento, fazer "return de true"
if ((strcimp(porticos[i].codigo, codigo) == 0) && (porticos[i].ativo =
true))
{
existe = true;
return existe;
}

// Se nao encontrar codigo em questo em nenhum portico ento, fazer "return

de false"
return existe;

/*
Este procedimento tem a funo de verificar se uma determinado estrada existe
*/

bool VerificarEstrada (char estrada, Estrada *estradas, int *numEstradas)

{
// Variaveis locais
int i;
bool existe = false;

// Percorrer todos os porticos

for (i = 0; i < numEstradas ; i++)
{
// Se encontrar nome estrada em questo em alguma estrada que esteja em
funcionamento, fazer "return de true"
if ((stricmp(estradas[i].nome, estrada) == 0) && (estradas[i].ativa =
true))
{
existe = true;
return existe;
}

// Se nao encontrar nome estrada em questo em nenhuma estrada ento, fazer

"return de false"
return existe;
}

/*
Este procedimento tem a funo de verificar se uma determinado categoria
existe
*/

bool VerificarCategoria (char categoria, Categoria *categorias, int *numCategorias)

{
// Variaveis locais
bool existe = false;
int = i;

// Percorrer todas as categorias

for (i = 0; i < numCategorias ; i++ );
{
// Se encontrar nome categoria em questo em alguma categoria que
esteja ativa, fazer "return de true"
if ((stricmp(categorias[i].nome, categoria) == 0) &&
(categorias[i].ativa = true))
{
existe = true;
return existe;
}

// Se nao encontrar nome categoria em questo em nenhuma categoria ento,

fazer "return de false"
return existe;
}

/*
Este procedimento tem a funo de verificar se uma determinado matricula
existe
*/

bool VerificarMatricula (char matricula, Viaturas *viaturas , int *numViaturas)

{
// Variaveis locais
bool existe = false;
int = i;

// Percorrer todas as viaturas

for (i = 0; i < numViaturas ; i++ );
{
// Se encontrar matricula em questo a caraterizar alguma viatura que
esteja ativa, fazer "return de true"
if ((stricmp(viaturas[i].matricula, matricula) == 0) &&
viaturas[i].ativa = true)
{
existe = par;
return existe;
}

// Se nao encontrar matricula em questo em nenhuma viatura ento, fazer

"return de false"
return existe;
}