Discussion :

[Florian Goo]

Bonjour à tous,

J'ai un doute sur une implémentation. Quel est le meilleur moyen de retourner un conteneur de pointeurs d'objets de façon à ce que les objets ne puissent pas être accédés de façon non-const ?

Soit une classe « panier » contenant une liste d'objets de type « pomme ».
De façon naïve, on commence par écrire le code suivant :

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
 
#include <list>
 
class pomme
{
    public:
        void
        set_taille(int){/*...*/};
 
    //...
};
 
class panier
{
    public:
        //...
 
        const std::list<pomme*>&
        get_pommes() const
        {
            return pommes_;
        }
 
    private:
        std::list<pomme*> pommes_;
};

Or, de cette façon, rien ne nous empêche d'appeler une méthode non-const d'un des objets pomme du conteneur (ce qui est tout à fait logique, mais totalement indésirable) :

Code :

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

1
2
3
4
5
6
7
 
void
foo(const panier& un_panier)
{
    const std::list<pomme*>& pommes = un_panier.get_pommes();
    if(!pommes.empty()) pommes.back()->set_taille(3);
}

Quelle est la bonne façon de faire dans un tel cas de figure ?
Il y a trois méthodes qui me viennent à l'esprit :

1. ne pas écrire d'accesseur direct à la liste, mais interfacer son accès via un itérateur qui renverra des const pomme* const ;
2. gérer deux listes : une contenant des pomme* et une autre des const pomme* ;
3. modifier l'accesseur à la liste de façon à ce qu'il retourne un objet proxy encapsulant la liste et proposant une interface empêchant une modification des objets pointés (probablement à base d'itérateur similaire à la première méthode).

La méthode 1 induit l'écriture d'un tas de méthodes membres (get_pommes_begin_iterator(), _end_iterator(), sans parler d'empty() et de size()), ce qui serait extrêmement lourd).
La méthode 2 me semble être la plus simple à mettre en place.
La méthode 3 semble propre elle aussi (quoique je n'ai pas énormément creusé cette possibilité), mais si elle était généralement utilisée on aurait des classes proxy template déjà présentes dans la STL ou dans Boost, mais il n'y existe rien de tel à ma connaissance.

Si je devais faire un choix moi-même, ce serait donc la méthode 2.
Toutefois, j'aimerais beaucoup avoir vos différents avis. Utilisez-vous une autre méthode à laquelle je n'ai pas pensée ?

J'attends vos réponses

[camboui]

Ce n'est peut-être pas très élégant, mais faire un cast pour que get_pommes retourne const std::list<const pomme*>& ?

[Florian Goo]

Eh non, c'est pas valide, comme cast

[Nogane]

Bonsoir,
Je me permet de rajouter une solution qui a une petite chance de convenir:
Avec un "const boost::ptr_list" les éléments contenu sont constant eux aussi.

[Florian Goo]

Dans mon cas particulier, mes objets sont alloués sur la pile, puis déplacés (move semantics de C++0x) dans un conteneur d'objets (et non de pointeurs d'objet). Le conteneur de pointeurs d'objet est là pour faire du polymorphisme.
Par exemple, pour rester dans l'esprit de l'exemple que j'ai donné, ça donnerait plutôt ça :

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
 
class panier
{
    public:
        void
        add(pomme&& p)
        {
            pommes_.push_back(p);
            pomme& p_ref = pommes_.back();
            fruits_.add(&p_ref);
        }
 
        void
        add(poire&& p)
        {
            poires_.push_back(p);
            poire& p_ref = poires.back();
            fruits_.add(&p_ref);
        }
 
        void
        add(scoubidoubidou&& s)
        {
            //...
        }
 
        const std::list<fruit*>
        get_fruits() const
        {
            return fruits_;
        }
 
    private:
        std::list<fruit*> fruits_;
        std::list<pomme> pommes_;
        std::list<poire> poires_;
        std::list<scoubidoubidou> scoubidoubidou_;
        //...
};

Quoi qu'il en soit, je ne pense pas qu'on puisse parler d'objets alloués sur le tas dans ce cas-là. Par conséquent, boost::ptr_list n'est pas envisageable.

[Sylvain Togni]

Pour ma part j'utilise std::vector à 99.9% du temps, les 0.1% sont des std::set ou std::map (je crois que je n'ai jamais trouvé un cas concret où l'utilisation de std::list se justifiait) alors une interface d'accès à base d'index convient souvent :

Code :

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

1
2
3
4
5
6
7
8
9
class panier
{
public:
  int nombre_de_fruits() const {return int(fruits_.size());}
  fruit const& fruit(int i) const {return *fruits_[i];}
 
private:
  std::vector<fruit*> fruits_;
};

[camboui]

Eh non, c'est pas valide, comme cast

En trichant un peu si.
Je le reconnais, c'est un peu gonfflé, mais ça fonctionne très bien.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
std::vector<const unsigned *> & foo()
{
	std::vector<unsigned *> u_v;
 
	void *vp=&u_v;
	std::vector<const unsigned *> *cu_v_ptr=reinterpret_cast<std::vector<const unsigned *> *>(vp);
	return *cu_v_ptr;
}
 
int main()
{
	std::vector<const unsigned *> & r=foo();
}

[loufoque]

Plutôt que de retourner un conteneur, tu pourrais pas plutôt fournir une paire d'itérateurs, ou une range ?
Tu fais un simple adapteur autour de ton conteneur, ça fait deux lignes et c'est bon...

return transformed(v, static_cast_<const unsigned*>(_1));

la deuxième ligne étant un typedef du type de retour de cette expression.

[Florian Goo]

Oui, c'est ce que j'ai tenté en premier avec ce type de code :

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
 
class panier
{
    public:
        //...
 
        std::list<fruit*>::const_iterator
        get_fruits_begin() const
        {
            return fruits_.begin();
        }
 
        std::list<fruit*>::const_iterator
        get_fruits_end() const
        {
            return fruits_.end();
        }
 
    private:
        std::list<fruit*> fruits_;
        std::list<pomme> pommes_;
        std::list<poire> poires_;
        std::list<scoubidoubidou> scoubidoubidou_;
        //...
};

Mais après il aurait fallut écrire get_fruits_size(), get_fruits_empty(), etc… ce qui au final donne une trop grande quantité de code.

Ceci dit, si tu as une solution élégante similaire requérant une quantité moindre de code, je suis partant . Retourner une paire d'itérateur semble être la solution privilégiée par les experts (par exemple, l'implémentation du pattern Composite du livre du GoF).

Cette fonction transformed() provient-elle de boost ? Le grand fan de Boost que tu es me souffle que oui. Je vais me renseigner sur boost::iterator