Lire et écrire dans un fichier à partir d'une classe c++

Bonjour, je souhaite réaliser une gestion de clients en c++, c'est à dire me permettre d'afficher, ajouter, modifier ou supprimer un client qui serait présent dans un fichier texte a chaque ajout.
J'ai réalisé classe.h regroupant la classe mere, mon souci est que je ne sais pas comment manier une lecture, ecriture ou suppression dans un fichier, j'aimerais si possible un exemple.
classe.h
#include <iostream>
#include <string>

class PERSONNE
{
protected:
std::string adresse;
std::string cp;
std::string ville;
int annee_entree;
int annee_sortie;
public:
void afficher();
void add();
void del();
};


class CLIENT :public PERSONNE
{

private:
std::string nom;
std::string prenom;
public:
CLIENT();
CLIENT(const std::string& _nom, const std::string& prenom ,const std::string & add,const std::string& _cp,const std::string& _ville,int _entree, int _sortie)
{
nom= _nom;
prenom= _prenom;
adresse=_add;
cp=_cp;
ville=_ville;
annee_entree=_entree;
annee_sortie=_sortie;

}
void afficher();
void add();
void del();
};



main.cpp

#include "classes.h"

CLIENT::CLIENT():PERSONNE()
{}

void CLIENT::afficher()
{
//nom|prenom|adresse|cp|ville|année entre| année sortis
using namespace std;
cout << prenom << adresse << cp << ville << annee_entree << annee_sortie << endl;
}

void CLIENT::add()
{ }

void CLIENT::del()
{}

/* L'exemple suivant ouvre le fichier "Moche.dat" (le créé s'il n'existe pas), efface son contenu, écrit des données à l'intérieur, puis les récupère dans un tampon, et ensuite ferme le fichier et affiche le contenu, à l'aide de printf() (que je recommande par rapport à cout, car beaucoup plus rapide et léger). */

// Inclut les bibliothèques.

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

// Déclare les fonctions.

void error(void);
void inline pause(void);
void inline ShowContent(LPCSTR lpContent, const DWORD dwLength);

// Définit les fonctions.

int main(void)
{
/* Fonction principale. */

// Variables.

DWORD dwNumberOfBytesRead = NULL; // Nombre d'octets lus.
DWORD dwNumberOfBytesToRead = NULL; // Nombre d'octets à lire.
DWORD dwNumberOfBytesWritten = NULL; // Nombre d'octets écrits.
HANDLE hUglyFile = NULL; // Handle du fichier "Moche.dat".
LPCSTR szUglySentence = "Tout le monde est moche !"; // Contenu à écrire.
LPSTR lpUglyContent = NULL; // Pointeur vers le contenu du fichier.

// Définit le titre de la fenêtre.

if(!(SetConsoleTitle("UglyWorld")))
error();

// Créé le fichier "Moche.dat".

hUglyFile = CreateFile("Moche.dat", (GENERIC_READ | GENERIC_WRITE), FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

if(!(hUglyFile))
error();

// Place le pointeur du fichier au début de celui-ci.

if(SetFilePointer(hUglyFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
error();

// Efface le contenu du fichier.

if(!(SetEndOfFile(hUglyFile)))
error();

// Ecrit le contenu.

if(!(WriteFile(hUglyFile, szUglySentence, (DWORD)strlen(szUglySentence), &dwNumberOfBytesWritten, NULL)))
error();

// Calcule la taille du fichier.

dwNumberOfBytesToRead = GetFileSize(hUglyFile, NULL);

if(dwNumberOfBytesToRead == INVALID_FILE_SIZE)
error();

// Créé le tampon pour recevoir le contenu du fichier.

if(!(lpUglyContent = new char[dwNumberOfBytesToRead]))
error();

for(UINT counter = 0; counter < dwNumberOfBytesToRead; counter++)
*(lpUglyContent + counter) = NULL;

// Place le pointeur du fichier au début de celui-ci.

if(SetFilePointer(hUglyFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
error();

// Lit le contenu.

if(!(ReadFile(hUglyFile, lpUglyContent, dwNumberOfBytesToRead, &dwNumberOfBytesRead, NULL)))
error();

// Ferme le fichier "Moche.dat".

if(!(CloseHandle(hUglyFile)))
error();

// Affiche le contenu.

ShowContent(lpUglyContent, dwNumberOfBytesToRead); // Affiche le contenu.
printf("\n"); // Saute une ligne.
pause(); // Attend qu'une touche soit pressée.

// Supprime le tampon du contenu.

delete lpUglyContent;

return 0;
}

void error()
{
/* Indique qu'une erreur s'est produite. */

printf("****Il y a eu une erreur !****\n"); // Affiche ce message.
printf("\n"); // Saute une ligne.
pause(); // Attend qu'une touche soit pressée.
exit(GetLastError()); // Quitte en retournant le dernier code d'erreur défini.
}

void inline pause(void)
{
/* Effectue une pause. */

printf("Appuyez sur une touche pour quitter...\n"); // Affiche ce message.
getch(); // Attend qu'une touche soit pressée.
}

void inline ShowContent(LPCSTR lpContent, const DWORD dwLength)
{
/* Affiche le contenu du tampon indiqué. */

// Affiche le contenu du tampon indiqué.

for(DWORD dwCurrentPosition = 0; dwCurrentPosition < dwLength; dwCurrentPosition++)
putch(*(lpContent + dwCurrentPosition));

// Termine la ligne.

putch('\n');
}

Je me suis bien éclaté à programmé ça ! Si tu comprend pas tout n'hésite pas !

Je te renvois sur un cours bien expliqué:
http://www.siteduzero.com/tuto-3-18613-1-lecture-et-ecriture-dans-les-fichier(...)