Реализация шаблонов проектирования GoF на C++

// Продукт — базовый интерфейс
class Enemy {
public:
    virtual void attack() = 0;
    virtual ~Enemy() = default;
};
 
// Конкретные продукты
class Zombie : public Enemy {
public:
    void attack() override {
        std::cout << "Zombie bites you!" << std::endl;
    }
};
 
class Vampire : public Enemy {
public:
    void attack() override {
        std::cout << "Vampire drains your blood!" << std::endl;
    }
};
 
// Creator — базовый класс с фабричным методом
class LevelEnemyFactory {
public:
    // Это и есть наш фабричный метод
    virtual Enemy* createEnemy() = 0;
    
    // Обратите внимание, как фабричный метод используется в алгоритме
    void spawnEnemy() {
        Enemy* enemy = createEnemy();
        std::cout << "A new enemy appeared: ";
        enemy->attack();
        // В реальном коде здесь был бы более сложный алгоритм
        delete enemy;  // Don't forget to clean up!
    }
    
    virtual ~LevelEnemyFactory() = default;
};
 
// Конкретные создатели
class ZombieLevel : public LevelEnemyFactory {
public:
    Enemy* createEnemy() override {
        return new Zombie();
    }
};
 
class VampireLevel : public LevelEnemyFactory {
public:
    Enemy* createEnemy() override {
        return new Vampire();
    }
};

class LevelEnemyFactory {
public:
    virtual std::unique_ptr<Enemy> createEnemy() = 0;
    
    void spawnEnemy() {
        auto enemy = createEnemy();
        std::cout << "A new enemy appeared: ";
        enemy->attack();
        // No need to delete explicitly, unique_ptr handles it
    }
    
    virtual ~LevelEnemyFactory() = default;
};
 
class ZombieLevel : public LevelEnemyFactory {
public:
    std::unique_ptr<Enemy> createEnemy() override {
        return std::make_unique<Zombie>();
    }
};

// Абстрактные продукты
class Button {
public:
    virtual void render() = 0;
    virtual ~Button() = default;
};
 
class Menu {
public:
    virtual void display() = 0;
    virtual ~Menu() = default;
};
 
// Средневековые продукты
class MedievalButton : public Button {
public:
    void render() override {
        std::cout << "Rendering medieval stone button" << std::endl;
    }
};
 
class MedievalMenu : public Menu {
public:
    void display() override {
        std::cout << "Showing parchment menu" << std::endl;
    }
};
 
// Футуристические продукты
class FuturisticButton : public Button {
public:
    void render() override {
        std::cout << "Rendering holographic button" << std::endl;
    }
};
 
class FuturisticMenu : public Menu {
public:
    void display() override {
        std::cout << "Showing floating neon menu" << std::endl;
    }
};
 
// Абстрактная фабрика
class UIFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<Menu> createMenu() = 0;
    virtual ~UIFactory() = default;
};
 
// Конкретные фабрики
class MedievalUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<MedievalButton>();
    }
    
    std::unique_ptr<Menu> createMenu() override {
        return std::make_unique<MedievalMenu>();
    }
};
 
class FuturisticUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<FuturisticButton>();
    }
    
    std::unique_ptr<Menu> createMenu() override {
        return std::make_unique<FuturisticMenu>();
    }
};

class HttpRequest {
    std::string method;
    std::string url;
    std::map<std::string, std::string> headers;
    std::string body;
    bool followRedirects;
    int timeout;
    
public:
    // Представьте себе конструктор с десятком параметров. Ужасно, правда?
    HttpRequest(const std::string& method, const std::string& url, 
                const std::map<std::string, std::string>& headers,
                const std::string& body, bool followRedirects, int timeout)
        : method(method), url(url), headers(headers), 
          body(body), followRedirects(followRedirects), timeout(timeout) {}
          
    // Геттеры и прочие методы...
};
 
// А вот с Строителем всё становится элегантно:
class HttpRequestBuilder {
private:
    std::string method = "GET";
    std::string url;
    std::map<std::string, std::string> headers;
    std::string body;
    bool followRedirects = true;
    int timeout = 30;
    
public:
    HttpRequestBuilder& setMethod(const std::string& method) {
        this->method = method;
        return *this;
    }
    
    HttpRequestBuilder& setUrl(const std::string& url) {
        this->url = url;
        return *this;
    }
    
    HttpRequestBuilder& addHeader(const std::string& name, const std::string& value) {
        headers[name] = value;
        return *this;
    }
    
    HttpRequestBuilder& setBody(const std::string& body) {
        this->body = body;
        return *this;
    }
    
    HttpRequestBuilder& shouldFollowRedirects(bool follow) {
        this->followRedirects = follow;
        return *this;
    }
    
    HttpRequestBuilder& setTimeout(int seconds) {
        this->timeout = seconds;
        return *this;
    }
    
    std::unique_ptr<HttpRequest> build() {
        if (url.empty()) {
            throw std::logic_error("URL is required");
        }
        
        return std::make_unique<HttpRequest>(
            method, url, headers, body, followRedirects, timeout
        );
    }
};

auto request = HttpRequestBuilder()
    .setMethod("POST")
    .setUrl("https://api.example.com/data")
    .addHeader("Content-Type", "application/json")
    .setBody("{\"key\": \"value\"}")
    .setTimeout(60)
    .build();

class HttpRequestDirector {
public:
std::unique_ptr<HttpRequest> createDefaultGetRequest(const std::string& url) {
    return HttpRequestBuilder()
        .setMethod("GET")
        .setUrl(url)
        .build();
}
 
std::unique_ptr<HttpRequest> createJsonPostRequest(
    const std::string& url, const std::string& jsonBody) {
    return HttpRequestBuilder()
        .setMethod("POST")
        .setUrl(url)
        .addHeader("Content-Type", "application/json")
        .setBody(jsonBody)
        .build();
}
};

class Monster {
public:
virtual ~Monster() = default;
virtual std::unique_ptr<Monster> clone() const = 0;
virtual void display() const = 0;
};
 
class Dragon : public Monster {
private:
std::string name;
int fireBreathDamage;
 
public:
Dragon(const std::string& name, int damage)
    : name(name), fireBreathDamage(damage) {}
 
std::unique_ptr<Monster> clone() const override {
    // Возвращаем копию себя
    return std::make_unique<Dragon>(*this);
}
 
void display() const override {
    std::cout << "Dragon " << name << " with " 
              << fireBreathDamage << " fire damage" << std::endl;
}
};
 
class Troll : public Monster {
private:
std::string clubType;
int clubDamage;
 
public:
Troll(const std::string& clubType, int damage)
    : clubType(clubType), clubDamage(damage) {}
 
std::unique_ptr<Monster> clone() const override {
    return std::make_unique<Troll>(*this);
}
 
void display() const override {
    std::cout << "Troll with " << clubType 
              << " dealing " << clubDamage << " damage" << std::endl;
}
};

class MonsterPrototypeRegistry {
private:
std::unordered_map<std::string, std::unique_ptr<Monster>> prototypes;
 
public:
void registerPrototype(const std::string& name, std::unique_ptr<Monster> prototype) {
    prototypes[name] = std::move(prototype);
}
 
std::unique_ptr<Monster> createMonster(const std::string& name) {
    if (prototypes.find(name) == prototypes.end()) {
        throw std::runtime_error("No such prototype: " + name);
    }
    return prototypes[name]->clone();
}
};

class GameSettings {
private:
// Статическая переменная для хранения единственного экземпляра
static GameSettings* instance;
std::string difficultyLevel;
bool soundEnabled;
float volume;
 
// Приватный конструктор, чтобы никто не мог создать новый экземпляр
GameSettings() : difficultyLevel("medium"), soundEnabled(true), volume(0.7f) {}
 
// Запрещаем копирование и присваивание
GameSettings(const GameSettings&) = delete;
GameSettings& operator=(const GameSettings&) = delete;
 
public:
// Метод для получения экземпляра
static GameSettings& getInstance() {
    // "Ленивая" инициализация — создаём объект только при первом вызове
    if (instance == nullptr) {
        instance = new GameSettings();
    }
    return *instance;
}
 
// Методы для работы с настройками
void setDifficulty(const std::string& level) {
    difficultyLevel = level;
}
 
std::string getDifficulty() const {
    return difficultyLevel;
}
 
// И другие методы...
};
 
// Инициализируем статическую переменную
GameSettings* GameSettings::instance = nullptr;

class GameSettings {
private:
std::string difficultyLevel;
bool soundEnabled;
float volume;
 
GameSettings() : difficultyLevel("medium"), soundEnabled(true), volume(0.7f) {}
 
public:
// Обратите внимание на реализацию
static GameSettings& getInstance() {
    // Объявляем статическую переменную внутри метода
    // Гарантируется, что она будет инициализирована только один раз,
    // даже в многопоточной среде
    static GameSettings instance;
    return instance;
}
 
// Методы для работы с настройками...
};

// Устаревший интерфейс, который мы не можем изменить
class LegacyRectangle {
public:
    void oldDraw(int x, int y, int width, int height) {
        std::cout << "Drawing rectangle at (" << x << "," << y
                  << ") with width " << width << " and height " << height << std::endl;
    }
};
 
// Новый интерфейс, который ожидает наша система
class Shape {
public:
    virtual void draw(int x, int y, int size) = 0;
    virtual ~Shape() = default;
};
 
// Адаптер, который позволяет использовать LegacyRectangle как Shape
class RectangleAdapter : public Shape {
private:
    std::unique_ptr<LegacyRectangle> adaptee;
public:
    RectangleAdapter() : adaptee(std::make_unique<LegacyRectangle>()) {}
    
    void draw(int x, int y, int size) override {
        // Предположим, что size определяет и ширину, и высоту
        adaptee->oldDraw(x, y, size, size);
    }
};

// Реализация
class RenderingEngine {
public:
    virtual void renderCircle(float x, float y, float radius) = 0;
    virtual ~RenderingEngine() = default;
};
 
// Конкретные реализации
class OpenGLRenderer : public RenderingEngine {
public:
    void renderCircle(float x, float y, float radius) override {
        std::cout << "Rendering circle using OpenGL at (" << x << "," << y
                  << ") with radius " << radius << std::endl;
    }
};
 
class DirectXRenderer : public RenderingEngine {
public:
    void renderCircle(float x, float y, float radius) override {
        std::cout << "Rendering circle using DirectX at (" << x << "," << y
                  << ") with radius " << radius << std::endl;
    }
};
 
// Абстракция
class Shape {
protected:
    RenderingEngine* renderer;
public:
    Shape(RenderingEngine* renderer) : renderer(renderer) {}
    virtual void draw() = 0;
    virtual ~Shape() = default;
};
 
// Уточнённая абстракция
class Circle : public Shape {
private:
    float x, y, radius;
public:
    Circle(float x, float y, float radius, RenderingEngine* renderer)
        : Shape(renderer), x(x), y(y), radius(radius) {}
        
    void draw() override {
        renderer->renderCircle(x, y, radius);
    }
};

// Компонент — общий интерфейс для листьев и составных объектов
class FileSystemNode {
protected:
    std::string name;
public:
    FileSystemNode(const std::string& name) : name(name) {}
    virtual void ls(int depth = 0) const = 0;
    virtual size_t getSize() const = 0;
    virtual ~FileSystemNode() = default;
};
 
// Лист
class File : public FileSystemNode {
private:
    size_t size;
public:
    File(const std::string& name, size_t size) 
        : FileSystemNode(name), size(size) {}
        
    void ls(int depth = 0) const override {
        std::cout << std::string(depth, ' ') << name << " (" << size << " bytes)" << std::endl;
    }
    
    size_t getSize() const override {
        return size;
    }
};
 
// Составной объект
class Directory : public FileSystemNode {
private:
    std::vector<std::unique_ptr<FileSystemNode>> children;
public:
    Directory(const std::string& name) : FileSystemNode(name) {}
    
    void add(std::unique_ptr<FileSystemNode> child) {
        children.push_back(std::move(child));
    }
    
    void ls(int depth = 0) const override {
        std::cout << std::string(depth, ' ') << name << "/" << std::endl;
        for (const auto& child : children) {
            child->ls(depth + 2);
        }
    }
    
    size_t getSize() const override {
        size_t totalSize = 0;
        for (const auto& child : children) {
            totalSize += child->getSize();
        }
        return totalSize;
    }
};

// Компонент — интерфейс для всех декораторов и основного объекта
class Coffee {
public:
    virtual double getCost() const = 0;
    virtual std::string getDescription() const = 0;
    virtual ~Coffee() = default;
};
 
// Конкретный компонент
class SimpleCoffee : public Coffee {
public:
    double getCost() const override {
        return 1.0;
    }
    
    std::string getDescription() const override {
        return "Simple coffee";
    }
};
 
// Базовый декоратор
class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> decoratedCoffee;
public:
    CoffeeDecorator(std::unique_ptr<Coffee> coffee)
        : decoratedCoffee(std::move(coffee)) {}
        
    double getCost() const override {
        return decoratedCoffee->getCost();
    }
    
    std::string getDescription() const override {
        return decoratedCoffee->getDescription();
    }
};
 
// Конкретные декораторы
class MilkDecorator : public CoffeeDecorator {
public:
    using CoffeeDecorator::CoffeeDecorator;
    
    double getCost() const override {
        return decoratedCoffee->getCost() + 0.5;
    }
    
    std::string getDescription() const override {
        return decoratedCoffee->getDescription() + ", with milk";
    }
};
 
class CaramelDecorator : public CoffeeDecorator {
public:
    using CoffeeDecorator::CoffeeDecorator;
    
    double getCost() const override {
        return decoratedCoffee->getCost() + 0.6;
    }
    
    std::string getDescription() const override {
        return decoratedCoffee->getDescription() + ", with caramel";
    }
};

auto myCoffee = std::make_unique<SimpleCoffee>();
std::cout << myCoffee->getDescription() << ": $" << myCoffee->getCost() << std::endl;
 
auto milkCoffee = std::make_unique<MilkDecorator>(std::move(myCoffee));
std::cout << milkCoffee->getDescription() << ": $" << milkCoffee->getCost() << std::endl;
 
auto fancyCoffee = std::make_unique<CaramelDecorator>(
                   std::make_unique<MilkDecorator>(
                   std::make_unique<SimpleCoffee>()));
std::cout << fancyCoffee->getDescription() << ": $" << fancyCoffee->getCost() << std::endl;

// Пример сложной подсистемы
class CPU {
public:
    void freeze() { std::cout << "CPU: Freezing..." << std::endl; }
    void jump(long position) { std::cout << "CPU: Jumping to position " << position << std::endl; }
    void execute() { std::cout << "CPU: Executing instructions..." << std::endl; }
};
 
class Memory {
public:
    void load(long position, const std::string& data) {
        std::cout << "Memory: Loading data at position " << position << std::endl;
    }
};
 
class HardDrive {
public:
    std::string read(long lba, int size) {
        std::cout << "HardDrive: Reading data from sector " << lba << std::endl;
        return "data";
    }
};
 
// Фасад, скрывающий сложность подсистемы
class ComputerFacade {
private:
    CPU cpu;
    Memory memory;
    HardDrive hardDrive;
    
public:
    void start() {
        cpu.freeze();
        memory.load(0, hardDrive.read(0, 1024));
        cpu.jump(0);
        cpu.execute();
    }
};

ComputerFacade computer;
computer.start();  // Запуск компьютера одной командой

// Приспособленец — текстура для частиц
class ParticleTexture {
private:
    std::string texturePath;
    std::vector<uint8_t> textureData;  // Потенциально большой объем данных
    
public:
    ParticleTexture(const std::string& path) : texturePath(path) {
        // Представим, что здесь происходит загрузка текстуры
        std::cout << "Loading texture: " << path << std::endl;
        textureData.resize(1024 * 1024, 1);  // 1MB "текстура"
    }
    
    void render(float x, float y, float scale, float rotation) const {
        std::cout << "Rendering texture at (" << x << "," << y 
                  << ") with scale " << scale << " and rotation " << rotation << std::endl;
    }
};
 
// Фабрика приспособленцев
class ParticleTextureFactory {
private:
    std::unordered_map<std::string, std::shared_ptr<ParticleTexture>> textures;
    
public:
    std::shared_ptr<ParticleTexture> getTexture(const std::string& path) {
        auto it = textures.find(path);
        if (it == textures.end()) {
            textures[path] = std::make_shared<ParticleTexture>(path);
        }
        return textures[path];
    }
};
 
// Клиентский код: частица, использующая приспособленца
class Particle {
private:
    std::shared_ptr<ParticleTexture> texture;  // Внутреннее, разделяемое состояние
    float x, y, scale, rotation;  // Внешнее, уникальное состояние
    
public:
    Particle(std::shared_ptr<ParticleTexture> tex, float x, float y)
        : texture(tex), x(x), y(y), scale(1.0f), rotation(0.0f) {}
        
    void update(float dt) {
        // Обновление внешнего состояния
        rotation += dt * 45.0f;  // 45 градусов в секунду
    }
    
    void render() const {
        texture->render(x, y, scale, rotation);
    }
};

// Интерфейс для реального объекта и заместителя
class Image {
public:
    virtual void display() = 0;
    virtual ~Image() = default;
};
 
// Реальный объект, который загружает изображение
class RealImage : public Image {
private:
    std::string filename;
    
    void loadFromDisk() {
        std::cout << "Loading image from disk: " << filename << std::endl;
        // Тяжелая операция загрузки изображения
    }
    
public:
    RealImage(const std::string& filename) : filename(filename) {
        loadFromDisk();
    }
    
    void display() override {
        std::cout << "Displaying image: " << filename << std::endl;
    }
};
 
// Заместитель, который отложит загрузку до момента вызова display()
class ProxyImage : public Image {
private:
    std::string filename;
    std::unique_ptr<RealImage> realImage;
    
public:
    ProxyImage(const std::string& filename) : filename(filename) {}
    
    void display() override {
        if (!realImage) {
            realImage = std::make_unique<RealImage>(filename);
        }
        realImage->display();
    }
};

enum class LogLevel {
    INFO,
    WARNING,
    ERROR
};
 
// Базовый обработчик
class Logger {
protected:
    std::unique_ptr<Logger> nextLogger;
    LogLevel level;
 
public:
    Logger(LogLevel level) : level(level) {}
 
    void setNext(std::unique_ptr<Logger> next) {
        nextLogger = std::move(next);
    }
 
    virtual void log(LogLevel messageLevel, const std::string& message) {
        if (this->level <= messageLevel) {
            writeMessage(message);
        }
        
        if (nextLogger) {
            nextLogger->log(messageLevel, message);
        }
    }
 
    virtual void writeMessage(const std::string& message) = 0;
    virtual ~Logger() = default;
};
 
// Конкретные обработчики
class ConsoleLogger : public Logger {
public:
    ConsoleLogger(LogLevel level) : Logger(level) {}
 
    void writeMessage(const std::string& message) override {
        std::cout << "Console Logger: " << message << std::endl;
    }
};
 
class FileLogger : public Logger {
public:
    FileLogger(LogLevel level) : Logger(level) {}
 
    void writeMessage(const std::string& message) override {
        std::cout << "File Logger: " << message << std::endl;
        // В реальности здесь был бы код для записи в файл
    }
};
 
class EmailLogger : public Logger {
public:
    EmailLogger(LogLevel level) : Logger(level) {}
 
    void writeMessage(const std::string& message) override {
        std::cout << "Email Logger: " << message << std::endl;
        // Отправка email в реальном коде
    }
};

// Строим цепочку обработчиков
auto consoleLogger = std::make_unique<ConsoleLogger>(LogLevel::INFO);
auto fileLogger = std::make_unique<FileLogger>(LogLevel::WARNING);
auto emailLogger = std::make_unique<EmailLogger>(LogLevel::ERROR);
 
fileLogger->setNext(std::move(emailLogger));
consoleLogger->setNext(std::move(fileLogger));
 
// Используем
consoleLogger->log(LogLevel::INFO, "This is an information");
consoleLogger->log(LogLevel::WARNING, "This is a warning");
consoleLogger->log(LogLevel::ERROR, "This is an error");

// Интерфейс команды
class Command {
public:
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual ~Command() = default;
};
 
// Получатель команды
class TextEditor {
private:
    std::string text;
public:
    void insertText(const std::string& newText) {
        text += newText;
        std::cout << "Text after insertion: " << text << std::endl;
    }
 
    void deleteText(int numChars) {
        if (numChars <= text.length()) {
            text.resize(text.length() - numChars);
            std::cout << "Text after deletion: " << text << std::endl;
        }
    }
 
    std::string getText() const {
        return text;
    }
};
 
// Конкретные команды
class InsertTextCommand : public Command {
private:
    TextEditor& editor;
    std::string textToInsert;
public:
    InsertTextCommand(TextEditor& editor, const std::string& text)
        : editor(editor), textToInsert(text) {}
 
    void execute() override {
        editor.insertText(textToInsert);
    }
 
    void undo() override {
        editor.deleteText(textToInsert.length());
    }
};
 
class DeleteTextCommand : public Command {
private:
    TextEditor& editor;
    int numChars;
    std::string deletedText;
public:
    DeleteTextCommand(TextEditor& editor, int chars)
        : editor(editor), numChars(chars) {}
 
    void execute() override {
        std::string currentText = editor.getText();
        if (numChars <= currentText.length()) {
            deletedText = currentText.substr(currentText.length() - numChars);
            editor.deleteText(numChars);
        }
    }
 
    void undo() override {
        editor.insertText(deletedText);
    }
};
 
// Инвокер — объект, вызывающий команды
class CommandInvoker {
private:
    std::vector<std::unique_ptr<Command>> executedCommands;
public:
    void executeCommand(std::unique_ptr<Command> command) {
        command->execute();
        executedCommands.push_back(std::move(command));
    }
 
    void undoLastCommand() {
        if (!executedCommands.empty()) {
            executedCommands.back()->undo();
            executedCommands.pop_back();
        }
    }
};

TextEditor editor;
CommandInvoker invoker;
 
// Вставляем текст
invoker.executeCommand(std::make_unique<InsertTextCommand>(editor, "Hello, "));
invoker.executeCommand(std::make_unique<InsertTextCommand>(editor, "World!"));
 
// Удаляем последние 6 символов
invoker.executeCommand(std::make_unique<DeleteTextCommand>(editor, 6));
 
// Отменяем последнюю команду (возвращаем "World!")
invoker.undoLastCommand();

// Агрегат — коллекция целых чисел с шагом
class NumberSequence {
private:
    int start;
    int step;
    int count;
public:
    NumberSequence(int start, int step, int count)
        : start(start), step(step), count(count) {}
 
    // Внутренний класс итератора
    class Iterator {
    private:
        const NumberSequence& sequence;
        int currentIndex;
    public:
        Iterator(const NumberSequence& seq, int index)
            : sequence(seq), currentIndex(index) {}
 
        bool operator!=(const Iterator& other) const {
            return currentIndex != other.currentIndex;
        }
 
        Iterator& operator++() {
            currentIndex++;
            return *this;
        }
 
        int operator*() const {
            return sequence.start + sequence.step * currentIndex;
        }
    };
 
    Iterator begin() const {
        return Iterator(*this, 0);
    }
 
    Iterator end() const {
        return Iterator(*this, count);
    }
};

NumberSequence evenNumbers(2, 2, 5);  // 2, 4, 6, 8, 10
 
for (int num : evenNumbers) {
    std::cout << num << " ";  // Выведет: 2 4 6 8 10
}

// Интерфейс посредника
class ChatMediator {
public:
    virtual void sendMessage(const std::string& msg, const std::string& userId) = 0;
    virtual void addUser(class User* user) = 0;
    virtual ~ChatMediator() = default;
};
 
// Абстрактный пользователь
class User {
protected:
    ChatMediator* mediator;
    std::string id;
public:
    User(ChatMediator* mediator, const std::string& id)
        : mediator(mediator), id(id) {}
 
    std::string getId() const {
        return id;
    }
 
    virtual void send(const std::string& msg) {
        mediator->sendMessage(msg, id);
    }
 
    virtual void receive(const std::string& msg) = 0;
    virtual ~User() = default;
};
 
// Конкретный пользователь
class ChatUser : public User {
public:
    using User::User;
 
    void receive(const std::string& msg) override {
        std::cout << id << " received: " << msg << std::endl;
    }
};
 
// Конкретный посредник
class ChatRoom : public ChatMediator {
private:
    std::unordered_map<std::string, User*> users;
public:
    void addUser(User* user) override {
        users[user->getId()] = user;
    }
 
    void sendMessage(const std::string& msg, const std::string& userId) override {
        for (auto& pair : users) {
            if (pair.first != userId) {
                pair.second->receive(msg);
            }
        }
    }
};

ChatRoom chatroom;
 
ChatUser* user1 = new ChatUser(&chatroom, "Alice");
ChatUser* user2 = new ChatUser(&chatroom, "Bob");
ChatUser* user3 = new ChatUser(&chatroom, "Charlie");
 
chatroom.addUser(user1);
chatroom.addUser(user2);
chatroom.addUser(user3);
 
user1->send("Hello, everyone!");  // Bob и Charlie получат сообщение
user2->send("Hi, Alice!");        // Alice и Charlie получат сообщение
 
delete user1;
delete user2;
delete user3;

// Снимок - объект, хранящий состояние редактора
class EditorMemento {
private:
    std::string content;
    
public:
    explicit EditorMemento(const std::string& content) : content(content) {}
    
    std::string getContent() const {
        return content;
    }
};
 
// Создатель снимков - текстовый редактор
class TextEditor {
private:
    std::string content;
    
public:
    void write(const std::string& words) {
        content += words;
    }
    
    std::string getContent() const {
        return content;
    }
    
    // Создаёт снимок текущего состояния
    EditorMemento save() const {
        return EditorMemento(content);
    }
    
    // Восстанавливает состояние из снимка
    void restore(const EditorMemento& memento) {
        content = memento.getContent();
    }
};
 
// Опекун - хранит историю снимков
class History {
private:
    std::vector<EditorMemento> mementos;
    
public:
    void push(const EditorMemento& memento) {
        mementos.push_back(memento);
    }
    
    EditorMemento pop() {
        auto memento = mementos.back();
        mementos.pop_back();
        return memento;
    }
};

// Абстрактный наблюдатель
class Observer {
public:
    virtual void update(const std::string& message) = 0;
    virtual ~Observer() = default;
};
 
// Конкретные наблюдатели
class EmailNotifier : public Observer {
private:
    std::string email;
    
public:
    EmailNotifier(const std::string& email) : email(email) {}
    
    void update(const std::string& message) override {
        std::cout << "Sending email to " << email << ": " << message << std::endl;
    }
};
 
class SMSNotifier : public Observer {
private:
    std::string phoneNumber;
    
public:
    SMSNotifier(const std::string& phoneNumber) : phoneNumber(phoneNumber) {}
    
    void update(const std::string& message) override {
        std::cout << "Sending SMS to " << phoneNumber << ": " << message << std::endl;
    }
};
 
// Издатель (наблюдаемый объект)
class MessagePublisher {
private:
    std::vector<Observer*> observers;
    
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    
    void detach(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }
    
    void notify(const std::string& message) {
        for (Observer* observer : observers) {
            observer->update(message);
        }
    }
    
    void createMessage(const std::string& message) {
        std::cout << "New message created: " << message << std::endl;
        notify(message);
    }
};

class ModernPublisher {
private:
    std::vector<std::function<void(const std::string&)>> callbacks;
    
public:
    void subscribe(std::function<void(const std::string&)> callback) {
        callbacks.push_back(callback);
    }
    
    void publish(const std::string& message) {
        for (const auto& callback : callbacks) {
            callback(message);
        }
    }
};

// Контекст — торговый автомат
class VendingMachine;
 
// Абстрактное состояние
class State {
protected:
    VendingMachine* vendingMachine;
    
public:
    virtual void insertCoin() = 0;
    virtual void ejectCoin() = 0;
    virtual void selectDrink() = 0;
    virtual void dispense() = 0;
    virtual ~State() = default;
    
    void setVendingMachine(VendingMachine* machine) {
        vendingMachine = machine;
    }
};
 
// Конкретные состояния будут определены после класса контекста

// Антипаттерн: Синглтон как глобальная переменная
class GlobalConfig {
private:
    static GlobalConfig* instance;
    std::map<std::string, std::string> settings;
    
    GlobalConfig() {}
    
public:
    static GlobalConfig* getInstance() {
        if (instance == nullptr) {
            instance = new GlobalConfig();
        }
        return instance;
    }
    
    void setSetting(const std::string& key, const std::string& value) {
        settings[key] = value;
    }
    
    std::string getSetting(const std::string& key) {
        return settings[key];
    }
};
 
// Инициализация статической переменной
GlobalConfig* GlobalConfig::instance = nullptr;
 
// Использование в разных частях программы:
void someFunction() {
    GlobalConfig::getInstance()->setSetting("timeout", "30");
}
 
void anotherFunction() {
    std::string timeout = GlobalConfig::getInstance()->getSetting("timeout");
}

class Config {
public:
    virtual std::string getSetting(const std::string& key) = 0;
    virtual void setSetting(const std::string& key, const std::string& value) = 0;
    virtual ~Config() = default;
};
 
class FileConfig : public Config {
    // Реализация
};
 
class DbConfig : public Config {
    // Реализация
};
 
class Service {
private:
    Config& config;
    
public:
    Service(Config& cfg) : config(cfg) {}
    
    void doSomething() {
        std::string timeout = config.getSetting("timeout");
        // Использование timeout
    }
};