建造者模式

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示

#include <iostream>
#include <vector>
#include <string>

class Computer {
private:
    std::vector<std::string> parts;

public:
    void Add(const std::string& part) {
        parts.push_back(part);
    }

    void Show() {
        for (const auto& part : parts) {
            std::cout << "Component: " << part << " assembled." << std::endl;
        }
        std::cout << "Computer assembled." << std::endl;
    }
};

class Builder {
public:
    virtual void BuildCPU() = 0;
    virtual void BuildMainboard() = 0;
    virtual void BuildHD() = 0;
    virtual Computer* GetComputer() = 0;
    virtual ~Builder() {}
};

class ConcreteBuilder : public Builder {
private:
    Computer* computer;

public:
    ConcreteBuilder() {
        computer = new Computer();
    }

    void BuildCPU() override {
        computer->Add("CPU");
    }

    void BuildMainboard() override {
        computer->Add("Mainboard");
    }

    void BuildHD() override {
        computer->Add("Hard Disk");
    }

    Computer* GetComputer() override {
        return computer;
    }

    ~ConcreteBuilder() {
        delete computer;
    }
};

class Director {
public:
    void Construct(Builder* builder) {
        builder->BuildCPU();
        builder->BuildMainboard();
        builder->BuildHD();
    }
};

int main() {
    Director director;
    ConcreteBuilder builder;

    director.Construct(&builder);
    Computer* computer = builder.GetComputer();
    computer->Show();

    delete computer;
    return 0;
}

适配器模式

适配器模式将一个类的接口转换成客户端期望的另一个接口，消除由于接口不兼容而导致的类无法一起工作的问题。

#include <iostream>

class Source {
public:
    void method1() {
        std::cout << "This is original method..." << std::endl;
    }
};

class Targetable {
public:
    virtual void method1() = 0;
    virtual void method2() = 0;
    virtual ~Targetable() {}
};

class Adapter : public Source, public Targetable {
public:
    void method2() override {
        std::cout << "This is the targetable method..." << std::endl;
    }
};

int main() {
    Targetable* target = new Adapter();
    target->method1();
    target->method2();
    delete target;
    return 0;
}