Pattern Composite et templates
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:
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:
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?
