Complementando em c++

alexalves100 · Março 12, 2009

Ola galera bom dia, estou precisando q vcs avaliem este código, estou tentando implementa-lo para q eu possa gerar extrato da conta do banco, fatura do cartão, se puderem me ajudar serei grato, pois ja tentei de várias formas, mas da erro na compilação.

este é o código:

/******************************************Bibliotecas***************************
**********/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.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)
{
	//Cria um ponteiro para o nó inicial de uma lista
	stLista* prSubLista  = NULL;
	
	struct  stLista* stData pDataInicial; 
	struct  stLista* stData pDataFinal;				 /*ponteiros anterior e novo*/
	 if (prSubLista==NULL)								 /*se primeiro não tiver nada*/
	 prSubLista=(struct  stLista*)le(prSubLista); /*aloca-se s struct e */
	 else												 /*lê-se dados pela função le*/
	 {
	 stData pDataInicial=prSubLista; /*anterior deve ser a struct anterior à nova*/
	 stData pDataFinal=stData pDataInicial;
	 do
	   {
	   if(stData pDataFinal==NULL){							   /*se novo for vazio*/
	   stData pDataFinal=(struct stLista *)le(stData pDataFinal);/*aloca e le struct*/
	   stData pDataInicial->next=stData pDataFinal; /*campo next do struct anterior deve apontar o novo*/	   
	   break;
		}
		 else{
		 stData pDataInicial=stData pDataFinal; /*anterior iguala-se a novo e novo avança uma struct*/
		 stData pDataFinal=stData pDataFinal->next;
		  }
		  }while(1);
	  }
	  return(prSubLista); /*não precisa retornar o novo pois ele fica na memória*/
}					   /* assim só retorna o ponteiro para o primeiro struct*/  

}
	
	//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)
{
	//Cria um ponteiro para o nó inicial de uma lista
	stLista* prSubLista  = NULL;
	
	//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;
}

VictorCacciari · Março 12, 2009

Cara...

quando o código for grande, use algum serviço de postagem, como o codepad ou paste.la, posi ler um código com realce de sintaxe é MUITO mais fácil!

Eu não li o teu código, é muita coisa pra eu encontrar o erro a olho nú...

Posta a parte que está dando erro, e qual é o erro, assim fica mais fácil de te ajudarmos a resolver o problema.

alexalves100 · Março 12, 2009

Certo é esta parte aqui:

stLista* CriaSubListaContaOrdenada(stLista* pListaConta, stConta *pConta, stData pDataInicial, stData pDataFinal)
{
	//Cria um ponteiro para o nó inicial de uma lista
	 stLista* prSubLista  = NULL;
	  stData *sDataInicial;
	  stData *sDataFinal;
	  stLista *sListaConta = (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;
	}
   return prSubLista;
}

Bruno ricardo · Março 16, 2009

Tbm estou com problemas nesse Código, o seu está mais correto que o meu o meu estava TODO errado,

se conseguir me avise por favor....

alexalves100 · Março 17, 2009

Alguém poderá me dar uma luz awe !!!!

Entrar

Arquivado

Complementando em c++

Recommended Posts

alexalves100 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

VictorCacciari 42

Compartilhar este post

Link para o post

Compartilhar em outros sites

alexalves100 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

Bruno ricardo 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

alexalves100 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

Fixar div até atingir uma certa altura

Ajuda com Extends e envio para o banco

PHP+Codeginiter - Orientação para Impressão

Este projeto é apoiado pelas empresas

Fóruns

Tempo Real

Informação importante