Какие знаете паттерны проектирования?cplus-76

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
    // Удаляем копирование и присваивание
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() = default;
};

class Creator {
public:
    virtual ```Creator() = default;
    virtual std::unique_ptr<Product> create() const = 0;
};

class ConcreteCreator : public Creator {
public:
    std::unique_ptr<Product> create() const override {
        return std::make_unique<ConcreteProduct>();
    }
};

class LegacySystem {
public:
    void oldMethod() {/*...*/}
};

class NewInterface {
public:
    virtual void newMethod() = 0;
};

class Adapter : public NewInterface {
    LegacySystem legacy;
public:
    void newMethod() override { legacy.oldMethod(); }
};

class Component {
public:
    virtual void operation() = 0;
    virtual void add(Component*) {}
    virtual void remove(Component*) {}
};

class Leaf : public Component {
    void operation() override {/*...*/}
};

class Composite : public Component {
    std::vector<Component*> children;
public:
    void operation() override {
        for (auto child : children) child->operation();
    }
    void add(Component* c) override { children.push_back(c); }
};

class Observer {
public:
    virtual void update(const std::string& data) = 0;
};

class Subject {
    std::vector<Observer*> observers;
public:
    void attach(Observer* o) { observers.push_back(o); }
    void notify(const std::string& data) {
        for (auto o : observers) o->update(data);
    }
};

class SortingStrategy {
public:
    virtual void sort(std::vector<int>&) const = 0;
};

class QuickSort : public SortingStrategy {
    void sort(std::vector<int>& v) const override {/*...*/}
};

class Context {
    std::unique_ptr<SortingStrategy> strategy;
public:
    void setStrategy(std::unique_ptr<SortingStrategy> s) { strategy = std::move(s); }
    void execute(std::vector<int>& v) { strategy->sort(v); }
};

template <typename T>
class Base {
    void interface() { static_cast<T*>(this)->implementation(); }
};

class Derived : public Base<Derived> {
    void implementation() {/*...*/}
};