Cria Lista em C

Olá pessoal estou com um trabalho para fazer, mais ja fiz varias coisas que estou perdido já, gostaria da ajuda de vocês,

se algum poder me ajudar agradeço, me dar dicas.

tem que implementar:

stLista CriaSubListaContaOrdenada(stLista pListaConta, stConta *pConta, stData pDataInicial, stData pDataFinal, char psNomeArquivo[]) , e

stLista CriaSubListaFaturaOrdenada(stLista pListaCartao, stConta *pConta, stData pDataInicial, stData pDataFinal, char psNomeArquivo[])

vlw

/********************************************************************************
***********
* Descrição: sistema em linguagem C para a geraçao de extratos de um banco
* Curso: Tecnologia em Análise e Desenvolvimento de Sistemas
* Local: Fundação Universidade do Tocantins (UNITINS)
********************************************************************************
***********/

/****************************************Bibliotecas*************************
**********/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>
//#include <alloc.h>

/***************************************Definições***************************
**********/
#define TAM_STRING 100

/***************************************Estruturas***************************
**********/
//Estrutura utilizada para armazenar uma data
typedef struct Data
{

	int iDia;
	int iMes;
	int iAno;
} stData;

//Estrutura utilizada para armazenar uma hora
typedef struct Horario
{

	int iHora;
	int iMinuto;
}stHorario;

//Estrutura utilizada para armazenar os dados de uma conta
typedef struct Conta
{

	char cTitular[TAM_STRING];
	char cAgencia[TAM_STRING];
	char cNumConta[TAM_STRING];
	float fSaldoAnterior;
	float fSaldoAtual;
	int iNumCartao;
	float fTotalComprasCartao;
	float fTotalPagtosCartao;
	float fTotalCartao;
}stConta;

//Estrutura utilizada para representar uma transação efetuada na conta ou cartão de crédito
typedef struct Transacao
{

	float fValor;
	stData sData;
	int iOperacao;
	stHorario sHorario;
	struct Transacao *prProximo;
}stTransacao;

//Estrutura utilizada para representar uma lista de transações
typedef struct Lista
{

	stTransacao *prInicio;
	stTransacao *prFim;
}stLista;

/***************************************Variáveis Globais******************************/
//Armazena o nome das operações bancárias para conta corrente (Compra_debito, Saque, Deposito, Transferencia) e
//cartao de crédito (Compra_credito, Pgto_fatura)
char* OPERACOES[] = {"Compra_debito","Saque","Deposito","Transferencia","Compra_credito","Pgto_fatura"};

/***********************Implementação das funções**************************************/
/*------------------------------------------------------------------------------------------
* Nome da função: LerCabecalho
* Descrição: Realiza a quebra das informações contidas no cabeçalho do arquivo (1ª linha do arquivo)
* Retorno: Nenhum
* Parâmetros: Ponteiro para uma estrutura stConta e string contendo cabeçalho
------------------------------------------------------------------------------------------*/
void LerCabecalho(stConta *pConta, char psCabecalho[])
{
//Quebra os tokens do cabeçalho

	strcpy(pConta->cTitular,strtok(psCabecalho,";"));
	strcpy(pConta->cAgencia,strtok(NULL,";"));
	strcpy(pConta->cNumConta,strtok(NULL,";"));
	sscanf(strtok(NULL,";"),"%f",&pConta->fSaldoAnterior);
	sscanf(strtok(NULL,";"),"%d",&pConta->iNumCartao);
}

/*------------------------------------------------------------------------------------------
* Nome da função: RetornaOperacao
* Descrição: Recebe uma string contendo uma operação e retorna o código da mesma
* Retorno: Um valor inteiro indicando o código da transação
* Parâmetros: String contendo a operaçao
------------------------------------------------------------------------------------------*/
int RetornaOperacao(char psOperacao[])
{

	int iIndex=0;

	for (iIndex=0; iIndex<6; iIndex++)
	{
 if(!strcmp(psOperacao,OPERACOES[iIndex]))
 {
 return iIndex;
 }
	}
	return -1;
}

/*------------------------------------------------------------------------------------------
* Nome da função: PreencheTransacao
* Descrição: Quebra os campos de uma String contendo a transação e preenche a estrutura
* Retorno: Nenhum
* Parâmetros: Ponteiro para uma estrutura stTransacao e uma String
------------------------------------------------------------------------------------------*/
void PreencheTransacao(stTransacao *pTransacao, char psTransacao[])
{
//Inicializa a transacao

	pTransacao->prProximo = NULL;
	pTransacao->fValor = 0.0f;

	//Quebra os tokens da transacao
	sscanf(strtok(psTransacao,";"),"%d/%d/%d/",&pTransacao->sData.iDia,&pTransacao->sData.iMes, &pTransacao->sData.iAno);
	sscanf(strtok(NULL,";"),"%d:%d",&pTransacao->sHorario.iHora,&pTransacao->sHorario.iMinuto);

	//Invoca a função que devolve o código da operação com base em uma string
	pTransacao->iOperacao = RetornaOperacao(strtok(NULL,";"));

	sscanf(strtok(NULL,";"),"%f",&pTransacao->fValor);

	//Faz a leitura do valor da transacao e de acordo com o tipo de operação coloca o sinal
	if(pTransacao->iOperacao == 0 || pTransacao->iOperacao == 1 || pTransacao->iOperacao == 4)
	{
 pTransacao->fValor *= -1;
	}
}

/*------------------------------------------------------------------------------------------
* Nome da função: InsereTransacao
* Descrição: Insere uma transação na lista passada como parâmetro
* Retorno: Nenhum
* Parâmetros: Um ponteiro para uma lista e um ponteiro para uma transação
-------------------------------------------------------------------------------------------*/
void InsereTransacao(stLista pLista, stTransacao pTransacao)
{
//Variáveis temporárias

	int iIndex=0;
	int iPosicao = 0;
	stTransacao *temp = NULL;

	//Verifica se a lista existe
	if (!pLista)
	{
 return;
	}

	//Lista vazia, inserção do primeiro elemento na lista
	if (!pLista->prInicio)
	{
 pLista->prInicio = pTransacao;
 pLista->prFim = pTransacao;
 return;
	}

	//Inserção no final da lista
	pLista->prFim->prProximo = pTransacao;
	pLista->prFim = pTransacao;
}

/*------------------------------------------------------------------------------------------
* Nome da função: LerArquivo
* Descrição: Realiza a leitura das informações do arquivo de entrada para as listas da conta
* corrente e do cartão de crédito
* Retorno: Nenhum
* Parâmetros: Um ponteiro para a lista conta, um ponteiro para a lista cartao, um ponteiro para
* uma estrutura stConta e uma String com o nome do arquivo a ser lido
------------------------------------------------------------------------------------------*/
void LerArquivo(stLista pListaConta, stLista pListaCartao, stConta *pConta, char psNomeArquivo[])
{
//Declara um ponteiro para a estrutura de um arquivo

	FILE *prArquivoEntrada = NULL;

	//Declara uma string para a leitura da linha
	char sLinha[TAM_STRING];

	//Declara um ponteiro para transaçao
	stTransacao *prTransacao = NULL;

	//Faz as inicializaçoes das estruturas lista
	pListaConta->prInicio = NULL;
	pListaConta->prFim = NULL;
	pListaCartao->prInicio = NULL;
	pListaCartao->prFim = NULL;

	//Faz as inicializações da estrutura conta
	pConta->fSaldoAnterior = 0.0f;
	pConta->fSaldoAtual = 0.0f;
	pConta->iNumCartao = 0;
	pConta->fTotalComprasCartao = 0.0f;
	pConta->fTotalPagtosCartao = 0.0f;
	pConta->fTotalCartao = 0.0f;

	//Faz a abertura do arquivo
	prArquivoEntrada = fopen(psNomeArquivo,"r");

	//Testa se o arquivo foi aberto com sucesso
	if (!prArquivoEntrada)
	{
 printf("Nao foi possivel abrir o arquivo de entrada");
 return;
	}

	//Le a primeira linha do arquivo (cabecalho)
	fgets(sLinha,TAM_STRING,prArquivoEntrada);

	//Invoca a função que separa as informaçoes do cabeçalho
	LerCabecalho(pConta,sLinha);

	//Enquanto existirem transasões a serem lidas
	while (!feof(prArquivoEntrada))
	{
 //Faz a leitura de uma linha no arquivo contendo os dados da transação
 fgets(sLinha,TAM_STRING,prArquivoEntrada);

 //Testa se não é linha em branco
 if (sLinha[0]=='\n')
 {
 continue;
 }

 //Aloca memória para uma nova transação
 prTransacao = (stTransacao*)malloc(sizeof(stTransacao));

 //Quebra os dados da transação e preenche as estruturas
 PreencheTransacao(prTransacao,sLinha);

 //Verifica o tipo da operação e insere na lista do cartão ou da conta corrente:
 //código 1 a 4: operações de conta corrente
 //código 5 e 6: operações do cartão de crédito
 if (prTransacao->iOperacao < 4)
 {
 InsereTransacao(pListaConta,prTransacao);
 }
 else
 {
 InsereTransacao(pListaCartao,prTransacao);
 }
	}
	//Fecha o arquivo
	fclose(prArquivoEntrada);
}

/*------------------------------------------------------------------------------------------
* Nome da função: CriaSubListaContaOrdenada
* Descrição: Cria uma sublista ordenada contendo as transações da conta com base em uma data inicial e final
* Retorno: Ponteiro para uma lista
* Parâmetros: Ponteiro para uma lista ordenada, ponteiro para estrutura do tipo conta e duas
* estruturas do tipo data
------------------------------------------------------------------------------------------*/
stLista CriaSubListaContaOrdenada(stLista pListaConta, stConta *pConta, stData pDataInicial, stData pDataFinal, char psNomeArquivo[])
{
//Declara um ponteiro para a estrutura de um arquivo

	FILE *prArquivoEntrada = NULL;

	//Declara uma string para a leitura da linha
	char sLinha[TAM_STRING];

	//Declara um ponteiro para transaçao
	stTransacao *prTransacao = NULL;

	//Faz as inicializaçoes das estruturas lista
	pListaConta->prInicio = NULL;
	pListaConta->prFim = NULL;

	//Faz as inicializações da estrutura conta
	pConta->fSaldoAnterior = 0.0f;
	pConta->fSaldoAtual = 0.0f;
	pConta->iNumCartao = 0;
	pConta->fTotalComprasCartao = 0.0f;
	pConta->fTotalPagtosCartao = 0.0f;
	pConta->fTotalCartao = 0.0f;

	//Faz a abertura do arquivo
	prArquivoEntrada = fopen(psNomeArquivo,"r");

	//Testa se o arquivo foi aberto com sucesso
	if (!prArquivoEntrada)
	{
 printf("Nao foi possivel abrir o arquivo de entrada");
 return(0);
	}

	//Le a primeira linha do arquivo (cabecalho)
	fgets(sLinha,TAM_STRING,prArquivoEntrada);

	//Invoca a função que separa as informaçoes do cabeçalho
	LerCabecalho(pConta,sLinha);

	//Enquanto existirem transasões a serem lidas
	while (!feof(prArquivoEntrada))
	{
 //Faz a leitura de uma linha no arquivo contendo os dados da transação
 fgets(sLinha,TAM_STRING,prArquivoEntrada);

 //Testa se não é linha em branco
 if (sLinha[0]=='\n')
 {
 continue;
 }
 //Aloca memória para uma nova transação
 prTransacao = (stTransacao*)malloc(sizeof(stTransacao));

 //Quebra os dados da transação e preenche as estruturas
 PreencheTransacao(prTransacao,sLinha);

 //Verifica o tipo da operação e insere na lista do cartão ou da conta corrente:
 //código 1 a 4: operações de conta corrente
 //código 5 e 6: operações do cartão de crédito
 if (prTransacao->iOperacao < 4)
 {
 InsereTransacao(pListaConta,prTransacao);
 }

	}

 if(stTransacao.stData.iDia == sDataInicial.iDia);
 if(stTransacao.stData.iMes == sDataInicial.iMes);
 if(stTransacao.stData.iAno == sDataInicial.iAno);

 if(stTransacao.stData.iDia == sDataFinal.iDia);
 if(stTransacao.stData.iMes == sDataFinal.iMes);
 if(stTransacao.stData.iAno == sDataFinal.iAno);

 //Cria um ponteiro para o nó inicial de uma lista

 stLista* prSubLista = NULL;
 stLista* prSubLista = (stLista*)malloc(sizeof(stLista));

 if (sListaConta==NULL)
 {
 printf("Erro de alocacao\n");
 return 0;
 }

 //sListaConta->sDataInicial = sConta;
 //sListaConta->sDataFinal = NULL;

 if (prSubLista==NULL)
 prSubLista = sListaConta;
 else {
 //sListaConta->sDataFinal = prSubLista;
 //prSubLista = sListaConta;
	}

 //Implemente aqui

 //Retorna a lista ordenada
 return prSubLista;

}

/*------------------------------------------------------------------------------------------
* Nome da função: CriaSubListaFaturaOrdenada
* Descrição: Cria uma sublista das transações da fatura com base em uma data inicial e final
* Retorno: Ponteiro para uma lista
* Parâmetros: Ponteiro para uma lista ordenada, ponteiro para estrutura do tipo conta e duas
* estruturas do tipo data
------------------------------------------------------------------------------------------*/
stLista CriaSubListaFaturaOrdenada(stLista pListaCartao, stConta *pConta, stData pDataInicial, stData pDataFinal, char psNomeArquivo[])
{

//Declara um ponteiro para a estrutura de um arquivo

	FILE *prArquivoEntrada = NULL;

	//Declara uma string para a leitura da linha
	char sLinha[TAM_STRING];

	//Declara um ponteiro para transaçao
	stTransacao *prTransacao = NULL;

	//Faz as inicializaçoes das estruturas lista
	pListaConta->prInicio = NULL;
	pListaConta->prFim = NULL;

	//Faz as inicializações da estrutura conta
	pConta->fSaldoAnterior = 0.0f;
	pConta->fSaldoAtual = 0.0f;
	pConta->iNumCartao = 0;
	pConta->fTotalComprasCartao = 0.0f;
	pConta->fTotalPagtosCartao = 0.0f;
	pConta->fTotalCartao = 0.0f;

	//Faz a abertura do arquivo
	prArquivoEntrada = fopen(psNomeArquivo,"r");

	//Testa se o arquivo foi aberto com sucesso
	if (!prArquivoEntrada)
	{
 printf("Nao foi possivel abrir o arquivo de entrada");
 return(0);
	}

	//Le a primeira linha do arquivo (cabecalho)
	fgets(sLinha,TAM_STRING,prArquivoEntrada);

	//Invoca a função que separa as informaçoes do cabeçalho
	LerCabecalho(pConta,sLinha);

	//Enquanto existirem transasões a serem lidas
	while (!feof(prArquivoEntrada))
	{
 //Faz a leitura de uma linha no arquivo contendo os dados da transação
 fgets(sLinha,TAM_STRING,prArquivoEntrada);

 //Testa se não é linha em branco
 if (sLinha[0]=='\n')
 {
 continue;
 }

 //Cria um ponteiro para o nó inicial de uma lista
 stLista *sListaCartao = (stLista*)malloc(sizeof(stLista));
 stLista* prSubLista = NULL;
 stData* sDataInicial;
 stData* sDataFinal;

 //Implemente aqui

 //Retorna a lista ordenada
 return prSubLista;
}

/*------------------------------------------------------------------------------------------
* Nome da função: LiberaTransacoes
* Descrição: Libera a memória de todas as transações contidas em uma lista
* Retorno: Nenhum
* Parâmetros: Um ponteiro para uma lista
------------------------------------------------------------------------------------------*/
void LiberaMemoriaTransacoes(stLista *pLista)
{

	stTransacao *temp = NULL;

	//Verifica se a lista não está vazia
	if (!pLista || !pLista->prInicio)
	{
 return;
	}

	//Enquanto houverem transações na lista, libera memória
	while (pLista->prInicio != NULL)
	{
 temp = pLista->prInicio->prProximo;
 free(pLista->prInicio);
 pLista->prInicio = temp;
	}

	//Aponta os ponteiros de inicio e fim de lista para NULL
	pLista->prInicio = NULL;
	pLista->prFim = NULL;
}

/*------------------------------------------------------------------------------------------
* Nome da função: FormataValorMonetario
* Descrição: Formata um valor monetário para o formato +00.00 ou -00.00
* Retorno: Nenhum
* Parâmetros: Um ponteiro para uma string e um valor do tipo float
------------------------------------------------------------------------------------------*/
void FormataValorMonetario(char *psValor, float pValor)
{
// Verifica o valor pra ver se é necessário inserir o sinal

 if(pValor >= 0)
 {
 sprintf(psValor, "+%0.2f", pValor);
 }
 else
 sprintf(psValor, "%0.2f", pValor);
}

/*------------------------------------------------------------------------------------------
* Nome da função: FormataData
* Descrição: Formata uma data para o formato dd/mm/aaaa
* Retorno: Nenhum
* Parâmetros: Um ponteiro para uma string e uma estrutura do tipo Data
------------------------------------------------------------------------------------------*/
void FormataData(char *psData, stData pData)
{

 char cTmpDia[3];
 char cTmpMes[3];

 if(pData.iDia < 10)
 {
 sprintf(cTmpDia, "0%d", pData.iDia);
 }
 else
 {
 sprintf(cTmpDia, "%d", pData.iDia);
 }

 if(pData.iMes < 10)
 {
 sprintf(cTmpMes, "0%d", pData.iMes);
 }
 else
 {
 sprintf(cTmpMes, "%d", pData.iMes);
 }

 sprintf(psData, "%s/%s/%d", cTmpDia, cTmpMes, pData.iAno);
}

/*------------------------------------------------------------------------------------------
* Nome da função: FormataHorario
* Descrição: Formata um horario para o formato hh:mm
* Retorno: Nenhum
* Parâmetros: Um ponteiro para uma string e uma estrutura do tipo Horario
------------------------------------------------------------------------------------------*/
void FormataHorario(char *psHorario, stHorario pHorario)
{

 char cTmpHora[3];
 char cTmpMin[3];

 if(pHorario.iHora < 10)
 {
 sprintf(cTmpHora, "0%d", pHorario.iHora);
 }
 else
 {
 sprintf(cTmpHora, "%d", pHorario.iHora);
 }

 if(pHorario.iMinuto < 10)
 {
 sprintf(cTmpMin, "0%d", pHorario.iMinuto);
 }
 else
 {
 sprintf(cTmpMin, "%d", pHorario.iMinuto);
 }

 sprintf(psHorario, "%s:%s", cTmpHora, cTmpMin);
}

/*------------------------------------------------------------------------------------------
* Nome da função: ImprimeExtrato
* Descrição: Faz a impressão do extrato da conta corrente
* Retorno: Nenhum
* Parâmetros: Uma estrutura do tipo stConta e um ponteiro para uma lista ordenada
------------------------------------------------------------------------------------------*/
void ImprimeExtrato(stConta pConta, stLista *pLista)
{
// Armazena valores que são convertidos para string

	char strValor[TAM_STRING];
	char strData[TAM_STRING];
	char strHorario[TAM_STRING];

	//Declara um ponteiro para a estrutura de um arquivo
	FILE *prArquivoSaida = NULL;

	//Faz a abertura do arquivo
	prArquivoSaida = fopen("extratoConta.txt","w");

	//Testa se o arquivo foi aberto com sucesso
	if (!prArquivoSaida)
	{
 printf("Nao foi possivel abrir o arquivo de saída");
 return;
	}

	fputs("\n ================================================\n", prArquivoSaida);
	fputs("\n Banco TAD$\n", prArquivoSaida);
	fputs("\n Extrato de Conta Corrente\n\n", prArquivoSaida);
	fputs(" Agencia: ", prArquivoSaida);
	fputs(pConta.cAgencia, prArquivoSaida);
	fputs("\n",prArquivoSaida);
	fputs(" Conta Corrente: ", prArquivoSaida);
	fputs(pConta.cNumConta, prArquivoSaida);
	fputs("\n",prArquivoSaida);
	fputs(" Titular: ", prArquivoSaida);
	fputs(pConta.cTitular, prArquivoSaida);
	fputs("\n ------------------------------------------------\n\n", prArquivoSaida);
	fputs("\n\t\t\tSaldo Anterior: ", prArquivoSaida);
	FormataValorMonetario(strValor, pConta.fSaldoAnterior);
	fputs(strValor, prArquivoSaida);
	fputs("\n\n Data\t Horario\t Operacao\t Valor\n\n", prArquivoSaida);

	//Cria um nó temporário
	stTransacao *temp = NULL;

	//Testa se a lista existe
	if(!pLista || !pLista->prInicio)
	{
 return;
	}

	//Aponta para o primeiro elemento da lista
	temp = pLista->prInicio;

	//Enquanto lista não chegou ao final, imprime
	while(temp!=pLista->prFim)
	{
 FormataValorMonetario(strValor, temp->fValor);
 FormataData(strData, temp->sData);
 FormataHorario(strHorario, temp->sHorario);
 if(temp->iOperacao == 1) // Saque: adiciona mais uma tabulação antes do valor
 {
 fprintf(prArquivoSaida, " %s \t %s \t %s \t\t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
 }
 else
 {
 fprintf(prArquivoSaida, " %s \t %s \t %s \t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
 }

 temp = temp->prProximo;
	}

	FormataValorMonetario(strValor, temp->fValor);
	FormataData(strData, temp->sData);
	FormataHorario(strHorario, temp->sHorario);
	fprintf(prArquivoSaida, " %s \t %s \t %s \t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);

 FormataValorMonetario(strValor, pConta.fSaldoAtual);
 fputs("\n\t\t\tSaldo Atual: ", prArquivoSaida);
	fputs(strValor, prArquivoSaida);

	//Fecha o arquivo
	fclose(prArquivoSaida);
}

/*------------------------------------------------------------------------------------------
* Nome da função: ImprimeFatura
* Descrição: Faz a impressão da fatura do cartão de crédito
* Retorno: Nenhum
* Parâmetros: Estrutura do tipo Conta e um ponteiro para uma lista ordenada
------------------------------------------------------------------------------------------*/
void ImprimeFatura(stConta pConta, stLista *pLista)
{
// Armazena valores que são convertidos para string

	char strValor[TAM_STRING];
	char strData[TAM_STRING];
	char strHorario[TAM_STRING];

	//Declara um ponteiro para a estrutura de um arquivo
	FILE *prArquivoSaida = NULL;

	//Faz a abertura do arquivo
	prArquivoSaida = fopen("faturaCartao.txt","w");

	//Testa se o arquivo foi aberto com sucesso
	if (!prArquivoSaida)
	{
 printf("Nao foi possivel abrir o arquivo de saída");
 return;
	}

	fputs("\n ================================================\n", prArquivoSaida);
	fputs("\n Banco TAD$\n", prArquivoSaida);
	fputs("\n Fatura do Cartao de Credito\n\n", prArquivoSaida);
	fputs(" Nro. do Cartao: ", prArquivoSaida);
	fprintf(prArquivoSaida, "%i\n", pConta.iNumCartao);
	fputs(" Titular: ", prArquivoSaida);
	fputs(pConta.cTitular, prArquivoSaida);
	fputs("\n ------------------------------------------------\n\n", prArquivoSaida);
	fputs("\n Data\t Horario\t Operacao\t Valor\n\n", prArquivoSaida);

	//Cria um nó temporário
	stTransacao *temp = NULL;

	//Testa se a lista existe
	if(!pLista || !pLista->prInicio)
	{
 return;
	}

	//Aponta para o primeiro elemento da lista
	temp = pLista->prInicio;

	//Enquanto lista não chegou ao final, imprime
	while(temp!=pLista->prFim)
	{
 FormataValorMonetario(strValor, temp->fValor);
 FormataData(strData, temp->sData);
 FormataHorario(strHorario, temp->sHorario);
 if(temp->iOperacao == 5) // Pagto_Fatura: adiciona mais uma tabulação antes do valor
 {
 fprintf(prArquivoSaida, " %s \t %s \t %s \t\t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
 }
 else
 {
 fprintf(prArquivoSaida, " %s \t %s \t %s \t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
 }

 temp = temp->prProximo;
	}

	FormataValorMonetario(strValor, temp->fValor);
	FormataData(strData, temp->sData);
	FormataHorario(strHorario, temp->sHorario);
	if(temp->iOperacao == 5) // Pagto_Fatura: adiciona mais uma tabulação antes do valor
	{
 fprintf(prArquivoSaida, " %s \t %s \t %s \t\t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
	}
	else
	{
 fprintf(prArquivoSaida, " %s \t %s \t %s \t %s\n", strData, strHorario, OPERACOES[temp->iOperacao], strValor);
 }

 fputs("\n\t\t\tTotal de Compras: ", prArquivoSaida);
	FormataValorMonetario(strValor, pConta.fTotalComprasCartao);
	fputs(strValor, prArquivoSaida);
	fputs("\n\t\t\tTotal de Pagamentos: ", prArquivoSaida);
	FormataValorMonetario(strValor, pConta.fTotalPagtosCartao);
	fputs(strValor, prArquivoSaida);
	fputs("\n\t\t\tTotal da Fatura: ", prArquivoSaida);
	FormataValorMonetario(strValor, pConta.fTotalCartao);
	fputs(strValor, prArquivoSaida);

 //Fecha o arquivo
	fclose(prArquivoSaida);
}

/*------------------------------------------------------------------------------------------
* Nome da função: MenuPrincipal
* Descrição: Mostra na tela o menu principal
* Retorno: Nenhum
* Parâmetros: Nenhum
------------------------------------------------------------------------------------------*/
void MenuPrincipal()
{

	system("cls");
	printf("\n |------------------------------------------------|\n");
	printf(" | |\n");
	printf(" | UNIVERSIDADE DO TOCANTINS |\n");
	printf(" | Banco TAD$ |\n");
	printf(" | |\n");
	printf(" |------------------------------------------------|\n");
	printf(" | |\n");
	printf(" |	<1> Extrato da Conta Corrente |\n");
	printf(" |	<2> Fatura do Cartao de Credito |\n");
	printf(" |	<3> Sair |\n");
	printf(" | |\n");
	printf(" |------------------------------------------------|\n\n");
	printf("\t\tOpcao: ");
}

/*------------------------------------------------------------------------------------------
* Nome da função: TelaPeriodo
* Descrição: Mostra na tela o cabeçalho para solicitação do período do extrato da conta ou do cartao
* Retorno: Nenhum
* Parâmetros: Nenhum
------------------------------------------------------------------------------------------*/
void TelaPeriodo(char psTipoRelatorio, stData pDataInicio, stData *pDataFinal)
{

	system("cls");
	printf("\n |------------------------------------------------|\n");
	printf(" | |\n");
	printf(" | UNIVERSIDADE DO TOCANTINS |\n");
	printf(" | Banco TAD$ |\n");
	printf(" | |\n");
	printf(" |------------------------------------------------|\n");
	printf(" | |\n");
	printf(" | %s - Periodo |\n",psTipoRelatorio);
	printf(" | |\n");
	printf(" |------------------------------------------------|\n\n");

	//Obtem a data inicial e final para o extrato desejado
	printf(" Entre com a data inicial: ");
	scanf("%d/%d/%d", &pDataInicio->iDia, &pDataInicio->iMes, &pDataInicio->iAno);
	printf(" Entre com a data final: ");
	scanf("%d/%d/%d", &pDataFinal->iDia, &pDataFinal->iMes, &pDataFinal->iAno);
}

/*------------------------------------------------------------------------------------------
* Nome da função: main
* Descrição: Função principal de um programa em C
* Retorno: Um valor inteiro
* Parâmetros: Nenhum
------------------------------------------------------------------------------------------*/
int main(void)
{
//Variáveis criadas para armazenar a data inicial e final do extrato desejado

	stData sDataInicio;
	stData sDataFinal;

	//Variável criada para armazenar as informações da conta do cliente
	stConta sConta;

	//Declaração e alocação de memória para as listas
	stLista *sListaConta = (stLista*)malloc(sizeof(stLista));
	stLista *sListaCartao = (stLista*)malloc(sizeof(stLista));
	stLista *sSubLista = NULL;

	// Variável que armazena a opção do menu selecionada pelo usuário
	char opcao;

	//Invoca a função para realizar a leitura dos dados do arquivo
	LerArquivo(sListaConta, sListaCartao, &sConta, "Entrada.txt");

	// Mostra o menu principal na tela
	MenuPrincipal();
 fflush(stdin);
	opcao=getchar();

	switch(opcao)
	{
 case '1': // Emitir extrato da conta corrente
 system("cls");
 TelaPeriodo("Extrato da Conta Corrente ",&sDataInicio, &sDataFinal);
 //Cria a sublista de transações com base nas datas fornecidas
 sSubLista = CriaSubListaContaOrdenada(sListaConta, &sConta, sDataInicio, sDataFinal);
 //Imprime extrato no arquivo de saída
 ImprimeExtrato(sConta, sSubLista);
 system("cls");
 //Imprime mensagem
 printf("\n\n\t\tExtrato da conta corrente gerado com sucesso");
 getch();
 break;
 case '2': // Emitir fatura do cartão de crédito
 system("cls");
 TelaPeriodo("Fatura do Cartao de Credito",&sDataInicio, &sDataFinal);
 //Cria a sublista de transações com base nas datas fornecidas
 sSubLista = CriaSubListaFaturaOrdenada(sListaCartao, &sConta, sDataInicio, sDataFinal);
 //Imprime a fatura no arquivo de saída
 ImprimeFatura(sConta, sSubLista);
 system("cls");
 //Imprime mensagem
 printf("\n\n\t\tFatura do cartao de credito gerado com sucesso");
 getch();
 break;
 }

	//Libera a memória alocada dinamicamente
	LiberaMemoriaTransacoes(sListaConta);
	LiberaMemoriaTransacoes(sListaCartao);

	free(sListaConta);
	free(sListaCartao);
	free(sSubLista);

	return 0;
}