In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes a group of objects that are treated the same way as a single instance of the same type of object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.
The Composite design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.
The Composite pattern solves these problems:
When defining (1) <code>Part</code> objects and (2) <code>Whole</code> objects that act as containers for <code>Part</code> objects, clients must treat them separately, which complicates client code.
This enables clients to work through the <code>Component</code> interface to treat <code>Leaf</code> and <code>Composite</code> objects uniformly: <code>Leaf</code> objects perform a request directly, and <code>Composite</code> objects forward the request to their child components recursively downwards the tree structure. This makes client classes easier to implement, change, test, and reuse.
See also the UML class and object diagram below.
When dealing with Tree-structured data, programmers often have to discriminate between a leaf-node and a branch. This makes code more complex, and therefore, more error prone. The solution is an interface that allows treating complex and primitive objects uniformly. In object-oriented programming, a composite is an object designed as a composition of one-or-more similar objects, all exhibiting similar functionality. This is known as a "has-a" relationship between objects. The key concept is that you can manipulate a single instance of the object just as you would manipulate a group of them. The operations you can perform on all the composite objects often have a least common denominator relationship. For example, if defining a system to portray grouped shapes on a screen, it would be useful to define resizing a group of shapes to have the same effect (in some sense) as resizing a single shape.
Composite should be used when clients ignore the difference between compositions of objects and individual objects. If programmers find that they are using multiple objects in the same way, and often have nearly identical code to handle each of them, then composite is a good choice; it is less complex in this situation to treat primitives and composites as homogeneous.
In the above UML class diagram, the <code>Client</code> class doesn't refer to the <code>Leaf</code> and <code>Composite</code> classes directly (separately). Instead, the <code>Client</code> refers to the common <code>Component</code> interface and can treat <code>Leaf</code> and <code>Composite</code> uniformly. <br> The <code>Leaf</code> class has no children and implements the <code>Component</code> interface directly. <br> The <code>Composite</code> class maintains a container of child <code>Component</code> objects (<code>children</code>) and forwards requests to these <code>children</code> (<code>for each child in children: child.operation()</code>). <br>
The object collaboration diagram shows the run-time interactions: In this example, the <code>Client</code> object sends a request to the top-level <code>Composite</code> object (of type <code>Component</code>) in the tree structure. The request is forwarded to (performed on) all child <code>Component</code> objects (<code>Leaf</code> and <code>Composite</code> objects) downwards the tree structure.<br>
There are two design variants for defining and implementing child-related operations like adding/removing a child component to/from the container (<code>add(child)/remove(child)</code>) and accessing a child component (<code>getChild()</code>):
The GoF authors present a variant of the Composite design pattern that emphasizes transparency over type safety and discuss the tradeoffs of the two approaches.
The type-safe approach is particularly palatable if the composite structure is fixed post construction: the construction code does not require transparency because it needs to know the types involved in order to construct the composite. If downstream, the code does not need to modify the structure, then the child manipulation operations do not need to be present on the <code>Component</code> interface.
As it is described in Design Patterns, the pattern also involves including the child-manipulation methods in the main Component interface, not just the Composite subclass. More recent descriptions sometimes omit these methods.
This C++23 implementation is based on the pre C++98 implementation in the book.
The program output is