Lista Ligada

[byprogsystem]

E ai Pessoal Beleza!!! Tenho que fazer um programa para a faculdade, mais nao estou conseguindo finalizar...

segue o codigo completo.

As duas funçoes que ta pegando e as:

CriaSubListaContaOrdenada e CriaSubListaFaturaOrdenada

Sera que alguem pode me ajudar.

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

[skm]

Perdi-me a meio do codigo. Como eu acho que a maior parte das pessoas vai desistir a meio de ver.

1º - Podes so colcoar o codigo onde tents duvidas.

2º - Que duvida realmente tens ? Senão vai ser dificil ajudar-te

[byprogsystem]

E nessa função que eu estou com problemas:

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

}

[Atahualpa]

Primeiramente, vc tem aí alguns problema de sintaxe, certo? Coloque pra rodar, e ele apontou para essa linha:

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

Erro: 329 expected primary-expression before '.' token