Die Anwendung des Singleton-Modus und des Factory-Modus beim Überladen und Umschreiben von C++-Funktionen

Singleton-Modus: Stellen Sie Singleton-Instanzen durch Funktionsüberladung unterschiedliche Parameter zur Verfügung. Fabrikmuster: Erstellen Sie verschiedene Objekttypen durch Umschreiben von Funktionen, um den Erstellungsprozess von bestimmten Produktklassen zu entkoppeln. Die Anwendung des Singleton-Modus und des Factory-Modus beim Überladen und Umschreiben von Funktionen in C++. Die geladene Funktion verfügt über eine andere Parameterliste und gibt daher eine andere Instanz zurück.

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_;
};

Praktischer Fall

Erstellen Sie zwei Singleton-Objekte: eines mit Parametern und eines ohne Parameter.

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

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

Fabrikmuster

Funktionsüberschreibung

Fabrikmuster können durch Funktionsumschreiben implementiert werden. Die umgeschriebene Funktion verfügt über unterschiedliche Implementierungen in Unterklassen, wodurch unterschiedliche Objekte erstellt werden.

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();
    }
};

Praktischer Fall

Erstellen Sie zwei Fabrikobjekte, jedes Objekt erstellt einen anderen Produkttyp.

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;
    }
}

Das obige ist der detaillierte Inhalt vonDie Anwendung des Singleton-Modus und des Factory-Modus beim Überladen und Umschreiben von C++-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!