Discussion :

[ternel]

Je me suis replongé dans l'article de David Come sur les design patterns en C++, pour voir ce que je peux en tirer avec le C++11.

L'auteur nous décrit plusieurs patterns, dont le Composite.
De celui-ci en particulier, il dit qu'il ne se prête pas à la réalisation template.

Hors, j'ai ce code dans mon projet actuel:

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
#include <vector>
#include <functional>
#include <initializer_list>
 
template <class A>
class Composite: public A {
	public:
		explicit Composite(){}
		explicit Composite(std::initializer_list<A*> elements):elements(elements){}
 
		~Composite() {for(A* a: elements) delete a;}
 
		Composite& add(A* a) { elements.push_back(a); return *this; }
 
	private:
        	std::vector<A*> elements;
	protected:
		void iterate(std::function<void(const A*)> const& f) const {
			for(const A* a : elements) f(a);
		}
		void iterate(std::function<void(A*)> const& f){
			for(A* a : elements) f(a);
		}
};

Ce qui permet d'avoir, par exemple, ce genre d'usage:

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
stuct Base{
		virtual std::string content() const = 0;
};
 
class Leaf : public Base{
	private:
		std::string name;
	public:
		explicit Leaf(const std::string& name):name(name){}
		std::string content() const {return name;}
};
 
class Node : public Composite<Base>{
	public:
		Node(std::initializer_list<Base*> elements):Composite<Base>(elements){}
 
		std::string content() const {
			std::ostringstream oss;
			oss<<"[ ";
			iterate( [&oss](const Base* b){oss<<(b->content())<<' ';} );
			oss<<']';
			return oss.str();
		}
};

Qu'en pensez-vous? Est-ce vraiment utile?

[3DArchi]

Salut,

Qu'en pensez-vous?

Que la classe Composite ressemble plus à un conteneur. Une surcouche à std::vector en quelque sorte.

Est-ce vraiment utile?

Quelle est la responsabilité de composite qui la distingue d'un conteneur ? Ou en d'autre termes, j'ai le sentiment qu'une surcouche a été rajoutée mais avec une faible valeur ajoutée.

[ternel]

Le pattern composite est essentiellement de grouper plusieurs elements, et de se comporter comme l'un d'eux.

en gros

Code :

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

1
2
3
4
5
6
class Composite<Bidule>: public Bidule{
    container<Bidule> contenu;
 
    //pour toute fonction f de bidule, 
    f = for (auto c : contenu) c.f
};

Dans les interfaces graphiques, par exemple, un panneau contenant des boutons est un ComposantGraphique, comme chacun des boutons.

Dessiner le panneau appelle (entre autre) le dessin de chaque bouton.

Il s'agit de mapper chaque fonction de l'interface sur l'ensemble des contenus.

La classe que j'ai trouvé me semble n'être qu'un utilitaire, qui aurai d'ailleurs du être templaté aussi sur le type de conteneur.

[Médinoc]

@3DArchi: Ça ajoute une notion d'arborescence: Le composite peut contenir des (pointeurs vers) des objets de différents types d'une hiérarchie, y compris son propre type.

C'est très utilisé en Interface Utilisateur Graphique (javax.swing.JComponent, System.Windows.Forms.Control, etc.)

Par contre, ça nécessite du downcasting dès que tu veux accéder à des propriétés particulières d'un objet d'une classe dérivée. Je dirais que cette approche fais très "Java", bien qu'elle n'y soit pas limitée.

[ptyxs]

J'avais cru comprendre que ce fil s'interrogeait sur l'incidence éventuelle de la nouvelle norme C+11 sur les design patterns en général, mais j'ai dû mal saisir le sens du titre du fil...
Il s'agit apparemment d'une question sur un certain design pattern, et indépendamment de la nouvelle norme, non ?

[ternel]

initialement, je projetais de mettre à jour ma manière de réaliser les différents patterns en profitant des fonctionnalités du C++11.
Je suis retourné sur les articles de développez.com abordant le sujet, et je soulevai le problème présent.

De toutes façons, les patterns sont des concepts, indépendants de la norme et même du langage.

Cela dit, je vais renommer le sujet, le titre "Composite et template" étant plus adapté.