c++设计模式（一）

单例模式

在整个应用程序中，确保某个类只实例化一个类对象，并提供一个访问它的全局访问点。

准备程序：

1、需要将构造函数设置为私有的，禁止别人使用构造函数实例化其它对象；

2、单例类需要一直向系统提供这个实例，那么需要声明它为静态的实例成员，在需要的时候，才创建该实例；

3、且应该将这个静态成员设置为nullptr，在一个public的方法里去判断，只有在静态实例成员为nullptr时，才创建。

单例模式的两种基本形态：饿汉式和懒汉式

饿汉式：直接在静态区初始化instance，然后用get方法返回。

懒汉式：只有在调用get方法时才初始化实例。

懒汉式

//单例模式示例
class Singleton
{
public:
    static Singleton * getInstance()
    {
        if (instance == NULL) {
            instance = new Singleton();
        }
        
        return instance;
    }
    
private:
    //私有的构造函数，防止外人私自调用
    Singleton()
    {
        cout << "实例化了" << count << "个对象！" << endl;
        count++;
    }
    //声明一个静态实例，静态函数只能使用静态的数据成员。整个类中静态成员只有一个实例，通常在实现源文件中被初始化。
    static Singleton *instance;
    //记录实例化的对象
    int count = 1;
};

Singleton * Singleton::instance = NULL;

int main(void)
{
    Singleton::getInstance();
    Singleton::getInstance();
    Singleton::getInstance();
    Singleton::getInstance();
    
    return 0;
}

饿汉式

#include <QCoreApplication>

class HangryDesign {
public:
    static HangryDesign* GetInstance() {
        return instance;
    }

    int m_a;
    int m_b;
private:
    HangryDesign(int a, int b) {
        m_a = a;
        m_b = b;
    }
    ~HangryDesign() {

    }
    HangryDesign() = delete;
    HangryDesign(const HangryDesign &instance) = delete;
    HangryDesign& operator =(const HangryDesign &instance) = delete;
    static HangryDesign *instance;
};

HangryDesign * HangryDesign::instance = new HangryDesign(1, 2);

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    HangryDesign *instance = HangryDesign::GetInstance();
    qInfo("m_a: %d, m_b: %d", instance->m_a, instance->m_b);

    return a.exec();
}

注意： 构造函数需在private或者protected模式下，需删除拷贝构造函数，默认重载赋值操作（=），留下一个你所需的构造函数

工厂模式

简单工厂模式

简单工厂模式需要传入判断条件动态决定创建哪个对象，如一个工厂生产A、B、C三种产品，那么决定要生成哪种产品，需要传入参数告知生产哪种产品，当新增一个产品后，需要修改工厂类。

#include <QCoreApplication>
#include <iostream>
class Product
{
public:
    virtual void show() = 0;
};

class Product_A : public Product
{
public:
    Product_A() {}
    void show() {
        std::cout << "Show Product_A" << std::endl;
    }
};

class Product_B : public Product
{
public:
    Product_B() {}
    void show() {
        std::cout << "Show Product_B" << std::endl;
    }
};

class Product_C : public Product
{
public:
    Product_C() {}
    void show() {
        std::cout << "Show Product_C" << std::endl;
    }
};

class Factory
{
public:
    Product * CreateProduct(int type) {
        switch (type) {
        case 0:
            return new Product_A();
            break;
        case 1:
            return new Product_B();
            break;
        case 2:
            return new Product_C();
            break;
        default:
            break;
        }
        return nullptr;
    }
};
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Factory factory;
    factory.CreateProduct(0)->show();
    factory.CreateProduct(1)->show();
    factory.CreateProduct(2)->show();

    return a.exec();
}

工厂方法模式

所谓工厂方法模式即指定义一个用于创建对象的接口，让子类决定实例化哪一个类。比如，有A、B两个产品，那么我创建两个工厂，工厂A负责生产A产品，工厂B负责生产B产品。

#include <QCoreApplication>
#include <iostream>
class Product
{
public:
    virtual void show() = 0;
};

class Product_A : public Product
{
public:
    Product_A() {}
    void show() {
        std::cout << "Show Product_A" << std::endl;
    }
};

class Product_B : public Product
{
public:
    Product_B() {}
    void show() {
        std::cout << "Show Product_B" << std::endl;
    }
};
class FactortWay
{
public:
    virtual Product *create() = 0;
};

class Factort_A : public FactortWay
{
public:
    Product *create() {
        return new Product_A();
    }
};

class Factort_B : public FactortWay
{
public:
    Product *create() {
        return new Product_B();
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Factort_A factory_a;
    factory_a.create()->show();
    Factort_B factory_b;
    factory_b.create()->show();

    return a.exec();
}

抽象工厂模式

适用于产品种类结构多的场合，主要用于创建一组（有多个种类）相关的产品，为它们提供创建的接口；就是当具有多个抽象角色时，抽象工厂便可以派上用场。

#include <QCoreApplication>
#include <iostream>
class Product1
{
public:
    virtual void show() = 0;
};

class Product_A1 : public Product1
{
public:
    Product_A1() {}
    void show() {
        std::cout << "Show Product_A1" << std::endl;
    }
};

class Product_B1 : public Product1
{
public:
    Product_B1() {}
    void show() {
        std::cout << "Show Product_B1" << std::endl;
    }
};

class Product2
{
public:
    virtual void show() = 0;
};

class Product_A2 : public Product2
{
public:
    Product_A2() {}
    void show() {
        std::cout << "Show Product_A2" << std::endl;
    }
};

class Product_B2 : public Product2
{
public:
    Product_B2() {}
    void show() {
        std::cout << "Show Product_B2" << std::endl;
    }
};

class AbstractFactory
{
public:
    virtual Product1 *create1() = 0;
    virtual Product2 *create2() = 0;
};

class Factory1 : public AbstractFactory
{
public:
    Product1 * create1() {
        return new Product_A1();
    }
    Product2 * create2() {
        return new Product_A2();
    }
};

class Factory2 : public AbstractFactory
{
public:
    Product1 * create1() {
        return new Product_B1();
    }
    Product2 * create2() {
        return new Product_B2();
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Factory1 factory1;
    factory1.create1()->show();
    factory1.create2()->show();

    Factory2 factory2;
    factory2.create1()->show();
    factory2.create2()->show();
    return a.exec();
}