Lesson 3: Design Patterns for Problem Solving

Introduction to Design Patterns

Design patterns are reusable solutions to commonly occurring problems in software development. They provide a way to solve problems that many developers have encountered before, and offer an established way of thinking and designing software.

Design patterns are important in problem solving as they help avoid reinventing the wheel. Instead of starting from scratch, developers can use known patterns to solve similar problems, saving time and effort.

```c++
#include <iostream>
using namespace std;

int main() {
    // Design Patterns
    cout << "Design patterns are reusable solutions to commonly occurring problems in software development. They provide a way to solve problems that many developers have encountered before, and offer an established way of thinking and designing software." << endl;
    
    // Importance in Problem Solving
    cout << "Design patterns are important in problem solving as they help avoid reinventing the wheel. Instead of starting from scratch, developers can use known patterns to solve similar problems, saving time and effort." << endl;
    
    return 0;
}
```

Design patterns are reusable solutions to commonly occurring problems in software development. They provide a way to solve problems that many developers have encountered before, and offer an established way of thinking and designing software.

Design patterns are important in problem solving as they help avoid reinventing the ___________.

Creational Design Patterns

Creational design patterns focus on how objects are created and initialized. They provide mechanisms for creating objects without specifying the exact class of object that will be created.

Singleton

The Singleton pattern ensures that there is only one instance of a class and provides global access to that instance. This pattern is often used in scenarios where there is a need for a single point of access to a shared resource or an object that controls a system-wide behavior.

In the example code below, we implement a Singleton class that allows only one instance of the class to be created. The getInstance() method is used to retrieve the instance of the Singleton class, and the showMessage() method is called to display a message from the Singleton instance.

#include <iostream>

using namespace std;

// Singleton class
// ... (see code field for the full code snippet)

int main() {
    // Get the singleton instance
    Singleton* singleton = Singleton::getInstance();
    // Show message
    singleton->showMessage();

    return 0;
}

```cpp
#include <iostream>

using namespace std;

// Singleton class
class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    // Get the singleton instance
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    void showMessage() {
        cout << "Hello from Singleton!" << endl;
    }
};

// Initialize static instance
Singleton* Singleton::instance = nullptr;

int main() {
    // Get the singleton instance
    Singleton* singleton = Singleton::getInstance();
    // Show message
    singleton->showMessage();

    return 0;
}
```

The Singleton pattern ensures that there are multiple instances of a class and provides global access to each instance.

Structural Design Patterns

Structural design patterns focus on establishing relationships between objects, making it easier to design a flexible and reusable system. These patterns help in defining how different parts of a system can work together to form larger structures without making the system complex or unmanageable.

Adapter Pattern

The Adapter pattern allows objects with incompatible interfaces to work together by providing a common interface. It acts as a bridge between the old and the new, allowing the components to collaborate without modifying their original code.

In the code example below, we have an Adapter interface that defines the common interface for different types of adapters. The ConcreteAdapter class implements this interface and internally uses the ConcreteAdaptee class to fulfill the required behavior. The ConcreteAdaptee class has a specific method called specificRequest(), which is adapted by the ConcreteAdapter class.

#include <iostream>

using namespace std;

// Adapter interface

class Adapter {
 public:
  virtual void request() const = 0;
};

// ConcreteAdaptee class

class ConcreteAdaptee {
 public:
  void specificRequest() const {
    cout << "Specific request" << endl;
  }
};

// ConcreteAdapter class

class ConcreteAdapter : public Adapter {
 private:
  ConcreteAdaptee *adaptee;

 public:
  ConcreteAdapter(ConcreteAdaptee *adaptee) : adaptee(adaptee) {}

  void request() const override {
    adaptee->specificRequest();
  }
};

int main() {
  // Create an instance of ConcreteAdaptee
  ConcreteAdaptee *adaptee = new ConcreteAdaptee();

  // Create an instance of ConcreteAdapter
  Adapter *adapter = new ConcreteAdapter(adaptee);

  // Call the request method on the adapter
  adapter->request();

  return 0;
}

By using the Adapter pattern, we can easily integrate legacy code or third-party libraries into new systems while maintaining a consistent and unified interface.

```c++
#include <iostream>

using namespace std;

// Adapter interface

class Adapter {
 public:
  virtual void request() const = 0;
};

// ConcreteAdaptee class

class ConcreteAdaptee {
 public:
  void specificRequest() const {
    cout << "Specific request" << endl;
  }
};

// ConcreteAdapter class

class ConcreteAdapter : public Adapter {
 private:
  ConcreteAdaptee *adaptee;

 public:
  ConcreteAdapter(ConcreteAdaptee *adaptee) : adaptee(adaptee) {}

  void request() const override {
    adaptee->specificRequest();
  }
};

int main() {
  // Create an instance of ConcreteAdaptee
  ConcreteAdaptee *adaptee = new ConcreteAdaptee();

  // Create an instance of ConcreteAdapter
  Adapter *adapter = new ConcreteAdapter(adaptee);

  // Call the request method on the adapter
  adapter->request();

  return 0;
}
```

In the Adapter pattern, the _______________ class acts as a bridge between the old and the new, allowing the components to collaborate without modifying their original code. This class implements the common interface defined by the ___________ class and internally uses the ___________ class to fulfill the required behavior.

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.

#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;
  }

  void doSomething() {
    // Perform some action
    // Notify the observer
    observer->update();
  }
};

int main() {
  // Create an instance of Subject
  Subject subject;

  // Create an instance of ConcreteObserver
  Observer* observer = new ConcreteObserver();

  // Attach the observer to the subject
  subject.attach(observer);

  // Perform some action on the subject
  subject.doSomething();

  return 0;
}

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.

```c++
#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;
  }

  void doSomething() {
    // Perform some action
    // Notify the observer
    observer->update();
  }
};

int main() {
  // Create an instance of Subject
  Subject subject;

  // Create an instance of ConcreteObserver
  Observer* observer = new ConcreteObserver();

  // Attach the observer to the subject
  subject.attach(observer);

  // Perform some action on the subject
  subject.doSomething();

  return 0;
}

```

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.

Design Patterns for Problem Solving

When it comes to solving complex problems in software development, design patterns play a crucial role. Design patterns are reusable solutions to common problems that occur in software design. They provide a structured approach to problem solving and enable developers to create flexible and maintainable code.

Design patterns are especially useful when dealing with complex systems and large codebases. They help in organizing code, improving code readability, and promoting code reusability. By leveraging design patterns, developers can tackle various problem domains and ensure that their solutions are robust and scalable.

Types of Design Patterns

There are three main categories of design patterns:

1. Creational Design Patterns

• Singleton: Ensures that only one instance of a class is created and provides a global point of access to it.
• Factory: Provides an interface for creating objects without specifying their concrete classes.
• Builder: Separates the construction of an object from its representation, allowing the same construction process to create various representations.

1. Structural Design Patterns

• Adapter: Allows objects with incompatible interfaces to work together by providing a common interface.
• Decorator: Dynamically adds functionality to an object at runtime by wrapping it with a decorator class.
• Proxy: Provides a surrogate or placeholder for another object to control access to it.

1. Behavioral Design Patterns

• Observer: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
• Strategy: Encapsulates interchangeable behavior and allows clients to choose from different algorithms at runtime.
• Template Method: Defines the skeleton of an algorithm in a base class and lets subclasses override specific steps of the algorithm.

Benefits of Design Patterns

Design patterns offer several benefits when it comes to problem solving in software development:

• Code Reusability: Design patterns provide reusable solutions to common problems, reducing the need to re-implement the same functionality.
• Modularity: Design patterns promote code modularity by separating concerns and responsibilities into separate classes or components.
• Flexibility: By utilizing design patterns, developers can easily modify or extend the behavior of an application without impacting the overall system.
• Readability: Design patterns provide well-defined structures and relationships, making code more readable and understandable.

Conclusion

Design patterns provide a proven approach to problem solving in software development. By understanding and applying design patterns, developers can create scalable, maintainable, and flexible code. Whether it's solving a specific problem or improving the overall architecture of an application, design patterns are a valuable tool in a developer's toolkit.

```c++
#include <iostream>
using namespace std;

int main() {
  // Replace with your C++ logic here
  return 0;
}
```

In software development, design patterns provide a structured approach to problem solving and enable developers to create _______________ code.

Pattern Selection

When you encounter a problem in software development, choosing the appropriate design pattern is crucial. The right design pattern helps structure your code and provides a reusable solution for the problem at hand. Here are some guidelines to follow when selecting a design pattern:

1. Identify the problem: Understand the problem you are trying to solve and the specific requirements or constraints involved.
2. Analyze the problem: Break down the problem into smaller parts and identify the key components or entities involved.
3. Research available design patterns: Familiarize yourself with different design patterns and their use cases. Look for patterns that align with the problem domain.
4. Consider trade-offs: Evaluate the pros and cons of each design pattern in terms of code structure, complexity, maintainability, and performance.
5. Choose the most suitable pattern: Select the design pattern that best fits the problem requirements and aligns with the overall architecture of your system.

By following these guidelines, you can make an informed decision when choosing a design pattern for a given problem.

Example

Let's consider an example where we need to model different types of vehicles in a software system. We have cars, motorcycles, and bicycles. Each vehicle type has its own set of properties and behaviors. To choose the appropriate design pattern, we can leverage the Factory Method pattern. This pattern allows us to encapsulate the vehicle creation logic in a factory class, which can determine the specific type of vehicle based on certain conditions or input.

Here's an example of using the Factory Method pattern to choose the appropriate vehicle type: ```cpp

include

using namespace std;

// Abstract base class for vehicles class Vehicle { public: virtual void startEngine() = 0; virtual void stopEngine() = 0; };

// Concrete classes for each vehicle type class Car : public Vehicle { public: void startEngine() { cout << "Starting car engine..." << endl; }

void stopEngine() {
  cout << "Stopping car engine..." << endl;
}

};

// Create a factory class to encapsulate the vehicle creation logic class VehicleFactory { public: static Vehicle* createVehicle(string type) { if (type == "car") { return new Car(); } else if (type == "motorcycle") { return new Motorcycle(); } else if (type == "bicycle") { return new Bicycle(); }

  return nullptr;
}

};

// Drive the vehicle void driveVehicle(Vehicle* vehicle) { vehicle->startEngine(); // Drive the vehicle... vehicle->stopEngine(); }

int main() { // Use the factory method to create the appropriate vehicle type Vehicle* vehicle1 = VehicleFactory::createVehicle("car"); Vehicle* vehicle2 = VehicleFactory::createVehicle("motorcycle"); Vehicle* vehicle3 = VehicleFactory::createVehicle("bicycle");

// Drive each vehicle driveVehicle(vehicle1); driveVehicle(vehicle2); driveVehicle(vehicle3);

return 0; } ```

In this example, we create a factory class VehicleFactory that encapsulates the logic for creating vehicle objects based on a given type. The VehicleFactory class helps us choose the appropriate vehicle type using the Factory Method pattern. By using the factory method, we can easily add new vehicle types in the future without modifying the driveVehicle function or other parts of our code.

Remember, the choice of design pattern depends on the specific problem and the desired trade-offs. By considering the problem requirements and evaluating the available design patterns, you can select the most suitable pattern for a given problem.

```c++
#include <iostream>

using namespace std;

int main() {
  // Imagine we have a problem where we need to model different types of vehicles.
  // We have cars, motorcycles, and bicycles.
  // Each vehicle type has its own set of properties and behaviors.
  // We want to apply a design pattern to choose the appropriate vehicle type based on certain conditions.

  // Let's start by defining an abstract base class for vehicles.
  class Vehicle {
    public:
      virtual void startEngine() = 0;
      virtual void stopEngine() = 0;
  };

  // Now let's define concrete classes for each vehicle type.
  class Car : public Vehicle {
    public:
      void startEngine() {
        cout << "Starting car engine..." << endl;
      }

      void stopEngine() {
        cout << "Stopping car engine..." << endl;
      }
  };

  class Motorcycle : public Vehicle {
    public:
      void startEngine() {
        cout << "Starting motorcycle engine..." << endl;
      }

      void stopEngine() {
        cout << "Stopping motorcycle engine..." << endl;
      }
  };

  class Bicycle : public Vehicle {
    public:
      void startEngine() {
        // Bicycles don't have engines, so we don't need to do anything here.
      }
      void stopEngine() {
        // Bicycles don't have engines, so we don't need to do anything here.
      }
  };

  // Now let's see how we can choose the appropriate vehicle type using a design pattern.
  // Suppose we have a function that takes in a vehicle type as a parameter.
  void driveVehicle(Vehicle* vehicle) {
    vehicle->startEngine();
    // Drive the vehicle...
    vehicle->stopEngine();
  }

  // Now let's create instances of different vehicle types.
  Vehicle* vehicle1 = new Car();
  Vehicle* vehicle2 = new Motorcycle();
  Vehicle* vehicle3 = new Bicycle();
  
  // Let's drive each vehicle.
  driveVehicle(vehicle1);
  driveVehicle(vehicle2);
  driveVehicle(vehicle3);

  return 0;
}
```

When choosing a design pattern, it's important to consider the ________ and evaluate the available design patterns.

Implementing a Design Pattern

Implementing a design pattern involves converting the abstract concepts and principles of the pattern into concrete code. This often requires creating new classes, modifying existing classes, and establishing connections between them.

Let's take the Singleton design pattern as an example to understand the implementation process:

1. Define the Singleton class: Start by creating a class that will serve as the singleton object. In this example, we'll create a class called Singleton.

2. Make the constructor private: To ensure that only one instance of the singleton class can be created, make the constructor private. This prevents external code from directly instantiating the class.

3. Provide a static method to access the singleton instance: Create a static method, such as getInstance(), that returns the singleton instance. This method checks if an instance has already been created and returns it, or creates a new instance if one does not exist.

Here's an example of implementing the Singleton design pattern in C++:

#include <iostream>
using namespace std;

// Replace this code with the implementation of the design pattern

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

int main() {
    // Usage of the Singleton design pattern
    Singleton* obj1 = Singleton::getInstance();
    Singleton* obj2 = Singleton::getInstance();

    if (obj1 == obj2) {
        cout << "Objects are the same instance." << endl;
    } else {
        cout << "Objects are different instances." << endl;
    }

    return 0;
}

In this implementation, we create a class Singleton with a private constructor to prevent direct instantiation. The getInstance() method is used to get a reference to the singleton instance. If the instance doesn't exist, it is created; otherwise, the existing instance is returned.

By following the steps above, you can implement any design pattern in code. The specific implementation details may vary depending on the pattern and the programming language being used. Remember to adapt the implementation to your specific requirements and use the design pattern to solve the problem at hand.

```c++
#include <iostream>
using namespace std;

// Replace this code with the implementation of the design pattern

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

int main() {
    // Usage of the Singleton design pattern
    Singleton* obj1 = Singleton::getInstance();
    Singleton* obj2 = Singleton::getInstance();

    if (obj1 == obj2) {
        cout << "Objects are the same instance." << endl;
    } else {
        cout << "Objects are different instances." << endl;
    }

    return 0;
}
```

The Singleton design pattern allows for multiple instances of a class to be created.

Generating complete for this lesson!