In the dynamic landscape of software development, implementing
design patterns is an essential practice for architects and developers.
These patterns encapsulate refined solutions to recurrent problems,
fostering code reusability, maintainability, and scalability. This
article delves into three pivotal design patterns — Factory, Strategy,
and Singleton within the context of C++, utilizing real-world examples
and substantiated facts.
The Factory Pattern
Situated within the creational design patterns paradigm, the
Factory Pattern emerges as a cornerstone for the instantiation process
of objects. It furnishes an interface for creating instances of a class,
allowing subclasses to dynamically alter the type of objects to be
created. A compelling example of the Factory Pattern in action can be
found in the development of graphical user interfaces. (Refactoring.Guru, n.d.)
Consider the following example:
#include <iostream>
class Product {
public:
virtual void display() = 0;
};
class ConcreteProduct: public Product {
public:
void display() override {
std::cout << "ConcreteProduct\n";
}
};
class Creator {
public:
virtual Product* createProduct() = 0;
};
class ConcreteCreator: public Creator {
public:
Product* createProduct() override {
return new ConcreteProduct();
}
};
int main() {
Creator* creator = new ConcreteCreator();
Product* product = creator->createProduct();
product->display();
delete creator;
delete product;
return 0;
}
In this example, Creator is the factory, and ConcreteCreator is a
specific implementation of the factory that creates a ConcreteProduct.
Moreover, C++ facilitates the seamless implementation of the
Factory Pattern through its robust support for polymorphism and abstract
classes. This enables the creation of generic interfaces (e.g.,
Creator) and their concrete implementations (e.g., ConcreteCreator),
ensuring flexibility and extensibility in object creation (Refactoring.Guru, n.d.).
The Strategy Pattern
Transitioning into the realm of behavioral design patterns, the
Strategy Pattern assumes a pivotal role. This pattern defines a group of
algorithms, encapsulates each algorithm within a class, and allows for
their interchangeability. A notable real-world application of the
Strategy Pattern lies in the domain of sorting algorithms. For instance,
the C++ Standard Template Library (STL) employs the Strategy Pattern in
its sort function, allowing developers to specify a custom sorting
strategy based on the context (C++ Reference, 2023).
Furthermore, the Strategy Pattern’s flexibility shines in
scenarios where a class exhibits multiple behaviors. By encapsulating
each behavior in a separate strategy class, the Context class can
dynamically switch between strategies, facilitating adaptability and
code maintainability (Garcia-Molina et al., 2008). Here is a brief
illustration:
#include <iostream>
class Strategy {
public:
virtual void execute() = 0;
};
class ConcreteStrategyA: public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy A\n";
}
};
class ConcreteStrategyB: public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy B\n";
}
};
class Context {
private:
Strategy* strategy;
public:
Context(Strategy* s) : strategy(s) {}
void setStrategy(Strategy* s) {
strategy = s;
}
void executeStrategy() {
strategy->execute();
}
};
int main() {
ConcreteStrategyA strategyA;
ConcreteStrategyB strategyB;
Context context(&strategyA);
context.executeStrategy();
context.setStrategy(&strategyB);
context.executeStrategy();
return 0;
}
In this example, Context maintains a reference to a Strategy
object, allowing the client to switch between different strategies
dynamically.
Ensuring Singular Instances
Within the creational design patterns spectrum, the Singleton
Pattern takes center stage by ensuring that a class has only one single
instance and providing a global point of access to it. A real-world
manifestation of the Singleton Pattern is discernible in the
implementation of database connection pools. Maintaining a single
instance of a connection pool in database systems ensures efficient
resource utilization and optimal performance (Garcia-Molina et al.,
2008). Likewise, the Singleton Pattern serves as a robust safeguard
against multiple instances of a class, mitigating potential resource
conflicts. The Singleton Pattern proves invaluable in scenarios
demanding a single point of control, such as configuration management or
logging.
Conclusion
In conclusion, the strategic integration of design patterns in
C++ elevates the software’s structural integrity and contributes to its
adaptability and sustainability. The Factory, Strategy, and Singleton
patterns, each with its unique role, exemplify the elegance and
pragmatism embedded in software design patterns. Embracing these
patterns empowers developers to navigate the complexities of software
development with finesse, creating systems that are not only robust but
also poised for future evolution.
References
C++ Reference. (2023). std::sort. Retrieved from https://en.cppreference.com/w/cpp/algorithm/sort
Garcia-Molina, H., Ullman, J. D., & Widom, J. (2008). Database systems: A comprehensive overview (2nd ed.). Pearson.
Refactoring.Guru. (n.d.). Factory method in C++. https://refactoring.guru/design-patterns/factory-method/cpp/example
