Option for write a file...

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.

Code:

---

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

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

---