Skip to Content
👆 We offer 1-on-1 classes as well check now

Prototype Pattern

The Prototype Pattern is a creational design pattern that allows you to create new objects by copying an existing object, known as the prototype. This pattern is particularly useful when creating new objects is expensive or complex, and you can obtain a new object by cloning an existing one. In C++, the Prototype Pattern is typically implemented using virtual functions and the copy constructor. This pattern avoids the need for concrete classes by allowing you to clone an abstract class.

What is Prototype Pattern

The Prototype Pattern addresses the problem of creating new objects when the type of object to create is determined at runtime. Instead of using the new keyword directly or relying on a factory pattern, the Prototype Pattern provides a mechanism for cloning existing objects. This approach offers several advantages:

  • Reduced Coupling: The client code doesn’t need to know the concrete classes of the objects it’s creating. It interacts with an abstract prototype interface.
  • Dynamic Object Creation: New object types can be added at runtime without modifying existing code. You simply register a new prototype.
  • Performance Improvement: Cloning can be more efficient than creating a new object from scratch, especially if the object’s initialization is costly.
  • Simplified Object Creation: The client code doesn’t need to manage the complexity of object creation, as it’s handled by the prototype.

In-Depth Explanation:

The core idea behind the Prototype Pattern is to have a base class or interface that defines a clone() method (typically a virtual function in C++). Concrete classes then implement this method to create a copy of themselves. The clone() method usually involves creating a new object of the same type and copying the data from the original object to the new one.

Edge Cases:

  • Deep vs. Shallow Copy: One of the most important considerations is whether to perform a deep or shallow copy. A shallow copy copies only the references to the object’s data, while a deep copy creates new copies of the data itself. Deep copies are generally preferred to avoid unintended side effects when modifying the copied object.
  • Circular References: If the objects being cloned contain circular references, a deep copy can lead to infinite recursion. You need to handle circular references carefully, possibly by using a mechanism to track which objects have already been copied.
  • Complex Object Graphs: Cloning complex object graphs can be challenging. You need to ensure that all related objects are cloned correctly and that the relationships between them are maintained.

Performance Considerations:

While cloning can be faster than creating a new object from scratch, it’s important to consider the performance implications of the copy operation itself. Cloning large objects can be expensive, especially if a deep copy is required. In some cases, it may be more efficient to use a factory pattern or other object creation mechanism.

Syntax and Usage

The Prototype Pattern in C++ typically involves the following elements:

  1. Prototype Interface/Abstract Class: Defines the clone() method. This is usually an abstract class with a virtual clone() function.
  2. Concrete Prototypes: Concrete classes that implement the clone() method to create a copy of themselves. They also implement the pure virtual methods from the interface.
  3. Client: The client code that uses the clone() method to create new objects. The client holds pointers to the prototype objects and calls their respective clone() methods.

Syntax:

#include <iostream>
#include <string>
 
class Prototype {
public:
    virtual Prototype* clone() const = 0;
    virtual void print() const = 0;
    virtual ~Prototype() = default;
};
 
class ConcretePrototype1 : public Prototype {
public:
    ConcretePrototype1(std::string data) : data_(data) {}
    Prototype* clone() const override {
        return new ConcretePrototype1(*this); // Copy constructor
    }
    void print() const override {
        std::cout << "ConcretePrototype1: " << data_ << std::endl;
    }
 
private:
    std::string data_;
};
 
class ConcretePrototype2 : public Prototype {
public:
    ConcretePrototype2(int value) : value_(value) {}
    Prototype* clone() const override {
        return new ConcretePrototype2(*this); // Copy constructor
    }
    void print() const override {
        std::cout << "ConcretePrototype2: " << value_ << std::endl;
    }
 
private:
    int value_;
};
 
int main() {
    ConcretePrototype1* prototype1 = new ConcretePrototype1("Hello");
    ConcretePrototype2* prototype2 = new ConcretePrototype2(123);
 
    Prototype* clone1 = prototype1->clone();
    Prototype* clone2 = prototype2->clone();
 
    clone1->print(); // Output: ConcretePrototype1: Hello
    clone2->print(); // Output: ConcretePrototype2: 123
 
    delete prototype1;
    delete prototype2;
    delete clone1;
    delete clone2;
 
    return 0;
}

Basic Example

Let’s consider a more complex example involving a Shape hierarchy where different shapes (e.g., Circle, Square) can be cloned.

#include <iostream>
#include <string>
#include <memory>
 
class Shape {
public:
    enum ShapeType {
        CIRCLE,
        SQUARE
    };
 
    virtual ~Shape() = default;
    virtual std::unique_ptr<Shape> clone() const = 0;
    virtual void draw() const = 0;
};
 
class Circle : public Shape {
public:
    Circle(int radius) : radius_(radius) {}
 
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Circle>(*this); // Copy constructor
    }
 
    void draw() const override {
        std::cout << "Drawing a circle with radius: " << radius_ << std::endl;
    }
 
private:
    int radius_;
};
 
class Square : public Shape {
public:
    Square(int side) : side_(side) {}
 
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Square>(*this); // Copy constructor
    }
 
    void draw() const override {
        std::cout << "Drawing a square with side: " << side_ << std::endl;
    }
 
private:
    int side_;
};
 
class ShapeFactory {
public:
    ShapeFactory() {
        prototypes_[Shape::ShapeType::CIRCLE] = std::make_unique<Circle>(5);
        prototypes_[Shape::ShapeType::SQUARE] = std::make_unique<Square>(10);
    }
 
    std::unique_ptr<Shape> createShape(Shape::ShapeType type) {
        auto it = prototypes_.find(type);
        if (it != prototypes_.end()) {
            return it->second->clone();
        }
        return nullptr;
    }
 
private:
    std::unordered_map<Shape::ShapeType, std::unique_ptr<Shape>> prototypes_;
};
 
 
int main() {
    ShapeFactory factory;
 
    auto circle1 = factory.createShape(Shape::ShapeType::CIRCLE);
    auto square1 = factory.createShape(Shape::ShapeType::SQUARE);
 
    if (circle1) {
        circle1->draw(); // Output: Drawing a circle with radius: 5
    }
 
    if (square1) {
        square1->draw(); // Output: Drawing a square with side: 10
    }
 
    auto circle2 = factory.createShape(Shape::ShapeType::CIRCLE);
     if (circle2) {
        circle2->draw(); // Output: Drawing a circle with radius: 5
    }
 
    return 0;
}

Explanation:

In this example, Shape is an abstract class with a virtual clone() method. Circle and Square are concrete classes that inherit from Shape and implement the clone() method using the copy constructor and std::make_unique. The ShapeFactory class holds a collection of prototype shapes and provides a createShape() method that clones the appropriate prototype based on the requested shape type. Using std::unique_ptr ensures proper memory management.

Advanced Example

Consider a scenario where you have complex objects with nested objects and you want to clone them. In this case, you’ll need to implement a deep copy to ensure that all nested objects are also cloned.

#include <iostream>
#include <string>
#include <memory>
#include <vector>
 
class Address {
public:
    Address(std::string street, std::string city) : street_(street), city_(city) {}
 
    Address(const Address& other) : street_(other.street_), city_(other.city_) {
        std::cout << "Address copy constructor called." << std::endl;
    }
 
    std::string getStreet() const { return street_; }
    std::string getCity() const { return city_; }
 
    void setStreet(const std::string& street) { street_ = street; }
    void setCity(const std::string& city) { city_ = city; }
 
private:
    std::string street_;
    std::string city_;
};
 
class Person {
public:
    Person(std::string name, std::unique_ptr<Address> address) : name_(name), address_(std::move(address)) {}
 
    Person(const Person& other) : name_(other.name_) {
        std::cout << "Person copy constructor called." << std::endl;
        address_ = std::make_unique<Address>(*other.address_); // Deep copy of Address
    }
 
    std::string getName() const { return name_; }
    Address* getAddress() const { return address_.get(); }
 
    void setName(const std::string& name) { name_ = name; }
    void setAddress(std::unique_ptr<Address> address) { address_ = std::move(address); }
 
    std::unique_ptr<Person> clone() const {
        return std::make_unique<Person>(*this);
    }
 
    void printDetails() const {
        std::cout << "Name: " << name_ << std::endl;
        std::cout << "Address: " << address_->getStreet() << ", " << address_->getCity() << std::endl;
    }
 
 
private:
    std::string name_;
    std::unique_ptr<Address> address_;
};
 
 
int main() {
    auto address = std::make_unique<Address>("123 Main St", "Anytown");
    Person person("John Doe", std::move(address));
    person.printDetails();
 
    auto personClone = person.clone();
    personClone->printDetails();
 
    personClone->getAddress()->setStreet("456 Oak Ave");
    personClone->getAddress()->setCity("Newville");
 
    std::cout << "Original Person:" << std::endl;
    person.printDetails();
    std::cout << "Cloned Person:" << std::endl;
    personClone->printDetails();
 
 
    return 0;
}

In this advanced example, the Person class contains a std::unique_ptr to an Address object. The copy constructor of Person performs a deep copy of the Address object, ensuring that the cloned Person object has its own independent Address object. This prevents modifications to the address of the cloned person from affecting the original person’s address.

Common Use Cases

  • Object creation with complex initialization: When creating objects requires a complex setup process, cloning an existing object can be more efficient.
  • Creating multiple objects with similar configurations: You can create a prototype object with the desired configuration and then clone it to create multiple similar objects.
  • Implementing undo/redo functionality: You can clone the current state of an object to create a snapshot that can be restored later.

Best Practices

  • Use smart pointers: Employ std::unique_ptr or std::shared_ptr to manage the memory of cloned objects and prevent memory leaks.
  • Implement deep copy correctly: Ensure that all nested objects are cloned correctly to avoid unintended side effects.
  • Consider the performance implications: Be aware of the performance cost of cloning large objects, especially if a deep copy is required.
  • Document the cloning behavior: Clearly document whether a class performs a shallow or deep copy in its clone() method.

Common Pitfalls

  • Forgetting to implement the clone() method: If you forget to implement the clone() method in a concrete class, you’ll get a compilation error (if the clone method in the base class is = 0).
  • Implementing a shallow copy when a deep copy is needed: This can lead to unintended side effects when modifying the cloned object.
  • Not handling circular references: This can lead to infinite recursion during the cloning process.

Key Takeaways

  • The Prototype Pattern allows you to create new objects by cloning existing ones.
  • It can improve performance and reduce coupling.
  • Deep vs. shallow copy is a crucial consideration.
  • Use smart pointers to manage memory effectively.
Last updated on