![\"patterns\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/patterns.png\")
<\/p>\nThe Composite Pattern allows you to compose objects into tree structures and treat the individual object and composite objects uniformly.<\/p>\n
<\/p>\n
<\/p>\n
The Composite Pattern is similar to the Decorator Pattern I presented in my last post. Both patterns are of structural nature. The main difference is that the Composite Pattern composites tree structures, but the Decorator Pattern only has one object.<\/p>\n
Here are more details about the Composite Pattern.<\/p>\n
![\"CompositePattern\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/10\/CompositePattern.png\")
<\/p>\n
When you perform an operation on the tree structure, the operation can be performed on a leaf node or a composite node. The operation is directly performed if it is a leaf node. The operation is delegated to all children components if it is a composite node. A composite node has a list of children and member functions to add or remove those. Consequentially, each component (leaf node or composite node) can handle the operation appropriately.<\/p>\n<\/p>\n <\/p>\n In this example Each component has to implement the pure virtual function The main program creates a tree structure with the root Applying an algorithm such as find <\/span>or find_if <\/span>on a container of the Standard Template Library can be regarded as a simplified application of the Composite Pattern. This is particularly true if the container is an ordered associative container like std::map.<\/span><\/p>\n Let me start with the benefits.<\/p>\nComponent<\/code><\/p>\n\n
Composite<\/span> <\/code>(parent) can access its Component<\/code>‘s child (optionally)<\/li>\n<\/ul>\nLeaf<\/code><\/p>\n\n
Composite<\/code><\/p>\n\n
Example<\/h3>\n
\n\/\/ composite.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\nclass<\/span> Graphic<\/span> {\r\n public:<\/span>\r\n virtual<\/span> void<\/span> print() const<\/span> =<\/span> 0<\/span>;\r\n virtual<\/span> ~<\/span>Graphic() {} \r\n};\r\n\r\nclass<\/span> GraphicComposite<\/span> :<\/span> public<\/span> Graphic {\r\n std::<\/span>vector<<\/span>const<\/span> Graphic*><\/span> children; \/\/ (1)<\/span>\r\n const<\/span> std::<\/span>string&<\/span> name;\r\n public:<\/span>\r\n explicit<\/span> GraphicComposite<\/span>(const<\/span> std::<\/span>string&<\/span> n):<\/span> name(n){}\r\n void<\/span> print() const<\/span> override { \/\/ (5)<\/span>\r\n std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>;\r\n for<\/span> (auto<\/span> c:<\/span> children) c-><\/span>print();\r\n }\r\n\r\n void<\/span> add(const<\/span> Graphic*<\/span> component) { \/\/ (2)<\/span>\r\n children.push_back(component);\r\n }\r\n\r\n void<\/span> remove(const<\/span> Graphic*<\/span> component) { \/\/ (3)<\/span>\r\n std::<\/span>erase(children, component);\r\n }\r\n};\r\n\r\nclass<\/span> Ellipse<\/span>:<\/span> public<\/span> Graphic {\r\n private:<\/span>\r\n const<\/span> std::<\/span>string&<\/span> name;\r\n public:<\/span>\r\n explicit<\/span> Ellipse<\/span>(const<\/span> std::<\/span>string&<\/span> n):<\/span> name (n) {}\r\n void<\/span> print() const<\/span> override { \/\/ (4)<\/span>\r\n std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>;\r\n }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n const<\/span> std::<\/span>string el1 =<\/span> \"ellipse1\"<\/span>;\r\n const<\/span> std::<\/span>string el2 =<\/span> \"ellipse2\"<\/span>;\r\n const<\/span> std::<\/span>string el3 =<\/span> \"ellipse3\"<\/span>;\r\n const<\/span> std::<\/span>string el4 =<\/span> \"ellipse4\"<\/span>;\r\n\r\n Ellipse ellipse1(el1);\r\n Ellipse ellipse2(el2);\r\n Ellipse ellipse3(el3);\r\n Ellipse ellipse4(el4);\r\n\r\n const<\/span> std::<\/span>string graph1 =<\/span> \"graphic1\"<\/span>;\r\n const<\/span> std::<\/span>string graph2 =<\/span> \"graphic2\"<\/span>;\r\n const<\/span> std::<\/span>string graph3 =<\/span> \"graphic3\"<\/span>;\r\n\r\n GraphicComposite graphic1(graph1);\r\n GraphicComposite graphic2(graph2);\r\n GraphicComposite graphic(graph3);\r\n\r\n graphic1.add(&<\/span>ellipse1);\r\n graphic1.add(&<\/span>ellipse2);\r\n graphic1.add(&<\/span>ellipse3);\r\n\r\n graphic2.add(&<\/span>ellipse4);\r\n\r\n graphic.add(&<\/span>graphic1);\r\n graphic.add(&<\/span>graphic2);\r\n\r\n graphic1.print();\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n graphic2.print();\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n graphic.print(); \/\/ (6)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n graphic.remove(&<\/span>graphic1);\r\n graphic.print(); \/\/ (7)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\nGraphic<\/code> defines the interface for all concrete components. GraphicComposite<\/code> stands for the composite node and Ellipse<\/code> stands for the leaf node. GraphicComposite<\/code> holds its children in a std::vector<const Graphic*><\/code> (line 1), and supports operations to add and remove children (lines 2 and 3). <\/p>\nprint<\/code>. The Ellipse<\/code> displays it name<\/code> (line 4). The GraphicComposite<\/code> also displays its name<\/code> but, additionally, delegates the show call to its children (line 5).<\/p>\ngraphic<\/code>. First, the tree graphic<\/code> is displayed with the subtree graphic1<\/code> (line 6) and then without it (line 7).<\/p>\nThe following screenshot shows the output of the program:<\/div>\n <\/div>\n![\"composite\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/10\/composite.png\")
<\/p>\n <\/div>\n\nKnown Uses<\/h3>\n
Related Patterns<\/h3>\n
\n
<\/div>\nWhat are the pros and cons of the Composite Pattern?<\/div>\n\nPros and Cons<\/h3>\n
Pros<\/h4>\n
\n
Cons<\/h4>\n
\n
What’s Next?<\/h2>\n