Aide pour débuter en C++

int x;
std::cout << "saisir un entier" << std::endl;
std::cin >> x;

struct plop_t{
  int x,y,z;
  plop_t(int x0,int y0,int z0):x(x0),y(y0),z(z0){}
};

// Les méthodes étant très courtes, je les mets inline ce qui me 
// permet de les implémenter directement dans les headers. 
// Rien ne t'empêche de mettre juste les prototypes et de
// les implémenter dans le .cpp qui correspond.

// Si tu sépares les fichiers, décommentes les #includes

// Début sep.hpp ----

// Le séparateur
inline const char *get_sep(){
	return " | ";
}

// Fin sep.hpp

// Début adresse.hpp ----
#include <string>
#include <ostream>
//#include "sep.hpp"

typedef std::string lieu_t;
typedef unsigned cp_t;
typedef std::string ville_t;

struct adresse_t{
	// Attributs
	lieu_t lieu;
	cp_t cp;
	ville_t ville;

	// Constructeur
	adresse_t(
		const lieu_t & _add = "",
		const cp_t & _cp = 0,
		const ville_t & _ville = ""
	):
		lieu(_add),
		cp(_cp),
		ville(_ville)
	{}

	// Destructeur sous-entendu (il ne fait rien)
};

// Opérateur de comparaison
inline bool operator<(const adresse_t & x,const adresse_t & y){
	if(x.lieu < y.lieu) return true;
	if(x.lieu > y.lieu) return false;

	if(x.cp < y.cp) return true;
	if(x.cp > y.cp) return false;

	if(x.ville < y.ville) return true;
	if(x.ville > y.ville) return false;
	return false;
}

// Opérateur d'affichage
inline std::ostream & operator << (std::ostream & out,const adresse_t & a){
	const char *sep = get_sep();
	out << a.lieu << sep << a.cp << sep << a.ville;
	return out;
}

// Fin adresse.hpp ----


// Début personne.hpp ----
#include <string>
#include <ostream>
//#include "adresse.hpp"
//#include "sep.hpp"

typedef std::string nom_t;
typedef std::string prenom_t;

class personne_t{
	protected:
		nom_t nom;
		prenom_t prenom;
		adresse_t adresse;
	public:
		// Constructeur
		personne_t(
			const nom_t & _nom = "", 
			const prenom_t & _prenom = "",
			const adresse_t & _adresse = adresse_t()
		):
			nom(_nom),
			prenom(_prenom),
			adresse(_adresse)
		{}

		
		// Accesseurs
		inline const nom_t & get_nom() const{
			return nom;
		}

		inline const prenom_t & get_prenom() const{
			return prenom;
		}

		inline const adresse_t & get_adresse() const{
			return adresse;
		}
}; 

// L'opérateur d'affichage
inline std::ostream & operator << (std::ostream & out,const personne_t & p){
	const std::string sep = get_sep();
	out << p.get_nom() << sep << p.get_prenom() << sep << p.get_adresse();
	return out;
}

// Une personne est identifiée par son nom, prénom, adresse
inline bool operator<(const personne_t & x,const personne_t & y){
	if (x.get_nom() < y.get_nom()) return true;
	if (x.get_nom() > y.get_nom()) return false;

	if (x.get_prenom() < y.get_prenom()) return true;
	if (x.get_prenom() > y.get_prenom()) return false;

	if (x.get_adresse() < y.get_adresse()) return true;
	if (y.get_adresse() < x.get_adresse()) return false;
	return false;
}

// Fin personne.hpp ----

// Début client.hpp ----
#include <string>
#include <ostream>
//#include "personne.hpp"
//#include "sep.hpp"

typedef unsigned annee_t;

class client_t : public personne_t{
	protected:
		annee_t annee_entree;
		annee_t annee_sortie;

	public:
		client_t(){}

		client_t(
			const nom_t & _nom, 
			const prenom_t & _prenom,
			const lieu_t & _adresse,
			const cp_t & _cp,
			const ville_t & _ville,
			const annee_t & _entree,
		   	const annee_t & _sortie
		):
			personne_t(_nom,_prenom,adresse_t(_adresse,_cp,_ville)),
			annee_entree(_entree),
			annee_sortie(_sortie)
		{}

		inline const unsigned & get_annee_entree() const{
			return annee_entree;
		}

		inline const unsigned & get_annee_sortie() const{
			return annee_sortie;
		}
};

// L'opérateur d'affichage
inline std::ostream & operator << (std::ostream & out,const client_t & p){
	const adresse_t & a = p.get_adresse();
	const std::string sep = " | ";
	out << p.get_nom() << sep << p.get_prenom() << sep << a << sep 
		<< p.get_annee_entree() << sep << p.get_annee_sortie();
	return out;
}

// Fin client.hpp ----

// Début base_client.hpp ----

//#include "client.hpp"
#include <map>
#include <set>

class base_client_t{
	public:
		typedef std::map<client_t,client_t *> clients_t;

		typedef std::map<nom_t,std::set<client_t *> > map_nom_clients_t;
		typedef std::map<prenom_t,std::set<client_t *> > map_prenom_clients_t;
		// ...
		
	protected:
		// Cette map stocke les clients
		clients_t clients;
		// Ces maps permettent de chercher un client juste sur son nom/prénom...
		map_nom_clients_t map_nom_clients;
		map_prenom_clients_t map_prenom_clients;

	public:
		base_client_t(){}

		// Détruit les clients stockés en base
		~base_client_t(){
			clients_t::const_iterator
				cit(clients.begin()),
				cend(clients.end());
			for(;cit!=cend;++cit) delete cit->second;
		}

		// Récupère la base de clients
		inline const clients_t & get_clients() const{
			return clients;
		}

		// Récupère la map clients avec un nom donné
		inline const std::set<client_t *> & chercher_nom(const nom_t & nom) const{
			map_nom_clients_t::const_iterator fit(map_nom_clients.find(nom));
			if (fit == map_nom_clients.end()) throw; // pas de client avec ce nom
			return fit->second;
		}

		// Insère un client en base
		inline bool add_client(const client_t & c){
			std::size_t nb_client = clients.size();
			client_t * pc = new client_t(c);
			clients[c] = pc;
			if (clients.size() > nb_client){ // nouveau client
				map_nom_clients[c.get_nom()].insert(pc);
				map_prenom_clients[c.get_prenom()].insert(pc);
				return true;
			}
			return false;
		}

		// Attention les fonctions de suppressions / modifications doivent supprimer
		// toutes les maps !
		inline bool del_client(const clients_t::iterator & fit){
			if(fit == clients.end()) return false; // iterator invalide
			const client_t & c = *(fit->second);
			map_nom_clients.erase(c.get_nom());
			map_prenom_clients.erase(c.get_prenom());
			clients.erase(fit);
			return true;
		}
		
		inline bool del_client(const client_t & c){
			clients_t::iterator fit(clients.find(c));
			if(fit == clients.end()) return false; // pas trouvé
			return del_client(fit);
		}
};

// Opérateur d'affichage
inline std::ostream & operator << (std::ostream & out,const base_client_t & base_client){
	typedef base_client_t::clients_t clients_t;
	const clients_t & clients = base_client.get_clients();
	clients_t::const_iterator
		cit (clients.begin()),
		cend(clients.end());
	for(;cit!=cend;++cit) out << *(cit->second) << std::endl;
	return out;
}


// Fin base_client.hpp ----

// Début main.cpp

#include <set>
#include <iostream>
//#include "base_client.hpp"
#include <fstream>

int main(){
	base_client_t base_client;
	// Initialisation de la base
	const client_t c1(
		"nom","prenom","rue",
		75000,"ville",1900,2000
	);
	const client_t c2(
		"dupond","jean","69 rue de la gaité",
		75014,"paris",1969,2008
	);
	const client_t c3(
		"dupond","pierre","1 rue de quai",
		69699,"groville",1969,2008
	);

	base_client.add_client(c1);
	base_client.add_client(c2);
	base_client.add_client(c3);
	base_client.add_client(c3); // doublon -> pas inséré

	// Ecrire la base
	const char *filename = "plop.txt";
	std::ofstream ofs(filename);
	if (!ofs){
		std::cerr << "impossible d'ouvrir " << filename << std::endl;
		return 1;
	}
	ofs << base_client;
	ofs.close();
	
	// Ecrire la base
	std::cout << base_client;

	// Faire une requête
	std::cout << "chercher les dupond..." << std::endl;
	try{
		const std::set<client_t *> & clients_dupond = base_client.chercher_nom("dupond");
		std::set<client_t *>::const_iterator 
			sit (clients_dupond.begin()),
			send(clients_dupond.end());
		for(;sit!=send;++sit) std::cout << **sit << std::endl;
	}catch(...){
		std::cout << "client non trouvé" << std::endl;
	}

	std::cout << "suppression du client c1 : " << c1 << std::endl;
	base_client.del_client(c1);
	std::cout << base_client;
	return 0;
}

dupond | jean | 69 rue de la gaité | 75014 | paris | 1969 | 2008
dupond | pierre | 1 rue de quai | 69699 | groville | 1969 | 2008
nom | prenom | rue | 75000 | ville | 1900 | 2000
chercher les dupond...
dupond | jean | 69 rue de la gaité | 75014 | paris | 1969 | 2008
dupond | pierre | 1 rue de quai | 69699 | groville | 1969 | 2008
suppression du client c1 : nom | prenom | rue | 75000 | ville | 1900 | 2000
dupond | jean | 69 rue de la gaité | 75014 | paris | 1969 | 2008
dupond | pierre | 1 rue de quai | 69699 | groville | 1969 | 2008

void CLIENT::set()
{
printf("Nom ? ");
scanf("%s",nom);
printf("Prénom ? ");
scanf("%s",prenom);
//getchar();
printf("Adresse ? ");
scanf("%s",adresse);
getchar();
printf("Code postal ? ");
scanf("%s",cp);
printf("Ville ? ");
scanf("%s",ville);
printf("Année d'entrée dans l'entreprise ? ");
scanf("%u",annee_enree);
printf("Année de sortie de l'entreprise ? ");
scanf("%u",annee_sorti);
}