Option for write a file...

[Ervilha]

I made a small source of a diary in C.
Everything works perfect.
I am studying alone with the material found on the net, and wanted to learn to write in text file.
I tried several handouts but I could not understand the concept.
I want to record only when you select the option to record.

(This Work Fine) (1) -> Add New Registration: (Ex, Name, phone, end...)
(This Work Fine) (2) -> Delete one up:
(This Work Fine) (3) -> Pesquizar one up:
(This Work Fine) (4) -> List All Registrations:
(5) -> Write to File:
(6) -> Read File
(This Work Fine) (0) -> To Exit

I want to write all in a file when you press 5.
And Read off a file when press 6.

I used visual studio 2008.

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

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

[Cheezewizz]

try looking into iostreams, in particular fstreams will do what you want...

[Ervilha]

Thanks man, For write i made this, and work well...

void Gravar() 
{
	int ciclos;

	FILE* ficheiro;
	ficheiro=fopen("agenda.txt", "w");

	No *Atual;
	Atual = Raiz;
	ciclos=1;

	if(ficheiro!=NULL)
	{
		while(Atual!=NULL)		// percorre a lista duplamente encadeada desde a raiz
		{
			fprintf(ficheiro, "\n\n Reg. N: %d",ciclos);
			fprintf(ficheiro, "\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++;
		}
	}
	fclose(ficheiro);
	printf ("\n\n ");
	printf ("Gravacao efetuada com sucesso!");
	printf ("\n\n\n\n ");
	system("pause");
	system("cls");
}

Now, i have a little touble for doing the read.
i tried this...

void Ler() 
{
	int ciclos;

	FILE* ficheiro;
	ficheiro=fopen("agenda.txt", "r");

	No *Atual;
	Atual = Raiz;
	ciclos=1;

	if(ficheiro!=NULL)
	{
		while(gets(Atual->nome))		// percorre a lista duplamente encadeada desde a raiz
		{
			scanf(Atual->nome, "%s", Atual->nome);
			//fprintf(ficheiro, "\n\n Reg. N: %d",ciclos);
			//fprintf(ficheiro, "\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++;
		}
	}
	fclose(ficheiro);
	printf ("\n\n\n\n ");
	printf ("Gravacao efetuada com sucesso!");
	printf ("\n\n\n\n ");
	system("pause");
	system("cls");
}