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?