【C++ 23种设计模式】

■ 创建型模式(5种)

■ 工厂模式

示例一：

#include
#include
using namespace std;
enum CTYPE{COREA,COREB};
//定义一个基类单核
class SingleCore 
{
public:
	virtual void show() = 0;
};
//单核A
class SingleCoreA:public SingleCore
{
public:
	void show() {
		cout << "SingleCore A" << endl;
	}
};
//单核B
class SingleCoreB:public SingleCore
{
public:
	void show() {
		cout << "SingleCore B" << endl;
	}
};
//唯一的工厂，可以生成A、B两种处理器核，在内部判断
class Factory {
public:
	//基类的对象指针指向子类的对象，也就是多态
	SingleCore* CreateSingleCore(CTYPE ctype)
	{
		//工厂内部判断
		if (ctype == COREA)
		{
			//生产核A
			return new SingleCoreA();
		}
		else if (ctype == COREB)
		{
			//生产核B
			return new SingleCoreB();
		}
		else {
			return NULL;
		}
	}
};
int main() 
{
	Factory* factor = new Factory();
	factor->CreateSingleCore(COREA)->show();

	getchar();
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

■ 抽象工厂模式

■ 原型模式

■ 单例模式

■ 第一种：单线程（懒汉）

//单线程解法
//这种解法在多线程的情况下，可能创建多个实例。
class Singleton1
{
private:
    static Singleton1* m_pInstance1;//需要的时候才创建，懒汉
    //利用static关键字的特性，不属于任何类，整个类只有一个
    Singleton1();
public:
    static Singleton1* GetInstance1();
    static void DestroyInstance1();
};
Singleton1::Singleton1()
{
    cout << "创建单例" << endl;
}
Singleton1* Singleton1::GetInstance1()
{
    return m_pInstance1;
}
void Singleton1::DestroyInstance1()
{
    if (m_pInstance1 != nullptr)
    {
        delete m_pInstance1;
        m_pInstance1 = nullptr;
    }
}

//初始化一个对象
Singleton1* Singleton1::m_pInstance1 = new Singleton1();

//单线程下多次获取实例
void test1()
{
    Singleton1* singletoObj1 = Singleton1::GetInstance1();
    cout << singletoObj1 << endl;

    Singleton1* singletoObj2 = Singleton1::GetInstance1();
    cout << singletoObj2 << endl;

    //上面的两个对象会指向同一个地址

    Singleton1::DestroyInstance1();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

■ 第二种：多线程（互斥量实现锁+懒汉）

//多线程+加锁（互斥量）
class Singleton2
{
private:
    Singleton2();
    static Singleton2* m_pInstance2;
    static mutex m_mutex;//互斥量
public:
    static Singleton2* GetInstance2();
    static void DestroyInstance2();
};

Singleton2::Singleton2()
{
    cout << "创建单例2" << endl;
}
Singleton2* Singleton2::GetInstance2()
{
    if (m_pInstance2 == nullptr)
    {
        cout << "加锁中" << endl;
        m_mutex.lock();
        if (m_pInstance2 == nullptr)
        {
            m_pInstance2 = new Singleton2();
        }
        cout << "解锁中" << endl;
        m_mutex.unlock();
    }
    return m_pInstance2;
}
void Singleton2::DestroyInstance2()
{
    if (m_pInstance2 != nullptr)
    {
        delete m_pInstance2;
        m_pInstance2 = nullptr;
    }
}
//静态成员变量的定义
Singleton2* Singleton2::m_pInstance2 = nullptr;//懒汉式的写法
mutex Singleton2::m_mutex;

//常见一个实例对象，给下面的多线程调用
void print_singleton_instance()
{
    Singleton2* singletonObj2 = Singleton2::GetInstance2();
    cout << "新的一个实例对象" << singletonObj2 << endl;
}

void test2()
{
    vector<thread> threads;
    for (int i = 0; i < 10; i++)
    {
        //十个线程都指向同一个静态变量的地址
        threads.push_back(thread(print_singleton_instance));
    }
    for (auto& thr : threads)
    {
        thr.join();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

■ 第三种：多线程（const static+饿汉）（还要继续了解）

//方案三：使用const特性，来替换方案二的加锁操作
class Singleton3
{
private:
    Singleton3(){}
    static const Singleton3* m_pInstance3;
public:
    static Singleton3* GetInstance3();
    static void DestroyInstance3();
};

Singleton3* Singleton3::GetInstance3()
{
    //这个函数的返回值如果变化曾const static属性，就不用进行const_cast
    return const_cast<Singleton3*> (m_pInstance3);
}

void Singleton3::DestroyInstance3()
{
    if (m_pInstance3 != nullptr)
    {
        delete m_pInstance3;
        m_pInstance3 = nullptr;
    }
}

//静态成员变量的定义
const Singleton3* Singleton3::m_pInstance3 = new Singleton3();//饿汉式的写法

//常见一个实例对象，给下面的多线程调用
void print_singleton_instance3()
{
    Singleton3* singletonObj3 = Singleton3::GetInstance3();
    cout << "新的一个实例对象" << singletonObj3 << endl;
}

void test3()
{
    vector<thread> threads;
    for (int i = 0; i < 10; i++)
    {
        //十个线程都指向同一个静态变量的地址
        threads.push_back(thread(print_singleton_instance3));
    }
    for (auto& thr : threads)
    {
        thr.join();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

■ 建造者模式

---

■ 结构型模式(7种)

■ 适配器模式

■ 桥接模式

■ 组合实体模式

■ 装饰器模式

■ 外观模式

■ 享元模式

■ 代理模式

---

■ 行为型模式(11种)

■ 责任链模式

■ 中介者模式

■ 策略模式

■ 模板模式

■ 状态模式

■ 观察者模式

■ 备忘录模式

■ 命令模式

■ 访问者模式

■ 解释器模式

■ 迭代器模式