Discussion :

[LittleWhite]

Bonjour à tous,

J'ai tenté de faire une classe Container, de style banque de données, qui reprends ce que fait un peu std::map. Enfin clairement, c'est juste une classe qui est au dessus de std::map et qui offre moins de fonctionnalités.

Au début, j'avais écris mon template comme ça :

Code :

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

typedef std::map<std::string, const T*> StringBank;

Mais là, je viens d'avoir besoin de la même classe, mais sans que les données soient constantes.

Du coup, la question que je mettais posée lors de la création de ma classe est : est ce qu'il est bon de rajouter const T* alors que l'on pourrait laisser l'utilisateur choisir ?
De plus, l'utilisateur n'est pas obliger de savoir que cela va être const, puis que cela sera un pointeur, du coup, n'est ce pas dangereux de lui cacher de telle chose (un peu comme certain typedef de structure que je voyais en cours, qui cacher les pointeurs ...).

Quel est votre avis ?

[Bousk]

Bonjour,

dans l'idéal en tant qu'utilisateur j'apprécierais plutôt un 3° paramètre template de type bool que je définis à true si le container contient des données constantes, à false sinon.

Après je n'ai pas d'idée quant à l'implémentation et réalisation de ceci, mais dans l'idée le concept me plait.

[3DArchi]

Salut,
Ca dépend si la constance relève de l'implémentation de ton conteneur ou d'une utilisation de celui-ci. Dans le premier cas, ça peut passer par une séparation implémentation/interface et cela dépend de comment la décision est prise. Dans le second cas, ben c'est l'utilisateur qui choisit conteneur<const T> ou conteneur<T>.
Je n'ai pas compris ton problème de pointeur. Il existe des typedef sur des pointeurs pour faire des handle qui 'obscurcissent' l'objet sous-jacents. Ce n'est pas forcément choquant mais on peut se demander pourquoi ce besoin.

[LittleWhite]

Bonjour,

dans l'idéal en tant qu'utilisateur j'apprécierais plutôt un 3° paramètre template de type bool que je définis à true si le container contient des données constantes, à false sinon.

Après je n'ai pas d'idée quant à l'implémentation et réalisation de ceci, mais dans l'idée le concept me plait.

Je trouve cela lourd personnellement ... et si je voulais un pointeur, il me faut un autre boolean, pour le spécifier

Pour l'histoire des pointeurs, disons que par exemple, si on passe un type, l'utilisateur ne sait pas forcément si c'est un pointeur. S'il ne sait pas, il peut penser que c'est mieux de passer un pointeur.
(Pour le coup des typedef sur les structures, oubliez ce cas là, c'est pas grave)

[koala01]

Salut,

En fait, tu peux très bien créer deux politique qui définissent un typedef "ptr_type" (par exemple), l'une comme étant un pointeur constant, l'autre comme ne l'étant pas.

Elles pourraient ressembler à quelque chose comme

Code :

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

1
2
3
4
5
6
7
8
9
10
template <typename T>
struct constPtr_policy
{
    typedef const T* ptr_type;
};
template <typename T>
struct noConstPtr_policy
{
    typedef T* ptr_type;
};

Tu rajouterais effectivement un parametre template (template) qui permet de définir la poliltique en question, en lui donnant, éventuellement, une valeur par défaut.

Tu pourrais dés lors définir le typedef ptr_type comme étant... du type ptr_type issu de la politique fournie, qui te servirait pour définir le type de la valeur, sous 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
template <typename T, template <typename> class policy  = constPtr_policy  >
class MyClass
{
    typedef std::map<std::string, typename policy<T>::ptr_type > StringBank;
    public:
    typedef typename policy<T>::ptr_type ptr_type;
        ptr_type get(std::string const & name){return *(bank_.find(name).second); }
        /* ... */
    private:
       StringBank bank_;
};

De cette manière, tu n'as plus besoin de t'inquiéter de la constance de ton pointeur (hormis pour déterminer si tu peux ou invoquer une fonction non constante )

[EDIT]
Tu pourrais dés lors utiliser cette classe sous 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
/* soit la class Test proche de */
class Test
{
    public:
        void foo() const{}
        void bar() {}
};
 
int main()
{
    MyClass<Test> testConst; // version constante par défaut
    myClass<Test,noConst_policy> testNoConst; // version non constante
 
 
    testNoConst.get("unnom")->foo() // ok : on est sur un  const T *
    testNoConst.get("unnom")->bar() // OK : on est sur un cosnt T * et bar est non const
 
    testNoConst.get("unnom")->foo() // ok : on est sur un  T *
    testNoConst.get("unnom")->bar() // ok : on est sur un T *
}

[germinolegrand]

La librairie standard C++11 (<type_traits>) fournit tous les outils nécessaires pour cela.
Il suffit de rajouter un/des paramètre(s) template bool (pourquoi pas avec une valeur par défaut) puis d'agir en conséquence.

un exemple :

Code :

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

1
2
3
4
5
6
 
template <class T, bool constptr = true>
struct A
{
    typedef std::map<std::string, std::conditional<constptr, const T, T>::type*> StringBank;
};