Behavioral Design Patterns

Behavioral design patterns focus on communication and the interaction between objects, providing solutions for managing algorithms, relationships, and responsibilities between objects. They help to define the behavior of an object and how it interacts with other objects in the system.

Observer Pattern

The Observer pattern is a behavioral design pattern that allows an object, called the subject, to maintain a list of its dependents, called observers, and notify them automatically of any state changes. This pattern is useful when there is a one-to-many relationship between objects, where a change in one object should trigger changes in other objects.

In the code example below, we have an interface called Observer with an update method. The ConcreteObserver class implements this interface and provides its own implementation of the update method. The Subject class represents the subject being observed and has a list of attached observers. The doSomething method performs some action and triggers the update method on the attached observer.

1#include <iostream>
2
3using namespace std;
4
5// Interface for observers
6
7class Observer {
8 public:
9  virtual void update() = 0;
10};
11
12// ConcreteObserver class
13
14class ConcreteObserver : public Observer {
15 public:
16  void update() override {
17    cout << "Observer updated" << endl;
18  }
19};
20
21// Subject class
22
23class Subject {
24 private:
25  Observer* observer;
26
27 public:
28  void attach(Observer* observer) {
29    this->observer = observer;
30  }
31
32  void doSomething() {
33    // Perform some action
34    // Notify the observer
35    observer->update();
36  }
37};
38
39int main() {
40  // Create an instance of Subject
41  Subject subject;
42
43  // Create an instance of ConcreteObserver
44  Observer* observer = new ConcreteObserver();
45
46  // Attach the observer to the subject
47  subject.attach(observer);
48
49  // Perform some action on the subject
50  subject.doSomething();
51
52  return 0;
53}

By implementing the Observer pattern, you can achieve loose coupling between objects, as the subject doesn't need to know the details of the concrete observers. This pattern promotes the principles of encapsulation and separation of concerns, making the system more flexible and extensible.

xxxxxxxxxx

}

#include <iostream>

​

using namespace std;

​

// Interface for observers

​

class Observer {

 public:

  virtual void update() = 0;

};

​

// ConcreteObserver class

​

class ConcreteObserver : public Observer {

 public:

  void update() override {

    cout << "Observer updated" << endl;

  }

};

​

// Subject class

​

class Subject {

 private:

  Observer* observer;

​

 public:

  void attach(Observer* observer) {

    this->observer = observer;