Cria Lista em C

osbornehell · Março 14, 2009

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;
}

osbornehell · Março 17, 2009

alguem pode dar uma dica do quer fazer? e esta certo a linha Raciocínio?

VictorCacciari · Março 17, 2009

Amigo...

O teu código ta um pouco grande, para lermos ele e analisarmos...

onde é que está tendo dificuldades?

poste somente o que é preciso (parte onde tem dificuldade e erros gerados).

[]

osbornehell · Março 17, 2009

Amigo...

O teu código ta um pouco grande, para lermos ele e analisarmos...

onde é que está tendo dificuldades?

poste somente o que é preciso (parte onde tem dificuldade e erros gerados).

[]

preciso implementar essas funções

/*------------------------------------------------------------------------------------------
* 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;
}

osbornehell · Março 17, 2009

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;

	//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);
		}

	}

	 // comparar datas entrada usuario com arquivo
		 
 	  if(stTransacao.sData.iDia == sDataInicial.iDia, // erro
		&& stTransacao.sData.iMes == sDataInicial.iMes,
		&& stTransacao.sData.iAno == DataInicial.iAno); 
	  
		 if(stTransacao.sData.iDia == sDataFinal.iDia,
		&& stTransacao.sData.iMes == sDataFinal.iMes,
		&& stTransacao.sData.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;
	

}

esta muito errado essa linha de raciocinio

VictorCacciari · Março 17, 2009

Cara, sua linha de raciocínio está certa, na minha opinião.

ali onde você comentou: "//erro"

no final do if você colocou um ponto e vírgula??

isso deve estar gerando o erro!

Pelo que vi, o que você está tendo dificuldade é na criação e manipulação da lista, correto?

achei meio confusa a forma como você declarou a lista, massss...

eu teria usado uma lista duplamente encadeada. é facílimo manipular dados com ela.

Ok,

a idéia por trás de uma lista ordenada encadeada é:

typedef struct
{
	 int valor;
	 struct node *prox;
} node;


void inserir(node* ini, int item)
{
node *add = (node*)malloc(sizeof(node));
node *curr;

	curr = ini;
	
	//vamos encontrar a posição em que deve-se adicionar o item
	while (curr->valor < item)
	{
		curr = curr->prox;
	}

	//agora ja estamos na posição correta!
	add->valor = item;

	//inserimos o nó no local desejado!
	add->prox = curr->prox;
	curr->prox = add;
}

Cara, eu sinceramente não entendi muito bem o que você precisa fazer, acho que a parte mais dificil, que era organizar esse monte de dados (transações, contas, etc...) você ja fez.

era só criar a lista mesmo?

osbornehell · Março 17, 2009

sim estou com problemas justa mente ai

não estou assimilando como cria essa lista

VictorCacciari · Março 18, 2009

Cara,

tem um outro tópico que fala bastante sobre o assunto!

da uma olhada lá, acho que vai te ajudar!

http://forum.imasters.com.br/index.php...p;#entry1249487

Krisofferson · Março 19, 2009

até agora eu não entendi como é que essa duas estruturas se conectam pra formar a bendita lista

//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;

VictorCacciari · Março 19, 2009

fiz rapidão um esquema pra você, talvez te ajude a visualizar

da uma olhada:

http://img7.imageshack.us/img7/9830/linkedlist.png

Krisofferson · Março 19, 2009

ok, essa parte de quardar o endereço de memória tava beleza, o que não me entra na cabeça é como que essa variáveis/ponteiros tem relação entre si nesta estrutura e lista correspondentes?????

stTransacao *prInicio;

stTransacao *prFim;

struct Transacao *prProximo;

VictorCacciari · Março 19, 2009

O problema é que uma lista encadeada não tem fim...

não tem necessidade de você guardar o endereço do inicio da lista dentro de cada nó da lista, você estará ocupando 4 bytes a mais em cada nó, em uma lista grande isso pode ser bastante!

no tópico que eu te passei, eu fiz a implementação de uma lista beeeem simples.

o que você poderia fazer para simplificar:

(eu acho que dessa forma ficará mais legível!)

typedef struct
{
	//os dados da transação
} transacao;

typedef struct
{
	transacao dados;
	struct node_t* proxima;
} node_t;

se não houver hipótese e no caso de você não poder mudar as estruturas, o esquema é:

prInicio aponta para a primeira transação da lista, prFim aponta para a última...

em cada transação, podemos encontrar o endereço da próxima transação.

Com isso podemos percorrer a lista toda:

void mostrarLista(stLista* list)
{
stTransacao *atual;

	atual = list->prInicio;

	while (atual != list->prFim)
	{   
	printf("Valor da transação: %f\n", atual->fValor);
	//faça os prints para todos os valores...

	atual = atual->prProximo;
	}

	//a lista foi percorrida!
}

osbornehell · Março 19, 2009

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

sDataIncial, sDataFinal

entõa stTransação pode receber stData

typedef struct Data
{
	int iDia;
	int iMes;
	int iAno;		
} stData;

porem tem que comparar agora como é que não estou sabendo

if(stTransacao.sData.iDia == sDataInicial.iDia,
		&& stTransacao.sData.iMes == sDataInicial.iMes,
		&& stTransacao.sData.iAno == DataInicial.iAno) 
	  
		if(stTransacao.sData.iDia == sDataFinal.iDia,
		&& stTransacao.sData.iMes == sDataFinal.iMes,
		&& stTransacao.sData.iAno == sDataFinal.iAno)

me passaram que tem que ser algo meio assim

tipo transacao recebe stData stData

e stLista recebe dados stTransacao*prInicio e prFim

osbornehell · Abril 5, 2009

ai pessoal alguem sabe me fala se esta lista esta errada?

/*------------------------------------------------------------------------------------------
* 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
			stTransacao *aux = NULL;
			stLista* prSubLista = (stLista*)malloc(sizeof(stLista));		 
			stTransacao *sListaConta  = prSubLista->prInicio;


	while(int x=1 || x>0)
	{
	sListaConta = prSubLista->prInicio->prProximo; //Aponta para o primeiro elemento da lista
	 stTransacao *sDataInicial = NULL;
	x = -1;
	 do{
	 stTransacao *sConta =sListaConta;
	stTransacao *sDataFinal= prSubLista->prFim->prProximo;
	 
	 if(sDataFinal==NULL)
	  {
	  break;
		}
	 if( sConta->iOperacao > sDataFinal->iOperacao )
	 {
	 x = 1;
	 if(sDataInicial==NULL)
	  {
	   aux=sDataFinal->prProximo;
	   sConta->prProximo=sConta;
	   prSubLista->prInicio = sDataFinal;
	   sConta->prProximo=aux;
	   
	  }else{

	  aux=sDataFinal->prProximo;
	  sDataFinal->prProximo=sConta;
	  sDataInicial->prProximo=sDataFinal;
	  sConta->prProximo=aux;
	}
 }

	 sDataInicial = sListaConta;
	 sListaConta = prSubLista->prFim->prProximo;

	  }while(prSubLista!=NULL);
   }


 
	//Implemente aqui
	
	//Retorna a lista ordenada
	return prSubLista;
}

porem seu retorno tem que ser datas 10/02/2010 e horas 12:00

/*------------------------------------------------------------------------------------------
* 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;					 
	}
}

VictorCacciari · Abril 5, 2009

não declare variáveis dentro de estruturas de loops, como:

while (int x = 1 || x > 0)

isso está totalmente fora do padrão internácional para C e C++

Sem contar que deixa o código meio porco....:P

Cara, não sei te dizer se a sua função está certa, ou errada.

Onde está dando erro?

como é o erro?

Uma coisa eu te garanto, se você espera um valor x de uma função e ela retorna y é porque algo está errado!

Tente explicar melhor o seu problema!

http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif

osbornehell · Abril 5, 2009

não declare variáveis dentro de estruturas de loops, como:
while (int x = 1 || x > 0)
isso está totalmente fora do padrão internácional para C e C++
Sem contar que deixa o código meio porco....:P

Cara, não sei te dizer se a sua função está certa, ou errada.

Onde está dando erro?

como é o erro?

Uma coisa eu te garanto, se você espera um valor x de uma função e ela retorna y é porque algo está errado!

Tente explicar melhor o seu problema!

http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif

é so cria a lista

Arquivado

Cria Lista em C

Recommended Posts

osbornehell 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

osbornehell 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

osbornehell 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

osbornehell 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

osbornehell 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

Krisofferson 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

Krisofferson 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

osbornehell 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

osbornehell 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

osbornehell 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

Fóruns

Tempo Real

Informação importante