C++ 函数重载和重写中单例模式与工厂模式的运用

单例模式：通过函数重载提供不同参数的单例实例。工厂模式：通过函数重写创建不同类型的对象，实现创建过程与具体产品类的解耦。

C++ 中函数重载和重写中单例模式与工厂模式的运用

单例模式

函数重载

单例模式可以通过函数重载来实现，重载后的函数具有不同的参数列表，从而返回不同的实例。

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

    static Singleton* getInstance(int arg) {
        if (instance_ == nullptr) {
            instance_ = new Singleton(arg);
        }
        return instance_;
    }

private:
    Singleton() = default;
    Singleton(int arg);
    static Singleton* instance_;
};

实战案例

创建两个单例对象：一个带有参数，一个不带参数。

int main() {
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance(10);

    // 检查两个实例是否相同
    if (instance1 == instance2) {
        std::cout << "两个实例相同" << std::endl;
    } else {
        std::cout << "两个实例不相同" << std::endl;
    }
}

工厂模式

函数重写

工厂模式可以通过函数重写来实现，重写后的函数在子类中具有不同的实现，从而创建不同的对象。

class Product {
public:
    virtual ~Product() {}
};

class ConcreteProductA : public Product {
    // ...
};

class ConcreteProductB : public Product {
    // ...
};

class Factory {
public:
    virtual ~Factory() {}
    virtual Product* createProduct() = 0;
};

class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

实战案例

创建两个工厂对象，每个对象创建不同的产品类型。

int main() {
    Factory* factory1 = new ConcreteFactoryA();
    Product* product1 = factory1->createProduct();

    Factory* factory2 = new ConcreteFactoryB();
    Product* product2 = factory2->createProduct();

    // 检查两个产品类型是否不同
    if (typeid(*product1) != typeid(*product2)) {
        std::cout << "两个产品类型不同" << std::endl;
    } else {
        std::cout << "两个产品类型相同" << std::endl;
    }
}

以上就是C++ 函数重载和重写中单例模式与工厂模式的运用的详细内容，更多请关注编程网其它相关文章！