Gravar e Ler em Arquivo.

[Ervilha]

Fiz um programa de agenda com as seguintes opções...

(1) -> Inserir Novo Cadastro:

(2) -> Excluir um Cadastro:

(3) -> Pesquisar um Cadastro:

(4) -> Listar Todos os Cadastros:

(0) -> Para Sair

Tudo funciona certinho, usando Struct, Função, Ponteiros, numa Lista Duplamente Encadeada.

Agora eu estava querendo colocar duas novas funções...

(5) -> Gravar no Arquivo:

(6) -> Ler do Arquivo

A idéia é, usar o programa na memória, e quando eu apertar ele gravar em um arquivo txt ou binário tanto faz.

Para quando eu abrir o programa de novo apenas apertar para ler e ele jogar tudo na memória de novo.

Como gravar direto quando eu for inserindo eu sei, mas queria fazer desse jeito.

Se alguém puder me dar uma mão, estou postando o código abaixo.

// Projeto_Veiculos.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "tool.h"
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <iostream>

/* ---------------------------------------------------------------- */

struct _no    // define a estrutura do processo
{
    struct _no *anterior;
    char nome[40], rua[100], bairro[50], cidade[50], estado[10], cep[15], telefone[15];
    struct _no *proximo;
};

/* ---------------------------------------------------------------- */

typedef struct _no No;

No *Raiz=NULL;        // define um ponteiro para o numero raiz
No *Ultimo=NULL;    // define um ponteiro para o ultimo numero

/* ---------------------------------------------------------------- */

void Insere(char *nome, char *rua, char *bairro, char *cidade, char *estado, char *cep, char *telefone) 
{
    No *Atual;
    No *NoAnterior;
    No *NoPosterior;
    No *NovoNo;    

    if (Raiz==NULL)        // Verifica se o nó na raiz é nulo, que é o caso quando a lista está vazia.
    {                    // Se for, cria nó na raiz com os dados fornecidos e faz o último nó coincidir com ele.
        Raiz = new No;
        strcpy (Raiz->nome,nome);
        strcpy (Raiz->rua,rua);
        strcpy (Raiz->bairro,bairro);
        strcpy (Raiz->cidade,cidade);
        strcpy (Raiz->estado,estado);
        strcpy (Raiz->cep,cep);
        strcpy (Raiz->telefone,telefone);
        Raiz->proximo = NULL;
        Raiz->anterior = NULL;
        Ultimo = Raiz;
    }
    else 
    {          
        NoAnterior = NULL;    // se já houver raiz percorre a lista duplamente encadeada, comecando da raiz.
        Atual = Raiz;        // inicialmente, não há nó anterior.

        while (Atual!=NULL) 
        {
            if (strcmp(Atual->nome,nome)>=0)
            {
                break;    // verifica se o nó atual é igual, se for superior pára
            }
            else 
            {
                NoAnterior = Atual;
                Atual = Atual->proximo;
            }
        }

        if (Atual!=NULL) // só faz a comparação abaixo se existe o nó Atual
        {
            if (strcmp(Atual->nome,nome)==0) 
            {
                printf ("\n\n Nome já existente!\n");
                printf ("\n\n\n\n ");
                system("pause");
                system("cls");
                return;
            }

            NoPosterior = Atual;        // insere um novo nó entre o nó atual e o nó anterior        
            NovoNo = new No;            // aloca memória para o novo nó            
            strcpy (NovoNo->nome,nome);    // coloca dados no nó a ser inserido
            strcpy (NovoNo->rua,rua);
            strcpy (NovoNo->bairro,bairro);
            strcpy (NovoNo->cidade,cidade);
            strcpy (NovoNo->estado,estado);
            strcpy (NovoNo->cep,cep);
            strcpy (NovoNo->telefone,telefone);

            NovoNo->proximo = NoPosterior;    // atualiza ponteiros do novo nó
            NovoNo->anterior = NoAnterior;

            if (NoAnterior != NULL)    // atualiza ponteiros dos nós vizinhos
            {
                NoAnterior->proximo = NovoNo;
            }
            if (NoPosterior != NULL)
            {
                NoPosterior->anterior = NovoNo;
            }            
            if (NovoNo->anterior == NULL)    // verifica se o novo nó foi inserido no início ou no fim da lista se foi,
            {                                // atualiza referências
                Raiz = NovoNo;
            }
            if (NovoNo->proximo == NULL)
            {
                Ultimo = NovoNo;
            }
        }
    }
}

/* ---------------------------------------------------------------- */

void Lista() 
{
    int ciclos;
    No *Atual;
    Atual = Raiz;
    ciclos=1;

    while(Atual!=NULL)        // percorre a lista duplamente encadeada desde a raiz
    {
        system("cls");
        printf("\n\n Reg. N: %d",ciclos);
        printf("\n Nome: %s\n Rua: %s\n Bairro: %s\n Cidade: %s\n Estado: %s\n CEP: %s\n Telefone: %s\n",Atual->nome,Atual->rua,Atual->bairro,Atual->cidade,Atual->estado,Atual->cep,Atual->telefone);
        Atual=Atual->proximo;
        ciclos++;
    }
    printf ("\n\n\n\n ");
    system("pause");
    system("cls");
}

/* ---------------------------------------------------------------- */

void Deleta(char *nome) 
{
    No *Atual;
    No *Anterior=NULL;
    No *Posterior;

    Atual = Raiz;

    while (Atual!=NULL)    // primeiro, percorre a lista duplamente encadeada desde a raiz
    {        
        if (strcmp(Atual->nome,nome)>=0)    // verifica se já encontrei ou já passei do nome procurado
        {
            break;
        }
        else  // se ainda não passou
        {  
            Anterior = Atual;
            Atual = Atual->proximo;
        }
    }

    if (Atual!=NULL)
        Posterior = Atual->proximo;


    if (Atual != NULL)    // verifica se o nó atual é mesmo o nó procurado
        if (strcmp(Atual->nome,nome)==0)    // se for, deleta faz com que o nó subsequente ao atual seja o subsequente ao nó anterior para manter a integridade da lista
        {              
            if (Atual != Raiz)
            {
                Anterior->proximo = Atual->proximo;
            }
            else  // se o no atual é a raiz, atualizo a referência para a raiz
            {
                Raiz = Atual->proximo;
            }            
            if (Atual != Ultimo)    // faz com que a referência para o nó anterior do próximo nó seja
            {                        // o nó anterior ao que será deletado, para manter a integridade
                Posterior->anterior = Anterior;
            }
            else    // se o nó atual é o último, atualiza a referência para o último
            {
                Ultimo = Anterior;
            }            
            free(Atual);    // agora, o nó atual morreeeee!!!!
            printf ("\n\n Nome deletado! \n\n");
            printf ("\n\n ");
            system("pause");
            system("cls");
            return;
        }
        printf("\n\n não achei!\n");
        printf ("\n\n\n\n ");
        system("pause");
        system("cls");
}

/* ---------------------------------------------------------------- */

void Pesquiza(char *nome)
{        
    No *Atual;
    Atual = Raiz;

    while (Atual!=NULL)
    {
        if (strcmp(Atual->nome,nome)>=0)
        {
            break;
        }
        else
        {
            Atual = Atual->proximo;
        }
    }

    if (Atual!=NULL)
    {
        if (strcmp(Atual->nome,nome)==0)
        {
            system("cls");
            printf("\n Nome: %s\n Rua: %s\n Bairro: %s\n Cidade: %s\n Estado: %s\n CEP: %s\n Telefone: %s\n",Atual->nome,Atual->rua,Atual->bairro,Atual->cidade,Atual->estado,Atual->cep,Atual->telefone);
            printf("\n\n\n\n ");
            system("pause");
            system("cls");
            return;
        }
    }

    printf("\n\n Nome não encontrado!");    

    printf("\n\n ");
    system("pause");
    system("cls");
}

/* ---------------------------------------------------------------- */

void main () 
{
    int opcao;
    char nome[40], rua[100], bairro[50], cidade[50], estado[10], cep[15], telefone[15];

    do 
    {
        printf("\n\n *************************************** \n *          AGENDA DE TELEFONE         * \n *************************************** \n *  (1) -> Inserir Novo Cadastro:      * \n *  (2) -> Excluir um Cadastro:        * \n *  (3) -> Pesquizar um Cadastro:      * \n *  (4) -> Listar Todos os Cadastros:  * \n *  (5) -> Gravar no Arquivo:          * \n *  (6) -> Ler do Arquivo              * \n *  (0) -> Para Sair                   * \n *************************************** \n\n --> ");
        scanf("%d",&opcao);

        if (opcao == 1 || opcao == 2 || opcao == 3) 
        {
            fflush(stdin);
            printf("\n\n Digite o Nome: " );            
            gets(nome);            
        }

        switch (opcao) 
        {
        case 1: 
            {    
                fflush(stdin);                
                printf(" Digite a Rua e o N da casa: " );            
                gets(rua);
                fflush(stdin);
                printf(" Digite o Bairro: " );            
                gets(bairro);    
                fflush(stdin);
                printf(" Digite a Cidade: " );            
                gets(cidade);    
                fflush(stdin);
                printf(" Digite o Estado: " );            
                gets(estado);    
                fflush(stdin);
                printf(" Digite o CEP: " );            
                gets(cep);
                fflush(stdin);
                printf(" Digite o Telefone: " );            
                gets(telefone);
                fflush(stdin);
                system("cls");
                Insere(nome,rua,bairro,cidade,estado,cep,telefone); 
                break;
            }
        case 2: 
            {
                Deleta(nome); 
                break;
            }
        case 3: 
            {
                Pesquiza(nome); 
                break;
            }
        case 4: 
            {
                Lista();                
                break;
            }
        case 5: 
            {                                                
                break;
            }
        case 6: 
            {                                
                break;
            }
        }
    } while (opcao != 0);
} 

/* ---------------------------------------------------------------- */

[Ervilha]

alguém pode dr um help ae?

[Jonathan Queiroz]

Como assim "Como gravar direto quando eu for inserindo eu sei, mas queria fazer desse jeito" ?

O que seria "desse jeito".

Obs.:

Não cheguei a analisar o código-fonte ainda.