Entwurfsmuster

void move(RobotMode* mode) {
    mode->move();
}

void move(int x, int y) override {
    for (auto& unit : units) {
        unit->move(x, y);
    }
}

#include <iostream>
#include <string>
 
// --- Strategy Interface ---
class IEditMode {
public:
    virtual void handleInput(std::string& text, int& cursorPos, char input) = 0;
    virtual ~IEditMode() {}
};
 
// --- Einfügen-Modus ---
class InsertMode : public IEditMode {
public:
    void handleInput(std::string& text, int& cursorPos, char input) override {
        text.insert(cursorPos, 1, input);
        cursorPos++;
    }
};
 
// --- Löschen-Modus ---
class DeleteMode : public IEditMode {
public:
    void handleInput(std::string& text, int& cursorPos, char input) override {
        if (input == 'd' && cursorPos > 0 && !text.empty()) {
            text.erase(cursorPos - 1, 1);
            cursorPos--;
        }
    }
};
 
// --- Auswahl-Modus ---
class SelectMode : public IEditMode {
public:
    void handleInput(std::string&, int&, char) override {
        std::cout << "Textauswahl aktiviert (keine weitere Funktionalität hier).\n";
    }
};
 
// --- TextEditor-Klasse ---
class TextEditor {
private:
    IEditMode* mode; // Aktueller Bearbeitungsmodus
    std::string text;
    int cursorPos;
 
    // Statische Instanzen der Modi zur Wiederverwendung
    InsertMode insertMode;
    DeleteMode deleteMode;
    SelectMode selectMode;
 
public:
    TextEditor() : mode(nullptr), cursorPos(0) {}
 
    void switchMode(char modeChar) {
        switch (modeChar) {
            case 'i': mode = &insertMode; std::cout << "Modus: Einfügen\n"; break;
            case 'd': mode = &deleteMode; std::cout << "Modus: Löschen\n"; break;
            case 's': mode = &selectMode; std::cout << "Modus: Auswahl\n"; break;
            default: std::cout << "Unbekannter Modus!\n"; return;
        }
    }
 
    void input(char ch) {
        if (mode) {
            mode->handleInput(text, cursorPos, ch);
        } else {
            std::cout << "Kein Bearbeitungsmodus aktiv!\n";
        }
    }
 
    void display() const {
        std::cout << "Text: \"" << text << "\"  Cursor: " << cursorPos << std::endl;
    }
};
 
// --- Hauptfunktion zur Demonstration ---
int main() {
    TextEditor editor;
 
    editor.switchMode('i'); // Wechsel zu Einfügemodus
    editor.input('H');
    editor.input('e');
    editor.input('l');
    editor.input('l');
    editor.input('o');
    editor.display();
 
    editor.switchMode('d'); // Wechsel zu Löschmodus
    editor.input('d'); // Löscht das letzte Zeichen
    editor.display();
 
    editor.switchMode('s'); // Wechsel zu Auswahlmodus
    editor.input('s'); // Aktiviert die Auswahl (Dummy-Funktion)
    editor.display();
 
    return 0;
}

IAudioTrack* track = new EchoEffect(
    new AmplifyEffect(
        new DenoiseEffect(
            new AudioTrack()
        )
    )
);
track->play();

class EchoEffect : public EffectDecorator {
    public:
        EchoEffect(IAudioTrack* track) : EffectDecorator(track) {}
 
        void play() override {
            track->play();  // Erst das vorherige Audio abspielen
            applyEcho();    // Dann Echo-Effekt hinzufügen
        }
 
        void applyEcho() {
            std::cout << "[Echo-Effekt angewendet]\n";
        }
};

class Strategy {
    public:
        virtual void execute() = 0;
};
 
class ConcreteStrategyA : public Strategy {
    public:
        void execute() override {
            std::cout << "ConcreteStrategyA" << std::endl;
        }
};
 
class ConcreteStrategyB : public Strategy {
    public:
        void execute() override {
            std::cout << "ConcreteStrategyB" << std::endl;
        }
};
 
class Context {
    private:
        Strategy* strategy;
    public:
        void setStrategy(Strategy* strategy) {
            this->strategy = strategy;
        }
};

#include <iostream>
 
// Vorwärtsdeklaration, damit jeder Zustand auf das Context-Objekt zugreifen kann
class Context;
 
// --- State-Interface ---
class State {
public:
    virtual void handle(Context* context) = 0;
    virtual ~State() {}
};
 
// --- Konkreter Zustand A ---
class ConcreteStateA : public State {
public:
    void handle(Context* context) override;
};
 
// --- Konkreter Zustand B ---
class ConcreteStateB : public State {
public:
    void handle(Context* context) override;
};
 
// --- Context-Klasse (enthält aktuellen Zustand) ---
class Context {
private:
    State* currentState;
public:
    Context(State* initialState) : currentState(initialState) {}
 
    void setState(State* newState) {
        currentState = newState;
    }
 
    void request() {
        currentState->handle(this);  // Zustand entscheidet selbst, ob er wechselt
    }
};
 
// Implementierung der Zustandswechsel
void ConcreteStateA::handle(Context* context) {
    std::cout << "Aktueller Zustand: A → Wechsel zu Zustand B.\n";
    context->setState(new ConcreteStateB());  // Zustand ändert sich selbst
}
 
void ConcreteStateB::handle(Context* context) {
    std::cout << "Aktueller Zustand: B → Wechsel zu Zustand A.\n";
    context->setState(new ConcreteStateA());  // Zustand ändert sich selbst
}
 
// --- Hauptprogramm ---
int main() {
    Context context(new ConcreteStateA());  // Start mit Zustand A
 
    context.request();  // A → B
    context.request();  // B → A
    context.request();  // A → B
 
    return 0;
}

class Observer {
    public:
        virtual void update(const std::string& message) = 0;
        virtual ~Observer() = default;
};
 
class Subject {
    public:
        virtual void registerObserver(Observer* observer) = 0;
        virtual void removeObserver(Observer* observer) = 0;
        virtual void notifyObservers() = 0;
};
 
class ConcreteObserver : public Observer {
    public:
        ConcreteObserver(const std::string& name) : name(name) {}
        void update(const std::string& message) override {
            std::cout << name << " received message: " << message << std::endl;
        }
};
 
int main() {
    Subject subject;
    
    ConcreteObserver observer1("Observer 1");
    ConcreteObserver observer2("Observer 2");
    ConcreteObserver observer3("Observer 3");
 
    subject.registerObserver(&observer1);
    subject.registerObserver(&observer2);
    subject.registerObserver(&observer3);
 
    subject.notifyObservers();
 
    subject.removeObserver(&observer2);
    subject.notifyObservers();
    return 0;
}

class Model {
    private:
        std::string username;
    public:
        void setUsername(std::string& name) {
            username = name;
        }
        std::string getUsername() const {
            return username;
        }
};
 
class View {
    public:
        void displayUser(const std::string& username) const {
            std::cout << "User: " << username << std::endl;
        }
};
 
class Controller {
    private:
        Model& model;
        View& view;
    public:
        Controller(Model& model, View& view) : model(model), view(view) {}
        void setUsername(const std::string& username) {
            model.setUsername(username);
        }
        void updateView() const {
            view.displayUser(model.getUsername());
        }
};
 
int main() {
    Model model;
    View view;
    Controller controller(model, view);
    controller.setUsername("John");
    controller.updateView();
    return 0;
}

#include <iostream>
#include <queue>
#include <string>
#include <mutex>
#include <thread>
#include <condition_variable>
 
class Actor {
public:
    virtual void receive(const std::string& message) = 0;
    virtual ~Actor() {}
};
 
class ConcreteActor : public Actor {
private:
    std::queue<std::string> messageQueue;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;
public:
    // Simuliert das Senden einer Nachricht an den Actor
    void send(const std::string& message) {
        std::lock_guard<std::mutex> lock(mtx);
        messageQueue.push(message);
        cv.notify_one();
    }
    
    // Der Actor läuft in einem eigenen Thread und verarbeitet Nachrichten asynchron
    void run() {
        while (true) {
            std::unique_lock<std::mutex> lock(mtx);
            cv.wait(lock, [this]() { return !messageQueue.empty() || stop; });
            if (stop && messageQueue.empty()) break;
            std::string msg = messageQueue.front();
            messageQueue.pop();
            lock.unlock();
            receive(msg);
        }
    }
    
    void stopProcessing() {
        std::lock_guard<std::mutex> lock(mtx);
        stop = true;
        cv.notify_all();
    }
    
    void receive(const std::string& message) override {
        std::cout << "ConcreteActor received: " << message << std::endl;
    }
};
 
int main() {
    ConcreteActor actor;
    // Starte den Actor in einem eigenen Thread
    std::thread actorThread(&ConcreteActor::run, &actor);
    
    actor.send("Hallo Actor!");
    actor.send("Nachricht 2");
    
    // Beenden
    std::this_thread::sleep_for(std::chrono::seconds(1));
    actor.stopProcessing();
    actorThread.join();
    
    return 0;
}

class Component {
    public:
        virtual void operation() = 0;
};
 
class ConcreteComponent : public Component {
    public:
        void operation() override {
            std::cout << "ConcreteComponent" << std::endl;
        }
};
 
class Decorator : public Component {
    private:
        Component* component;
    public:
        void operation() override {
            component->operation();
        }
};
 
class ConcreteDecorator : public Decorator {
    public:
        void operation() override {
            Decorator::operation();
            std::cout << "ConcreteDecorator" << std::endl;
        }
};
 
int main() {
    ConcreteComponent* concreteComponent = new ConcreteComponent();
    ConcreteDecorator* concreteDecorator = new ConcreteDecorator();
    concreteDecorator->setComponent(concreteComponent);
    concreteDecorator->operation();
    return 0;
}

class Component {
    public:
        virtual void add(Component* component) = 0;
        virtual void remove(Component* component) = 0;
        virtual void getChild(int index) = 0;
};
 
class Composite : public Component {
    private:
        std::vector<Component*> children;
    public:
        void add(Component* component) override {
            children.push_back(component);
        }
};
 
class Leaf : public Component {
    public:
        void add(Component* component) override {
            std::cout << "Leaf cannot add component" << std::endl;
        }
};
 
int main() {
    Composite* composite = new Composite();
    Leaf* leaf = new Leaf();
    Leaf* leaf2 = new Leaf();
    composite->add(leaf);
    composite->add(leaf2);
 
    Composite* composite2 = new Composite();
    Leaf* leaf3 = new Leaf();
    composite2->add(composite);
    composite2->add(leaf3);
    return 0;
}

class Singleton {
    private:
        static Singleton* instance;
        Singleton() {
            std::cout << "Singleton created" << std::endl;
        }
    public:
        static Singleton* getInstance() {
            if (instance == nullptr) {
                instance = new Singleton();
            }
            return instance;
        }
};
 
int main() {
    Singleton* singleton = Singleton::getInstance();
    Singleton* singleton2 = Singleton::getInstance();
    return 0;
}

#include <iostream>
#include <string>
 
// Abstrakte Produktklassen
class AbstractProductA {
public:
    virtual void doSomething() = 0;
    virtual ~AbstractProductA() {}
};
 
class AbstractProductB {
public:
    virtual void doSomethingElse() = 0;
    virtual ~AbstractProductB() {}
};
 
// Konkrete Produkte der Familie 1
class ConcreteProductA1 : public AbstractProductA {
public:
    void doSomething() override {
        std::cout << "ConcreteProductA1 doing something." << std::endl;
    }
};
 
class ConcreteProductB1 : public AbstractProductB {
public:
    void doSomethingElse() override {
        std::cout << "ConcreteProductB1 doing something else." << std::endl;
    }
};
 
// Abstrakte Fabrik
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
    virtual ~AbstractFactory() {}
};
 
// Konkrete Fabrik 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};
 
int main() {
    AbstractFactory* factory = new ConcreteFactory1();
    AbstractProductA* productA = factory->createProductA();
    AbstractProductB* productB = factory->createProductB();
    
    productA->doSomething();
    productB->doSomethingElse();
    
    delete productA;
    delete productB;
    delete factory;
    
    return 0;
}