设计模式（工厂模式与单例模式）

一、工厂模式

1、什么是工厂模式？他的主要目的是什么？

工厂模式是一种创建型设计模式，它通过提供一个创建对象的接口来让子类决定实例化那个类。主要目的：将对象的创建过程和使用过程分离，从而减少耦合，提高代码的可扩展性和可维护性

2、工厂模式有哪些类型？简要描述他们的区别？

简单工厂模式：通过一个工厂类的静态方法，根据传入的参数决定实例化那种类型

工厂方法模式：定义一个创建对象的接口，由子类决定实例化那个类

抽象工厂模式：提供一个创建一系列或相关依赖对象的接口，而无需指定他们的具体类

3、工厂模式与构造函数的直接调用相比，有哪些优势？

解耦性：客户端代码不依赖于具体类，便于修改和扩展

扩展性：新的产品类可以通过扩展工厂类实现，无需修改已有的代码

统一管理：对象创建的过程集中在工厂类中，便于控制复杂的创建过程

4、工厂方法模式如何遵循“开闭原则”？

工厂方法模式通过定义一个创建对象的接口，使得客户端不需要修改现有的代码就可以通过扩展工厂类来实现新的产品类型，这种扩展性符合"开闭原则",即对扩展开放，修改封闭，

5、工厂模式在什么情况下适用？

需要将对象的创建过程与使用过程分离时

需要创建的对象类型在运行时才能确定

系统需要根据不同条件创建不同类型的对象时

对象的创建过程比较复杂，涉及到配置或多个步骤时

6、抽象工厂模式与工厂方法模式有何区别？

工厂方法模式：创建一个产品的具体实例，每个工厂类对应一个产品子类

抽象工厂模式：创建一组相关的或依赖的产品实例，每个工厂可以创建多个相关的产品对象

7、在工厂模式中，如何处理需要川端过个参数给产品对象的情况？

通过在工厂方法中传递参数来实现

8、工厂模式是否可以与单例模式结合使用，如何实现？

可以。工厂类可以设计为单例模式，这样在系统中只有一个工厂实例来创建产品对象

方法：①将工厂类的构造函数设为私有，提供一个静态方法来获取工厂实例。②在静态方法中，如果工厂实例不存在，则创建一个新实例，否则返回已存在的实例

9、工厂模式在实际开发中有哪些应用场景？

数据库连接、日志记录系统、跨平台应用

10、工厂模式

#include <iostream>
#include <string>

// 抽象产品类
class Animal 
{
public:
    virtual void speak() = 0; // 纯虚函数，子类必须实现
    virtual ~Animal() {}
};

// 具体产品类：Dog
class Dog : public Animal 
{
public:
    void speak() override 
    {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

// 具体产品类：Cat
class Cat : public Animal 
{
public:
    void speak() override 
    {
        std::cout << "Meow! Meow!" << std::endl;
    }
};

// 工厂类
class AnimalFactory 
{
public:
    // 工厂方法，根据类型创建不同的动物对象
    static Animal* createAnimal(const std::string& type) 
    {
        if (type == "Dog") 
        {
            return new Dog();
        }
        else if (type == "Cat") 
        {
            return new Cat();
        }
        else 
        {
            return nullptr;
        }
    }
};

// 使用示例
int main() {
    // 创建一个Dog对象
    Animal* dog = AnimalFactory::createAnimal("Dog");
    if (dog) {
        dog->speak();
        delete dog;
    }

    // 创建一个Cat对象
    Animal* cat = AnimalFactory::createAnimal("Cat");
    if (cat) {
        cat->speak();
        delete cat;
    }

    return 0;
}

二、单例模式

1、什么是单例模式？

单例模式是一种创建型设计模式，构造函数私有化，用static实例化单例的静态方法，保证一个类只有一个实例，并提供一个全局访问点。它常用于需要全局唯一对象的场景

2、单例模式中的懒汉模式与饿汉模式有何区别？

懒汉模式：实例在首次使用时创建，具有延迟加载的特点。缺点是多线程下需要加锁，可能引发性能问题

饿汉模式：类加载是就创建实例，线程安全，但还是线程从未使用就会造成资源浪费

3、如何避免单例模式中内存泄露的问题？

使用智能指针(std::unique_ptr 或 std::shared_ptr ) 管理单例模式，或者在程序退出时，手动释放单例实例

4、C++11标准如何简化单例模式的实现？

C++11引入了线程安全的静态局部变量的初始化，直接用静态局部变量实现单例模式及简单又线程安全

5、单例模式的应用场景有哪些·？

配置管理类、日志记录系统、线程池、数据库连接管理

6、实现一个线程安全的饿汉式单例

class Singleton {
private:
    static Singleton* instance;

    Singleton() {}

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

// 静态成员初始化
Singleton* Singleton::instance = new Singleton();

7、实现一个线程安全的懒汉式单例？

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;  // 用于线程同步的互斥锁

    Singleton() {}

public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);  // 加锁保护
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;