Je ne connais manager_t...
Encore heureux c'est moi qui te suggère un nom plus cohérent avec ce que fait la classe. Ici tu ne décris pas une carte, tu décris un objet qui gère un jeu de carte.
Ensuite bien de nommer ses types avec un suffixe distinctif (genre "_t"). En particulier, ça permet d'écrire "plop_t plop". On peut ainsi déduire le type à partir du nom de la variable. C'est mieux que de mettre un nom bidon (comme "plop p"). Enfin ça c'est un conseil de programmation.
Ensuite je maintiens que tu n'as aucune vraie bonne raison de faire des statics ici. Enfin tu peux le faire mais c'est une mauvaise structure de code je trouve. Je te propose d'utiliser plutôt une std::map pour gérer tes cartes.
#include <map>
#include <set>
#include <string>
#include <ostream>
#include <iostream>
typedef std::string couleur_t;
typedef std::string rang_t;
typedef std::set<couleur_t> couleurs_t;
typedef std::set<rang_t> rangs_t;
class carte_t{
protected:
rang_t rang;
couleur_t couleur;
public:
carte_t(const rang_t & rang0,const couleur_t & couleur0):
rang(rang0),couleur(couleur0)
{}
inline rang_t get_rang() const{
return rang;
}
inline couleur_t get_couleur() const{
return couleur;
}
};
inline bool operator <(const carte_t & x,const carte_t & y){
return x.get_rang() < y.get_rang() ||
(x.get_rang() == y.get_rang() && x.get_couleur() < y.get_couleur());
}
inline bool operator==(const carte_t & x,const carte_t & y){
return x.get_rang() == y.get_rang() && x.get_couleur() == y.get_couleur();
}
inline std::ostream & operator<<(std::ostream & out,const carte_t & c){
out << c.get_rang() << " de " << c.get_couleur();
return out;
}
class manager_t{
public:
typedef std::map<carte_t,bool> etat_t;
protected:
etat_t etat;
couleurs_t couleurs;
rangs_t rangs;
public:
manager_t(
const couleurs_t & couleurs0,
const rangs_t & rangs0
):
couleurs(couleurs0),
rangs(rangs0)
{
init_manager();
}
inline void init_manager(){
std::set<couleur_t>::const_iterator
couleurs_it (couleurs.begin()),
couleurs_end(couleurs.end());
for(;couleurs_it!=couleurs_end;++couleurs_it){
std::set<rang_t>::const_iterator
rangs_it (rangs.begin()),
rangs_end(rangs.end());
for(;rangs_it!=rangs_end;++rangs_it){
carte_t c(*rangs_it,*couleurs_it);
etat[c] = false;
}
}
}
inline void set_etat(const carte_t & c,bool state) {
etat_t::iterator fit(etat.find(c));
if (fit == etat.end()) throw; // cette carte n'existe pas
etat[c] = state;
}
inline bool get_etat(const carte_t & c) const{
etat_t::const_iterator fit(etat.find(c));
if (fit != etat.end()) throw; // cette carte n'existe pas
return fit->second;
}
inline const couleurs_t & get_couleurs() const{
return couleurs;
}
inline const rangs_t & get_rangs() const{
return rangs;
}
inline const etat_t & get_etat() const{
return etat;
}
};
inline std::ostream & operator <<(std::ostream & out,const manager_t & m){
const manager_t::etat_t & etat = m.get_etat();
manager_t::etat_t::const_iterator
etat_it (etat.begin()),
etat_end(etat.end());
for(;etat_it!=etat_end;++etat_it){
out << etat_it->first << '\t' << (etat_it->second ? "true" : "false") << std::endl;
}
return out;
}
int main(){
couleurs_t couleurs;
couleurs.insert("pique");
couleurs.insert("coeur");
couleurs.insert("carreau");
couleurs.insert("trèfle");
rangs_t rangs;
rangs.insert("as");
rangs.insert("2");
rangs.insert("3");
//...
manager_t m(couleurs,rangs);
std::cout << m;
std::cout << "************" << std::endl;
m.set_etat(carte_t("as","coeur"),true);
std::cout << m;
return 0;
}
ce qui donne :
2 de carreau false
2 de coeur false
2 de pique false
2 de trèfle false
3 de carreau false
3 de coeur false
3 de pique false
3 de trèfle false
as de carreau false
as de coeur false
as de pique false
as de trèfle false
************
2 de carreau false
2 de coeur false
2 de pique false
2 de trèfle false
3 de carreau false
3 de coeur false
3 de pique false
3 de trèfle false
as de carreau false
as de coeur true
as de pique false
as de trèfle false
L'avantage de ce code c'est que tu peux facilement créer un jeu de tarot, de 32 cartes, de 52 cartes, etc...
Bonne chance
C affecter un tableau a un tableau
