c++11特殊类设计，单例模式_c++11 规范的实现一个类

设计一个类，不能被拷贝

1. 拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可
2. c++98的方式同名对象在类域中使用拷贝构造和赋值重载，但是c++11的delete后同名对象在类域中不可以使用拷贝和赋值重载。

c++98方式

通过将拷贝构造和赋值重载私有化，同时定义时不写函数体 。

class No_Copy
{
public:
	No_Copy()
	{
		;
	}
	void f()
	{
		No_Copy n1;
		No_Copy n2(n1);

	}
	
private:	

	No_Copy(const No_Copy& cpy)
	{
	;
	}
    No_Copy &operator=(const No_Copy& cpy)
    {
        ;
    }
};
//通过类域定义，因为在类中已经定义了--内联定义，编译会保错
//No_Copy::No_Copy(const No_Copy& cpy)
//{
//	cout << "hellowoerd" << endl;
//}
int main()
{
	No_Copy nocpy1;
	nocpy1.f();
}
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

C++11:

1. 通过关键字delete强制不生成拷贝构造和赋值重载。

​ 2. 即使是类域中的同名对象也不可使用delete后的拷贝构造和赋值重载。

class No_Copy
{
public:
	No_Copy()
	{
		;
	}
	No_Copy(const No_Copy& cpy) = delete;
	No_Copy&operator =(const No_Copy& cpy) = delete;
private:
};
1
2
3
4
5
6
7
8
9
10
11

设计一个类，只能在堆上创建对象

对象存在有：堆区，栈区，静态区(全局变量)，常量区

主流：

由RAII思想，当在类外，创建对象是会自动调用构造函数，因此把构造函数私有化，同时为了防止在栈或者静态区被拷贝，拷贝构造delete。赋值重载是针对已存在的2个对象，既然已经合法存在，说明是在堆上创建的，不需要私有化赋值。最后通过一个静态接口，在堆上创建对象

其它

将析构函数私有化，这样编译器在栈还是静态区，只有创建对象就会报错，但是对于在堆上申请的不会，之后通过成员函数进行delete。

设计一个类，只能在栈上创建对象

方法一：通过静态函数返回

方法二：强制不生成new和delete

设计一个类，不能被继承

c++98

C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承 。派生类创建对象必须调用基类的构造函数

class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
}
1
2
3
4
5
6
7
8
9
10
11

c++11

通过关键字final

class A fina
{

}
1
2
3
4

设计一个类，只能创建一个对象—单列模式

设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。同STL一样，具有泛性。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样 。

单例模式

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

饿汉模式

程序启动时，main函数之前就创建一个唯一的实例对象。

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好

//饿汉模式，上来就吃
class Signleton
{

public:
	static Signleton* Get_Signleton()
	{
		return _pslt;
	}
	void Print()
	{
		cout << "helloword" << endl;
	}

private:
	Signleton()=default;
	Signleton(const Signleton& slt) = delete;
	Signleton & operator=(const Signleton& slt) = delete;
	static Signleton* _pslt;
};
Signleton* Signleton::_pslt = new Signleton;

int main()
{
	Signleton::Get_Signleton()->Print();
	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

懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 —简单说就是main函数前面有太多饿汉类了，所以这种情况使用懒汉模式（延迟加载）更好 。

//懒汉模式模式，用时再吃
class Signleton
{

public:
	static Signleton* Get_Signleton()
	{
		if (_pslt == nullptr)
		{
			_pslt = new Signleton;
		}
		return _pslt;
	}
	void Print()
	{
		cout << "helloword" << endl;
	}

private:
	Signleton() = default;
	Signleton(const Signleton& slt) = delete;
	Signleton& operator=(const Signleton& slt) = delete;
	static Signleton* _pslt;
};
Signleton* Signleton::_pslt =nullptr;

int main()
{
	Signleton::Get_Signleton()->Print();
	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

饿汉模式与懒汉模式对比

饿汉模式：

逻辑简单，但初始化顺序不确定，如果有依赖关系就会有问题，饿汉对象初始化慢且多个饿汉单例对象会影响程序启动

懒汉特点：

复杂一点。第一次调用时初始化，可以控制初始化顺序，延迟加载初始化，不影响程序启动。

资源释放

一般单例模式不考虑内存释放。—以目前的水准不会解释