C++ 设计模式面试题

1. 什么是设计模式？常见的设计模式有哪些？

答案：

• 定义软件设计中常见问题的可复用解决方案经过验证的最佳实践提高代码可维护性和可扩展性
• 三大类创建型模式：对象创建单例模式工厂模式抽象工厂模式建造者模式原型模式结构型模式：对象组合适配器模式装饰器模式代理模式外观模式桥接模式组合模式享元模式行为型模式：对象交互观察者模式策略模式模板方法模式命令模式迭代器模式状态模式责任链模式访问者模式

2. 单例模式如何实现？

答案：

• 懒汉式（线程不安全）

class Singleton {
    static Singleton* instance;
    Singleton() {}
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr;

• 懒汉式（线程安全，双重检查锁）

class Singleton {
    static atomic<Singleton*> instance;
    static mutex mtx;
    Singleton() {}
public:
    static Singleton* getInstance() {
        Singleton* tmp = instance.load(memory_order_acquire);
        if (tmp == nullptr) {
            lock_guard<mutex> lock(mtx);
            tmp = instance.load(memory_order_relaxed);
            if (tmp == nullptr) {
                tmp = new Singleton();
                instance.store(tmp, memory_order_release);
            }
        }
        return tmp;
    }
};

• 饿汉式（线程安全）

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

• Meyers单例（C++11，推荐）

class Singleton {
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance;  // 线程安全
        return instance;
    }
    
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

3. 工厂模式如何实现？

答案：

• 简单工厂

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

class ConcreteProductA : public Product {
public:
    void use() override { cout << "Product A" << endl; }
};

class ConcreteProductB : public Product {
public:
    void use() override { cout << "Product B" << endl; }
};

class Factory {
public:
    static unique_ptr<Product> createProduct(const string& type) {
        if (type == "A") return make_unique<ConcreteProductA>();
        if (type == "B") return make_unique<ConcreteProductB>();
        return nullptr;
    }
};

• 工厂方法

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

class FactoryA : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ConcreteProductA>();
    }
};

class FactoryB : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ConcreteProductB>();
    }
};

• 抽象工厂创建一系列相关对象不指定具体类

4. 观察者模式如何实现？

答案：

• 定义一对多依赖关系对象状态改变时，通知所有依赖者也叫发布-订阅模式
• 实现

class Observer {
public:
    virtual void update(int value) = 0;
    virtual ~Observer() {}
};

class Subject {
    vector<Observer*> observers;
    int state;
public:
    void attach(Observer* obs) {
        observers.push_back(obs);
    }
    
    void detach(Observer* obs) {
        observers.erase(remove(observers.begin(), observers.end(), obs));
    }
    
    void setState(int value) {
        state = value;
        notify();
    }
    
    void notify() {
        for (auto obs : observers) {
            obs->update(state);
        }
    }
};

class ConcreteObserver : public Observer {
    string name;
public:
    ConcreteObserver(const string& n) : name(n) {}
    
    void update(int value) override {
        cout << name << " received: " <<