这是一个嵌入式大厂面试题专栏，每天更新高频面试题。专栏将包含题目描述、详细解析、相关知识点扩展以及实际代码示例。内容涵盖操作系统、驱动开发、通信协议等核心领域，并结合实际项目经验进行分析。每道题目都会附带面试官可能的追问方向，帮助大家更好地准备面试！

来源：牛客网C++中设计模式常见面试题

设计模式是软件开发中解决特定问题的经典方案，在C++面试中经常会被问到。以下是一些常见的C++设计模式面试题及其解答：

1. 单例模式 (Singleton Pattern)

基本概念

单例模式确保一个类只有一个实例，并提供一个全局访问点。

面试题：如何实现线程安全的单例模式？

// 懒汉式（线程安全，使用双检锁）
class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex_;
    
    // 私有构造函数
    Singleton() {}
    // 禁止拷贝和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {  // 第一次检查
            std::lock_guard<std::mutex> lock(mutex_);
            if (instance == nullptr) {  // 第二次检查
                instance = new Singleton();
            }
        }
        return instance;
    }
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex_;

// 更现代的实现：Meyers' Singleton (C++11)
class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
public:
    static Singleton& getInstance() {
        static Singleton instance;  // C++11保证线程安全的初始化
        return instance;
    }
};

相关问题

1. 单例模式有哪些实现方式？懒汉式：第一次使用时初始化饿汉式：程序启动时初始化Meyers' Singleton：利用C++11的静态局部变量初始化特性
2. 单例模式的优缺点是什么？优点：控制实例数量，节省资源，提供全局访问点缺点：隐藏依赖关系，违反单一职责原则，不易测试

2. 工厂模式 (Factory Pattern)

基本概念

工厂模式提供一个创建对象的接口，让子类决定实例化哪个类。

面试题：实现一个简单工厂和工厂方法模式

// 产品基类
class Product {
public:
    virtual ~Product() {}
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 简单工厂
class SimpleFactory {
public:
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

// 工厂方法模式 - 工厂基类
class Factory {
public:
    virtual ~Factory() {}
    virtual Product* createProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

相关问题

1. 简单工厂、工厂方法和抽象工厂的区别是什么？简单工厂：一个工厂创建不同产品工厂方法：不同工厂创建不同产品，但每个工厂只创建一种产品抽象工厂：不同工厂创建不同产品族
2. 工厂模式的优缺点是什么？优点：封装创建逻辑，降低耦合，符合开闭原则缺点：增加系统复杂度，需要引入更多类

3. 观察者模式 (Observer Pattern)

基本概念

观察者模式定义了对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。

面试题：实现一个观察者模式

// 观察者接口
class Observer {
public:
    virtual ~Observer() {}
    virtual void update(const std::string& message) = 0;
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    std::string name_;
    
public:
    ConcreteObserver(const std::string& name) : name_(name) {}
    
    void update(const std::string& message) override {
        std::cout << name_ << " received: " << message << std::endl;
    }
};

// 主题接口
class Subject {
public:
    virtual ~Subject() {}
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify(const std::string& message) = 0;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers_;
    
public:
    void attach(Observer* observer) override {
        observers_.push_back(observer);
    }
    
    void detach(Observer* observer) override {
        auto it = std::find(observers_.begin(), observers_.end(), observer);
        if (it != observers_.end()) {
            observers_.erase(it);
        }
    }
    
    void notify(const std::string& message) override {
        for (auto observer : observers_) {
            observer->update(message);
        }
    }
};

相关问题

1. 观察者模式与发布-订阅模式的区别是什么？观察者模式：观察者直接订阅主题，主题直接通知观察者发布-订阅模式：发布者和订阅者之间有一个中间层（事件通道）
2. 观察者模式的应用场景有哪些？GUI事件处理消息通知系统数据变化监听

4. 装饰器模式 (Decorator Pattern)

基本概念

装饰器模式动态地给对象添加额外的职责，比继承更灵活。

面试题：实现一个装饰器模式

// 组件接口
class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};

// 装饰器基类
class Decorator : public Component {
protected:
    Component* component_;
    
public:
    Decorator(Component* component) : component_(component) {}
    
    void operation() override {
        if (component_) {
            component_->operation();
        }
    }
};

// 具体装饰器A
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* component) : Decorator(component) {}
    
    void operation() override {
        Decorator::operation();
        addedBehavior();
    }
    
private:
    void addedBehavior() {
        std::cout