Design Patterns with C++

Explore the adapter pattern to convert an interface into another interface so incompatible interfaces work together, using adapter classes in their basic form with a model and mobile phone example.

Implement the adapter pattern to convert a server camera with ip and multisensory attributes into a client camera, wiring set and get methods for ip, multisensory, and other properties.

Explore the bridge design pattern to decouple abstraction from implementation, enabling independent modules, flexible variation, and a management system example.

Implement the bridge pattern in c++ by defining a base interface with virtual methods, overriding behavior in concrete light and image types, and coordinating them through a management system.

Explore the decorator pattern in theory, showing how to add new responsibilities to objects quickly through composition, illustrated by espresso-based drinks like espresso, Americano, and latte.

Implement the decorator pattern by defining a base espresso class and composing drinks like americano and latte with milk and water.

Explore the facade pattern as a simplified interface to a complex library or subsystem. Implement an application class to wrap needed classes, revealing an easy-to-use interface for diverse applications.

This lecture demonstrates a facade implementation in C++, introducing an applicant class with constructors, a name getter, a department check method, and an eligibility test to process an application.

Explore the flyweight pattern to share similar objects and reduce memory usage, illustrated by a coffee shop example that avoids creating new customer objects for each order.

Implement the flyweight pattern in c++ by building a customer class with a name property and a flyweights factory to share intrinsic state across orders in a coffee shop scenario.

Explore the proxy pattern by treating a server-side class as an interface for a client-side use, enabling the client to call the server's display method through a proxy.

Implement a proxy pattern in C++ by building a server side camera class, using separate namespaces for server and client, defining a contract, and running the code to verify results.

Explore the command design pattern with C++, identifying invoker, receiver, and command roles, and learn how to encapsulate requests for execution. See a simple example that illustrates invoking a receiver.

Explore command implementation within design patterns in C++, starting from a base class and a simple terminal-based example.

Explore the interpreter pattern in theory with a basic gender interpreter example that translates input into gender labels, illustrating language-like translation in design patterns with C++.

Implement the interpreter pattern in c++ by building a simple gender-detection data set with hard-coded names and a constructor, showing how to interpret inputs based on name patterns.

Explore the mediator pattern to reduce complex communications by introducing a central mediator that coordinates messages between components.

Implement the mediator pattern in a simple chat where a user named Robert sends a message to John, which pops up and displays the exchange.

Explore the memento in theory, detailing how an originator and caretaker relate to the memento and discuss a simple example and code.

Implement the memento design pattern by creating originator, memento, and caretaker components. Capture and restore states, transition between states, and verify state consistency with the memento.