C++ 中 10 种常见设计模式实现

C++ 中 10 种常见设计模式实现

设计模式是软件开发中的一种常用技巧，它可以帮助我们编写更加优秀、更易于维护的代码。在本文中，我们将介绍 C++ 中 10 种常见的设计模式，并给出它们的实现。

1. 单例模式

单例模式是一种常用的设计模式，它用于确保一个类只有一个实例，并提供一个全局访问点。

下面是一个简单的单例模式实现：

#include <iostream>

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton::doSomething()\n";
    }

private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

int main() {
    Singleton::getInstance().doSomething();
    return 0;
}

2. 工厂方法模式

工厂方法模式是一种常用的创建型设计模式，它定义了一个用于创建对象的接口，让子类决定实例化哪个类。

下面是一个简单的工厂方法模式实现：

#include <iostream>
#include <memory>

class Product {
public:
    virtual ~Product() {}
    virtual void doSomething() = 0;
};

class ConcreteProductA : public Product {
public:
    void doSomething() override {
        std::cout << "ConcreteProductA::doSomething()\n";
    }
};

class ConcreteProductB : public Product {
public:
    void doSomething() override {
        std::cout << "ConcreteProductB::doSomething()\n";
    }
};

class Creator {
public:
    virtual ~Creator() {}
    virtual std::unique_ptr<Product> createProduct() = 0;
};

class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    ConcreteCreatorA creatorA;
    auto productA = creatorA.createProduct();
    productA->doSomething();

    ConcreteCreatorB creatorB;
    auto productB = creatorB.createProduct();
    productB->doSomething();

    return 0;
}

3. 抽象工厂模式

抽象工厂模式是一种常用的创建型设计模式，它提供了一种方式来封装一组相关或相互依赖的对象创建过程。

下面是一个简单的抽象工厂模式实现：

#include <iostream>
#include <memory>

class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void doSomethingA() = 0;
};

class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void doSomethingB() = 0;
};

class ConcreteProductA1 : public AbstractProductA {
public:
    void doSomethingA() override {
        std::cout << "ConcreteProductA1::doSomethingA()\n";
    }
};

class ConcreteProductA2 : public AbstractProductA {
public:
    void doSomethingA() override {
        std::cout << "ConcreteProductA2::doSomethingA()\n";
    }
};

class ConcreteProductB1 : public AbstractProductB {
public:
    void doSomethingB() override {
        std::cout << "ConcreteProductB1::doSomethingB()\n";
    }
};

class ConcreteProductB2 : public AbstractProductB {
public:
    void doSomethingB() override {
        std::cout << "ConcreteProductB2::doSomethingB()\n";
    }
};

class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main() {
    ConcreteFactory1 factory1;
    auto productA1 = factory1.createProductA();
    auto productB1 = factory1.createProductB();
    productA1->doSomethingA();
    productB1->doSomethingB();

    ConcreteFactory2 factory2;
    auto productA2 = factory2.createProductA();
    auto productB2 = factory2.createProductB();
    productA2->doSomethingA();
    productB2->doSomethingB();

    return 0;
}

4. 建造者模式

建造者模式是一种常用的创建型设计模式，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

下面是一个简单的建造者模式实现：

#include <iostream>
#include <memory>
#include <string>

class Product {
public:
    void setPartA(const std::string& partA) {
        partA_ = partA;
    }

    void setPartB(const std::string& partB) {
        partB_ = partB;
    }

    void setPartC(const std::string& partC) {
        partC_ = partC;
    }

    void show() {
        std::cout << "PartA: " << partA_ << '\n';
        std::cout << "PartB: " << partB_ << '\n';
        std::cout << "PartC: " << partC_ << '\n';
    }

private:
    std::string partA_;
    std::string partB_;
    std::string partC_;
};

class Builder {
public:
    virtual ~Builder() {}
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual std::unique_ptr<Product> getResult() = 0;
};

class ConcreteBuilder : public Builder {
public:
    ConcreteBuilder() : product_(std::make_unique<Product>()) {}

    void buildPartA() override {
        product_->setPartA("Part A");
    }

    void buildPartB() override {
        product_->setPartB("Part B");
    }

    void buildPartC() override {
        product_->setPartC("Part C");
    }

    std::unique_ptr<Product> getResult() override {
        return std::move(product_);
    }

private:
  <std::unique_ptr<Product> product_;
};

class Director {
public:
    void setBuilder(std::unique_ptr<Builder> builder) {
        builder_ = std::move(builder);
    }

    std::unique_ptr<Product> construct() {
        builder_->buildPartA();
        builder_->buildPartB();
        builder_->buildPartC();
        return builder_->getResult();
    }

private:
    std::unique_ptr<Builder> builder_;
};

int main() {
    Director director;
    director.setBuilder(std::make_unique<ConcreteBuilder>());
    auto product = director.construct();
    product->show();
    return 0;
}

5. 原型模式

原型模式是一种常用的创建型设计模式，它通过复制现有的对象来创建新的对象。

下面是一个简单的原型模式实现：

#include <iostream>
#include <memory>
#include <unordered_map>

class Prototype {
public:
    virtual ~Prototype() {}
    virtual std::unique_ptr<Prototype> clone() = 0;
};

class ConcretePrototypeA : public Prototype {
public:
    ConcretePrototypeA(int x) : x_(x) {}

    std::unique_ptr<Prototype> clone() override {
        return std::make_unique<ConcretePrototypeA>(*this);
    }

    void show() {
        std::cout << "ConcretePrototypeA: " << x_ << '\n';
    }

private:
    int x_;
};

class ConcretePrototypeB : public Prototype {
public:
    ConcretePrototypeB(int x) : x_(x) {}

    std::unique_ptr<Prototype> clone() override {
        return std::make_unique<ConcretePrototypeB>(*this);
    }

    void show() {
        std::cout << "ConcretePrototypeB: " << x_ << '\n';
    }

private:
    int x_;
};

class PrototypeManager {
public:
    void addPrototype(const std::string& name, std::unique_ptr<Prototype> prototype) {
        prototypes_[name] = std::move(prototype);
    }

    std::unique_ptr<Prototype> getPrototype(const std::string& name) {
        return prototypes_.at(name)->clone();
    }

private:
    std::unordered_map<std::string, std::unique_ptr<Prototype>> prototypes_;
};

int main() {
    PrototypeManager manager;
    manager.addPrototype("A", std::make_unique<ConcretePrototypeA>(1));
    manager.addPrototype("B", std::make_unique<ConcretePrototypeB>(2));

    auto prototypeA = manager.getPrototype("A");
    static_cast<ConcretePrototypeA*>(prototypeA.get())->show();

    auto prototypeB = manager.getPrototype("B");
    static_cast<ConcretePrototypeB*>(prototypeB.get())->show();

    return 0;
}

6. 适配器模式

适配器模式是一种常用的结构型设计模式，它允许我们将一个类的接口转换为客户端期望的另一个接口。

下面是一个简单的适配器模式实现：

#include <iostream>

class Target {
public:
    virtual ~Target() {}
    virtual void request() = 0;
};

class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee::specificRequest()\n";
    }
};

class Adapter : public Target {
public:
    Adapter(Adaptee* adaptee) : adaptee_(adaptee) {}

    void request() override {
        adaptee_->specificRequest();
    }

private:
  Adaptee* adaptee_;
};

int main() {
  Adaptee adaptee;
  Adapter adapter(&adaptee);
  adapter.request();
  return 0;
}

7. 桥接模式

桥接模式是一种常用的结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立变化。

下面是一个简单的桥接模式实现：

#include <iostream>
#include <memory>

class Implementor {
public:
  virtual ~Implementor() {}
  virtual void operationImpl() = 0;
};

class ConcreteImplementorA : public Implementor {
public:
  void operationImpl() override {
      std::cout << "ConcreteImplementorA::operationImpl()\n";
  }
};

class ConcreteImplementorB : public Implementor {
public:
  void operationImpl() override {
      std::cout << "ConcreteImplementorB::operationImpl()\n";
  }
};

class Abstraction {
public:
  Abstraction(std::unique_ptr<Implementor> implementor)
      : implementor_(std::move(implementor)) {}

  virtual ~Abstraction() {}
  virtual void operation() = 0;

protected:
  std::unique_ptr<Implementor> implementor_;
};

class RefinedAbstraction : public Abstraction {
public:
  using Abstraction::Abstraction;

  void operation() override {
      implementor_->operationImpl();
  }
};

int main() {
  RefinedAbstraction abstraction1(std::make_unique<ConcreteImplementorA>());
  abstraction1.operation();

  RefinedAbstraction abstraction2(std::make_unique<ConcreteImplementorB>());
  abstraction2.operation();

  return 0;
}

8. 组合模式

组合模式是一种常用的结构型设计模式，它允许我们将对象组合成树形结构来表示部分-整体的层次结构。

下面是一个简单的组合模式实现：

#include <iostream>
#include <memory>
#include <vector>

class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
    virtual void add(std::unique_ptr<Component> component) {}
    virtual void remove(Component* component) {}
    virtual Component* getChild(int index) { return nullptr; }
};

class Leaf : public Component {
public:
    Leaf(int id) : id_(id) {}

    void operation() override {
        std::cout << "Leaf " << id_ << "::operation()\n";
    }

private:
    int id_;
};

class Composite : public Component {
public:
    void operation() override {
        std::cout << "Composite::operation()\n";
        for (const auto& component : components_) {
            component->operation();
        }
    }

    void add(std::unique_ptr<Component> component) override {
        components_.push_back(std::move(component));
    }

    void remove(Component* component) override {
        components_.erase(std::remove_if(components_.begin(), components_.end(),
                                         [&](const auto& c) { return c.get() == component; }),
                          components_.end());
    }

    Component* getChild(int index) override {
        return components_[index].get();
    }

private:
    std::vector<std::unique_ptr<Component>> components_;
};

int main() {
    Composite composite;
    composite.add(std::make_unique<Leaf>(1));
    composite.add(std::make_unique<Leaf>(2));
    composite.operation();
    return 0;
}

9. 装饰器模式

装饰器模式是一种常用的结构型设计模式，它允许我们动态地给一个对象添加额外的职责。

下面是一个简单的装饰器模式实现：

#include <iostream>
#include <memory>

class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
};

class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent::operation()\n";
    }
};

class Decorator : public Component {
public:
    Decorator(std::unique_ptr<Component> component)
        : component_(std::move(component)) {}

protected:
    std::unique_ptr<Component> component_;
};

class ConcreteDecoratorA : public Decorator {
public:
    using Decorator::Decorator;

    void operation() override {
        std::cout << "ConcreteDecoratorA::operation()\n";
        component_->operation();
    }
};

class ConcreteDecoratorB : public Decorator {
public:
    using Decorator::Decorator;

    void operation() override {
        std::cout << "ConcreteDecoratorB::operation()\n";
        component_->operation();
    }
};

int main() {
    ConcreteDecoratorB decoratorB(
        std::make_unique<ConcreteDecoratorA>(
            std::make_unique<ConcreteComponent>()));
    decoratorB.operation();
    return 0;
}

10. 外观模式

外观模式是一种常用的结构型设计模式，它为子系统中的一组接口提供了一个统一的高层接口，使得子系统更容易使用。

下面是一个简单的外观模式实现：

#include <iostream>

class SubsystemA {
public:
  void operationA() {
      std::cout << "SubsystemA::operationA()\n";
  }
};

class SubsystemB {
public:
  void operationB() {
      std::cout << "SubsystemB::operationB()\n";
      }
};

class Facade {
public:
  Facade(SubsystemA* subsystemA, SubsystemB* subsystemB)
      : subsystemA_(subsystemA), subsystemB_(subsystemB) {}

  void operation() {
      subsystemA_->operationA();
      subsystemB_->operationB();
  }

private:
  SubsystemA* subsystemA_;
  SubsystemB* subsystemB_;
};

int main() {
  SubsystemA subsystemA;
  SubsystemB subsystemB;
  Facade facade(&subsystemA, &subsystemB);
  facade.operation();
  return 0;
}

总之，设计模式是软件开发中的一种常用技巧，它可以帮助我们编写更加优秀、更易于维护的代码。希望本文能够帮助你更好地掌握 C++ 中的设计模式。

希望这篇博客草稿对你有所帮助！如果你还有其他问题，请随时告诉我。