Discussion :

[jblecanard]

Bonjour

Un petit topic de conception comme on les aime. J'ai besoin de créer des objets qui accèderont à une map pour mettre en correspondance une chaîne avec la valeur d'un enum. Cette map est commune à tous les objets.

Ma technique habituelle consiste à créer une factory qui portera cette map et en donnera une référence aux objets créés. Cela permet d'éviter de trimbaler un singleton et éventuellement de moduler la map pour créer des "groupes d'objets" au comportement différent.Mais il y a un gros défaut: c'est que la map créée par la factory voit sont cycle de vie lié à celui des objets créés, et ceux ci ne fonctionnent plus si elle est détruite (à la destruction de la factory par exemple).

Une solution serait de dire que la propriété de la map est partagée entre les objets, et donc, je n'ai qu'à la mettre dans un share_ptr. Là, on en arrive aux limites de mon contexte:
- J'ai pas shared_ptr (pas de boost ni C++11, sinon je me ferais plez avec des hash map compile time à base de const_expr)
- Je voudrais que le code reste au plus simple car mon besoin est relativement simple, donc pas question de réimplémenter un shared_ptr maison pour ça ni de faire un truc compliqué.

Comment feriez-vous ?

[Kaamui]

ça vaut ce que ça vaut, mais pour le besoin, je laisserai tomber l'idée d'une factory, et je ferai juste un namespace avec ma map et quelques méthode spécifiques à mes besoins.

Code :

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

1
2
3
4
5
6
7
8
9
 
namespace ma_map
{
   std::map<string, monTypeEnum> m_map;
 
   void ajouter(string key, monTypeEnum value);
 
   //etc
}

ou une classe statique...
c'est vrai que pour un truc aussi simple que "je veux une map commune à tous mes objets pour mapper une string avec un enum", il y a plus simple.
Un exemple d'utilisation :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
#ifndef PRESIDENT_HPP
#define PRESIDENT_HPP
 
//headers standards
#include <vector>
#include <algorithm>
#include <iostream>
#include <random>
#include <ctime>
 
//headers personnels
#include "Carte.hpp"
#include "Constantes.hpp"
#include "Joueur.hpp"
 
namespace Jeu
{
    //variables
    std::vector<Carte> Paquet;
    std::vector<Carte> Defausse;
 
    //Melanger les cartes
    void Melanger()
    {
        //ne fonctionne pas... à analyser
        //std::random_device rd;
        //std::default_random_engine re(rd());
        srand(time(NULL));
        std::random_shuffle(Paquet.begin(), Paquet.end());
    }   
 
    //initialiser le jeu a un jeu de 32 cartes
    void Init_32_cartes()
    {
        if(!Paquet.empty()) Paquet.clear();
 
        for(auto couleur = Carte::Couleur::Trefle; couleur < Carte::Couleur::Sans; couleur++){
            for(Carte::Valeur valeur = Carte::Valeur::Sept; valeur < Carte::Valeur::Joker; valeur++)
                Paquet.push_back(Carte(valeur, couleur));
        }
    }
 
    //initialiser le jeu a un jeu de 54 cartes
    void Init_54_cartes()
    {
        if(!Paquet.empty()) Paquet.clear();
 
        for(auto couleur = Carte::Couleur::Trefle; couleur < Carte::Couleur::Sans; couleur++){
            for(auto valeur = Carte::Valeur::Trois; valeur < Carte::Valeur::Joker; valeur++)
                Paquet.push_back(Carte(valeur, couleur));
        }
 
        /* Ajout des jokers */
        Carte joker(Carte::Valeur::Joker, Carte::Couleur::Sans);
        Paquet.push_back(joker);
        Paquet.push_back(joker);
 
    }
 
    //Distribuer les cartes a tous les joueurs presents
    void Distribuer()
    {
        for (auto j : Joueurs::Joueur::Groupe)
            j->main.clear();
 
 
        using namespace Joueurs;
 
        unsigned int i=0;
        int count =0;
        for(auto carte : Paquet){
            count++;
            Joueur::Groupe.at(i)->addCarte(carte);
            if(++i == Joueur::Groupe.size()) i=0;
        }
        Paquet.clear();
    }
}
 
#endif

C++11 ou pas, il y a moyen de faire la même chose en C++03

[jblecanard]

Pour ma part je pense que je vais torcher avec une méthode statique de mise en correspondance qui contient une map statique remplie au premier usage.

Mais je suis curieux de voir comment les autres développeurs abordent ce genre de mini-problèmes.

[white_tentacle]

Tu es sûr que tu n’as pas shared_ptr ? Pas même dans tr1 ? Parce que tu peux utiliser des weak_ptr vers la map dans tes objets. Ça ne règle pas ton problème de durée de vie, mais ça te permet de gérer tranquillement le cas où la map n’existe plus et que tu cherches à l’utiliser dans tes objets (note : ça ressemble à une erreur de programmation, la factory devrait de fait avoir une durée de vie plus longue que les objets qu’elle crée si elle est aussi en charge de la gestion de la ressource).

[jblecanard]

(note : ça ressemble à une erreur de programmation, la factory devrait de fait avoir une durée de vie plus longue que les objets qu’elle crée si elle est aussi en charge de la gestion de la ressource).

Oui c'est une erreur, c'est en la découvrant que j'ai écrit le topic. Et oui je suis sûr de ne pas avoir le tr1 ^^.

[Kaamui]

j'ai mis longtemps à réagir, mais je voulais ajouter qu'il est préférable d'utiliser les namespaces dans ce genre de cas. Comme je ne retrouvais pas l'article où je l'ai lu, je n'ai rien dit mais voilà qui est chose faite :

ici