Implementing the Composite Pattern

1#include <iostream>
2#include <memory>
3#include <vector>
4
5class Component {
6 public:
7  virtual ~Component() = default;
8  virtual void operation() = 0;
9  virtual void add(
10    std::shared_ptr<Component> component) {}
11  virtual void remove(
12    std::shared_ptr<Component> component) {}
13  virtual Component* getChild(int index) {
14    return nullptr;
15  }
16};
17
18class Leaf : public Component {
19 public:
20  void operation() override {
21    std::cout << "Leaf operation\n";
22  }
23};
24
25class Composite : public Component {
26 private:
27  std::vector<std::shared_ptr<Component>> children;
28
29 public:
30  void operation() override {
31    std::cout << "Composite operation\n";
32    for (const auto& child : children) {
33      child->operation();
34    }
35  }
36
37  void add(
38    std::shared_ptr<Component> component
39  ) override {
40    children.push_back(component);
41  }
42
43  void remove(
44    std::shared_ptr<Component> component
45  ) override {
46    // Removal logic (omitted for brevity)
47  }
48
49  Component* getChild(int index) override {
50    return children[index].get();
51  }
52
53  // Using 'this' for method chaining
54  Composite* addAndReturnThis(
55    std::shared_ptr<Component> component
56  ) {
57    add(component);
58    return this;  
59  }
60};
61
62int main() {
63  auto root = std::make_shared<Composite>();
64  auto branch1 = std::make_shared<Composite>();
65  auto branch2 = std::make_shared<Composite>();
66  auto leaf1 = std::make_shared<Leaf>();
67  auto leaf2 = std::make_shared<Leaf>();
68  auto leaf3 = std::make_shared<Leaf>();
69
70  root->addAndReturnThis(branch1)
71    ->addAndReturnThis(branch2);  
72
73  branch1->add(leaf1);
74  branch2->addAndReturnThis(leaf2)
75    ->addAndReturnThis(leaf3);
76
77  root->operation();
78}