Discussion :

[shirohige]

Bonjour,
Je souhaite réaliser un jeux vidéo. Le jeux vidéo lira une mappe et fera apparaître des énemis en fonction de cette mappe. Par exemple si à la case [y][x] il y à le caractère X ça va créer un monstre X si c'est un B ça va créer un monstre B. J'ajouterait ensuite ce monstre à ma liste.
Le problème est que si il y a plusieurs monstres, une dizaine par exemple, je n'ai pas envie de faire : if (c'est x) alors tu me créer le monstre x dix fois (un pour chaque lettre).
Je voudrais savoir comment vous feriez.
J'avais pensé à faire une map avec en key la lettre et en value le pointeur sur ma class monstre X.
Voilà ma question.
Merci pour vos réponses.
Edit: La question la plus importantes si je fait avec map, peut-on faire par exemple si j'ai une map qui se nomme toto:
Monstre Mx = new toto[x];

[koala01]

Salut,

Oui, la map <clé, Monster*> est une possibilité de travailler, mais non, pas de la manière dont tu semble vouloir t'y prendre.

D'abord, il faut savoir que l'opérateur [] a un comportement très particulier au niveau de std::map : Si la clé indiquée n'existe pas, il créera la clé en question en laissant la valeur non initialisée.

Comme la valeur est un pointeur, le pointeur correspondant à la clé sera NULL (nullptr en C++11).

Utiliser l'opérateur [] pour accéder aux éléments de ta map serait donc une idée particulièrement mauvaise car il est tellement facile d'oublier d'insérer une clé (ou même simplement d'écrire X au lieu de C) que cela te promettrait de longues heures de déboggage à t'arracher les cheveux.

Le meilleur moyen est encore d'utiliser les itérateurs et la fonction find, sous une forme proche de (C++11 inside)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
auto const & it = laMap.find(value);
if(it != laMap.end()){
    /* l'élément existe, on peut travailler avec ici */
}/* else{
    l'élément n'existe pas, il y a peut etre quelque chose à faire ici
} */

Ensuite, il faut savoir que new s'attend à être suivi d'un identifiant de type.

Or laMap['c'] renverra... un pointeur. Et qui plus est, un pointeur de type Monster (le type de base).

Dans le meilleur des cas, new laMap['c'] te permettra donc de créer un nouvel objet de type Monster et non un objet de type MonsterC.

Pour résoudre ce problème, il faut recourir au concept d'élément clonable.

L'idée est d'exposer un comportement polymorphe (typiquement une fonction clone() ) qui renvoie un pointeur du type de base (ici Monster) pointant vers un objet du type réellement attendu.

En gros, cela prendrait une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Monster : private NonCopyable /* (*) */{
    public:
        virtual ~Monster(){}
        /* aucune implémentation possible pour le monstre de base */
        virtual Monster * clone() const = 0;
};
class MonsterA : public Monster{
    public:
        Monster * clone() const{return new MonsterA ;}
};
class MonsterB : public Monster{
    public:
        Monster * clone() const{return new MonsterB ;}
};
class MonsterC : public Monster{
    public:
        Monster * clone() const{return new MonsterC ;}
};
class MonsterD : public Monster{
    public:
        Monster * clone() const{return new MonsterD ;}
};

(*) Typiquement, les classes qui interviennent dans une hiérarchie de classe ont sémantique d'entité.

Ce sont des classes qui ne sont pas sensées être copiable (ni affectable) afin d'assurer "l'intégrité référentielle".

Si tu crées une classe proche de (c++11 inside)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
NonCopyable{
    public:
        NonCopyable(NonCopyable const &) = delete;
        NonCopyable & operator=(NonCopyable const &) = delete;
    protected:
        NonCopyable(){}
        ~NonCopyable(){}
};

tu peux utiliser l'héritage privé pour chaque classe non copiable et non affectable que tu envisageras

Au final, la logique que tu devrais suivre serait donc proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
auto const & it = laMap.find(value);
if(it != laMap.end()){
    Monster * temp = it.second->clone();
    /* tu enregistre temp où c'est nécessaire -) */
}/* else{
    l'élément n'existe pas, il y a peut etre quelque chose à faire ici
} */

[shirohige]

Merci pour la réponse détaillée. J'ai des questions suite à votre message.
Vous avez dit:

Or laMap['c'] renverra... un pointeur. Et qui plus est, un pointeur de type Monster (le type de base).

Ce que je voulais faire c'était par exemple faire:
toto['X'] = MonsterA;
toto['Y'] = MonsterB;
.... .
Donc en fesant Monster *lol = new toto['X'];
Je fait un new sur MonsterA;
Donc du coup j'aurais du récupérer un MonsterA ou MonsterB et non pas un Monster tout court, non ?
Et aussi:

if(it != laMap.end())

M'évitera cette erreur:

D'abord, il faut savoir que l'opérateur [] a un comportement très particulier au niveau de std::map : Si la clé indiquée n'existe pas, il créera la clé en question en laissant la valeur non initialisée.

[GR3lh442kR]

Pourquoi ne pas faire une fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Monstre* GenererMonstre(std::string type){
	if(type == "A") return new MonstreA();
	else if(type == "B") return new MonstreB();
	else if(type == "C") return new MonstreC();
	else if(type == "D") return new MonstreD();
	else return NULL;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

marvar = GenererMonstre("A");

de toutes façon avec ta technique tu dois forcement écrire une ligne pour chaque type de monstre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
monstres["A"]= MonstreA;
monstres["B"]= MonstreB;
monstres["C"]= MonstreC;
monstres["D"]= MonstreD;

@koala01 : du coup il faut déjà avoir au moins une instance de chaque type avec ta technique, c'est pas l’idéal d’après moi

[jblecanard]

Salut

D'abord, il faut savoir que l'opérateur [] a un comportement très particulier au niveau de std::map : Si la clé indiquée n'existe pas, il créera la clé en question en laissant la valeur non initialisée.

Comme la valeur est un pointeur, le pointeur correspondant à la clé sera NULL (nullptr en C++11).

Juste un petit détail, j'ergote : ce n'est pas exact de dire que la valeur n'est pas initialisée. Si elle ne l'était pas, un pointeur dans une paire <clé, valeur> qui vient d'être créée par [] ne serait pas nul. Il est bien initialisé à nullptr. De même, les nombres sont initialisés à 0.

Bien sûr, cela ne change rien au reste de l'explication !

[Iradrille]

Ce que je voulais faire c'était par exemple faire:
toto['X'] = MonsterA;
toto['Y'] = MonsterB;
.... .
Donc en fesant Monster *lol = new toto['X'];
Je fait un new sur MonsterA;
Donc du coup j'aurais du récupérer un MonsterA ou MonsterB et non pas un Monster tout court, non ?

Tu ne peux pas faire une map de types.
Koala01 te propose de stocker des monstres différents (donc des instances de classes, des objets) dans la map, puis de les copier quand tu crée un monstres.

Tu récupère un Monstre * en faisant un find. clone est une fonction virtuelle, c'est l'implémentation de la classe fille correspondante qui sera appelée.

A chaque coup qu'un sujet comme ça ressort, j'ai la même réaction : l'héritage au niveau de Monstre est inutile.
Mais que tu partes sur de l'héritage ou pas, la proposition de koala01 est bonne et marchera.

[koala01]

@koala01 : du coup il faut déjà avoir au moins une instance de chaque type avec ta technique, c'est pas l’idéal d’après moi

Et pourtant :

• Elle répond strictement à la question posée par shirohige
• Elle correspond "trait pour trait" en interne à une implémentation "classique" de la fabrique.

L'idée est de s'assurer d'avoir un "modèle" de chaque monstre dans la map, et de rechercher le monstre à construire afin de le cloner à la demande

Nous devrons, effectivement, faire en sorte d'avoir un élément de chaque type dérivé, mais, si l'on applique le patron factory jusqu'au bout, cela devient quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Factory{
    public:
        /*static */ void register(KEY key, Monster const& monster){
            if(laMap.find(key)!=laMap.end()){
                laMap.insert(std::make_pair(key, monster.clone());
            }
        }
       Monster * create(KEY key){
            auto const & it =laMap.find(key);
            if(it!=laMap.end()){
               return it.second->clone()
            }
          return nullptr;
        }
    private:
         static std::map<KEY, Monster *> laMap;
};

[GR3lh442kR]

Je ne connaissait pas cette implémentation de la factory avec clone
J'utilise la même technique que celle proposée par Flob90 dans ce post http://www.developpez.net/forums/d11...ttern-factory/