Probleme C++

#include <vector>
#include <map>
#include <set>
#include <string>
#include <cassert>
#include <iostream>

typedef std::string equipe_id_t;

template <typename Tequipe_id>
inline Tequipe_id nobody(){
    return Tequipe_id();
}

// Le parametre template est une classe quelconque (un entier, une chaine...)
// une relation d'ordre < doit etre définie
template <typename Tequipe_id>
class planning_equipe_t{
    protected:
        typedef std::vector<Tequipe_id> matchs_t;   /// Ses matchs programmés
        matchs_t matchs;
        Tequipe_id equipe_id;                       /// Le numero de l'équipe
    public:
        planning_equipe_t(){}

        /// Le constructeur
        planning_equipe_t(const unsigned int & nb_jour,const Tequipe_id & equipe_id0):
            matchs(matchs_t(nb_jour)),
            equipe_id(equipe_id0)
        {
            std::fill(matchs.begin(),matchs.end(),nobody<Tequipe_id>());
        }

        /// Chercher si l'equipe est libre un jour donné
        bool est_libre(const unsigned int & no_jour) const {
            const unsigned int nb_jour = matchs.size();
            assert(no_jour < nb_jour);
            return (matchs[no_jour] == nobody<Tequipe_id>());
        }

        /// Chercher quel jour l'équipe retourne un adversaire
        inline std::pair<typename matchs_t::const_iterator,bool>
        chercher_match(const Tequipe_id & adversaire) const{
            typename std::vector<Tequipe_id>::const_iterator
                mit (matchs.begin()),
                mend(matchs.end());
            for(;mit!=mend;++mit){
                if (*mit == adversaire) return std::make_pair(mit,true);
            }
            return std::make_pair(mend,false);
        }

        /// Est ce que ce match est programmable ?
        bool match_valide(const Tequipe_id & adversaire,const unsigned int & no_jour) const{
            if(adversaire == equipe_id){
                std::cerr << "L'équipe " << equipe_id
                    << " ne peut pas jouer contre elle même !" << std::endl;
                return false;
            }
            if(!est_libre(no_jour)){
                std::cerr << "L'équipe " << equipe_id
                    << " rencontre déjà quelqu'un le jour "
                    << no_jour << std::endl;
                return false;
            }
            std::pair<typename matchs_t::const_iterator,bool> p = chercher_match(adversaire);
            if (p.second){
                std::cerr << "L'équipe " << equipe_id << " rencontre déjà l'equipe "
                    << adversaire << " le jour " << p.second << std::endl;
                return false;
            }
            return true;
        }

        /// Programmer match
        void programmer_match(const Tequipe_id & adversaire,const unsigned int & no_jour){
            assert(match_valide(adversaire,no_jour));
            matchs[no_jour] = adversaire;
        }
};

template <typename Tequipe_id>
class planning_t{
    protected:
        typedef std::map<Tequipe_id,planning_equipe_t<Tequipe_id> > planning_global_t;
        planning_global_t planning_global;

    public:
        /// Construire la grille de rencontre
        planning_t(const std::set<Tequipe_id> & equipes){
            const unsigned int
                nb_equipe = equipes.size(),
                nb_jour = equipes.size();
            typename std::set<Tequipe_id>::const_iterator
                equipes_it (equipes.begin()),
                equipes_end(equipes.end());
            for(;equipes_it!=equipes_end;++equipes_it){
                const Tequipe_id & equipe_id = *equipes_it;
                planning_global[equipe_id] = planning_equipe_t<Tequipe_id>(nb_jour,equipe_id);
            }
        }

        /// Definir une rencontre (si elle est possible)
        bool definir_rencontre(
            const Tequipe_id & x,
            const Tequipe_id & y,
            const unsigned & no_jour
        ){
            assert(planning_global.find(x)!=planning_global.end());
            assert(planning_global.find(y)!=planning_global.end());
            planning_equipe_t<Tequipe_id> &
                planning_x = planning_global[x],
                planning_y = planning_global[y];
            if(planning_x.match_valide(y,no_jour) && planning_y.match_valide(x,no_jour)){
                planning_x.programmer_match(y,no_jour);
                planning_y.programmer_match(x,no_jour);
                std::cout << "Rencontre " << x << " vs " << y << " jour " << no_jour
                    << " programmée" << std::endl;
                return true;
            }
            std::cerr << "La rencontre " << x << " vs " << y << " jour " << no_jour
                << " n'a pas pu être programmée" << std::endl;
            return false;
        }

        /// Recuperer le planning d'une equipe
        inline std::pair<typename planning_global_t::const_iterator,bool>
        recuperer_planning_equipe(const Tequipe_id & equipe_id) const{
            return planning_global.find(equipe_id);
        }
};

int main(){
    // Les equipes du championnat
    std::set<equipe_id_t> equipes;
    {
        equipes.insert("tapir");
        equipes.insert("plop");
        equipes.insert("ccm");
    }

    // Preparer le planning
    planning_t<equipe_id_t> planning(equipes);
    planning.definir_rencontre("tapir","plop",1);
    planning.definir_rencontre("tapir","ccm",1);
    return 0;
}