Gros Blocage pour prog C !

#include <iostream>
#include <map>
#include <set>

typedef enum{AJOUTER_CLIENT,RETIRER_CLIENT,AFFICHER_CLIENT,ACHAT,PAIEMENT,RECHERCHER,TOTAL,QUITTER} registre_t;

void afficherRegistre(){
    std::cout << std::endl << " Voici le menu du registre du solde des clients de l'entreprise" << std::endl
        << "=========================================================" << std::endl
        << AJOUTER_CLIENT   << "- Ajouter un nouveau client (avec son solde)" << std::endl
        << RETIRER_CLIENT   << "- Retirer un client" << std::endl
        << AFFICHER_CLIENT  << "- Afficher la liste des clients par ordre decroissant de solde" << std::endl
        << ACHAT            << "- Effectuer un achat (ajouter un certain montant au solde)" << std::endl
        << PAIEMENT         << "- Effectuer un paiement (diminuer le solde de certain montant)" << std::endl
        << RECHERCHER       << "- Rechercher un client par numero" << std::endl
        << TOTAL            << "- Afficher le total des soldes" << std::endl
        << QUITTER          << "- Quitter" << std::endl
        << "=========================================================" << std::endl
        << "Quelle est l'option que vous voulez choisir ? ";
}

class compte_t{
    public:
        typedef unsigned id_t;
        typedef double solde_t;
        typedef std::map<id_t,solde_t> map_id_solde_t;
        typedef std::map<solde_t,std::set<id_t> > map_solde_ids_t;
    protected:
        map_id_solde_t map_id_solde;
        map_solde_ids_t map_solde_ids;
    public:

        compte_t(){}

        bool is_valid_id(const id_t & id){
            return id > 10000 && id < 99999;
        }

        bool is_valid_solde(const solde_t & solde){
            return solde >= 0;
        }

        bool ajouter_client(const id_t & id,const solde_t & solde){
            if(!is_valid_id(id)){
                std::cerr << "identifiant client invalide [" << id << ']' << std::endl;
                return false;
            }
            if(map_id_solde.find(id) != map_id_solde.end()){
                std::cerr << "identifiant client déjà utilisé !" << std::endl;
                return false;
            }
            if(!is_valid_solde(solde)){
                std::cerr << "solde invalide [" << solde << ']' << std::endl;
                return false;
            }
            map_id_solde[id] = solde;
            map_solde_ids[solde].insert(id);
            return true;
        }

        bool supprimer_client(const id_t & id){
            map_id_solde_t::iterator fit = map_id_solde.find(id);
            if(fit == map_id_solde.end()){
                std::cerr << "le client [" << id << "] n'existe pas" << std::endl;
                return false;
            }
            const solde_t & solde = fit->second;
            map_solde_ids[solde].erase(id);
            map_id_solde.erase(fit);
            return true;
        }

        void afficher_client_ordre_decroissant() const{
            map_solde_ids_t::const_reverse_iterator
                mit (map_solde_ids.rbegin()),
                mend(map_solde_ids.rend());
            for(;mit!=mend;++mit){
                const solde_t & solde = mit->first;
                const std::set<id_t> & ids = mit->second;
                std::set<id_t>::const_iterator
                    sit (ids.begin()),
                    send(ids.end());
                for(;sit!=send;++sit){
                    const id_t & id = *sit;
                    std::cout << "Id " << id << "\tSolde " << solde << std::endl;
                }
            }
        }

        // etc...
};


int main(){
    compte_t compte;
    unsigned reponse;
    for(;;){
        afficherRegistre();
        std::cin >> reponse;

        if(reponse == AJOUTER_CLIENT){
            compte_t::id_t id;
            compte_t::solde_t solde;
            do{
                std::cout << "numero client ? ";
                std::cin >> id;
                std::cout << "solde ? ";
                std::cin >> solde;
            }while(!compte.ajouter_client(id,solde));
        }else if (reponse == RETIRER_CLIENT){
            compte_t::id_t id;
            std::cout << "numero client ? ";
            std::cin >> id;
            compte.supprimer_client(id);
        }else if(reponse == AFFICHER_CLIENT){
            compte.afficher_client_ordre_decroissant();
        //} else if (....){
        }else if(reponse == QUITTER){
            std::cout << "Au plaisir et a bientot !\n" << std::endl;
            break;
        }else{
            std::cerr << "Saisie invalide !" << std::endl;
        }
    }
    return 0;
}