（C++进阶）设计特殊类

目录

1 只能在堆上创建对象的类

1.1 实现方式

1.2 实现

2 只能在栈上创建对象的类

2.1 实现方法

2.2 实现

2.3 屏蔽new方法实现

3 不能被拷贝的类

3.1 C++98

3.1.1实现

3.2 c++11

3.2.1 实现

4 不能被继承的类

4.1 c++98

4.2 c++11

5 只能创建一个对象的类(单例模式)

5.1 设计模式

5.2 单例模式

5.2.1 饿汉模式

5.2.2 懒汉模式

5.2.3 懒汉模式与饿汉模式的对比

---

1 只能在堆上创建对象的类

1.1 实现方式

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

1.2 实现

//只能在堆上创建对象
class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}

	//拷贝构造私有，并且只声明不实现（实现也可以，但是没人用）
	//c++98叫做：防拷贝
	//HeapOnly(const HeapOnly&);

	//c++11 delete关键字 (属性为公有也能防拷贝)
public:
	HeapOnly(const HeapOnly&) = delete;
};


int main()
{
	HeapOnly* p = HeapOnly::CreateObj();
	return 0;
}

2 只能在栈上创建对象的类

2.1 实现方法

将构造函数私有化，然后设计静态方法创建对象返回。

2.2 实现

//只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return  StackOnly();
	}
private:
	StackOnly()
	{}
};


int main()
{
	StackOnly p = StackOnly::CreateObj();
	return 0;
}

2.3 屏蔽new方法实现

//只能在栈上创建对象(禁用new)
class StackOnly
{
public:
	StackOnly()
	{}

	//c++11
	void* operator new(size_t size)=delete;
	void operator delete(void* p)=delete;
private:

	//c++98
	//void* operator new(size_t size);
	//void operator delete(void* p);
};

int main()
{
	StackOnly p;

	//缺陷：可以在静态区创建
	static StackOnly sp;

	return 0;
}

3 不能被拷贝的类

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此 想要让一个类禁止拷贝，只需让该类 不能调用拷贝构造函数以及赋值运算符重载即可 。

3.1 C++98

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

1. 设置成私有：如果只声明没有设置成 private ，用户自己如果在类外定义了，就可以不能禁止拷贝

了

2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简

单，而且如果定义了就不会防止成员函数内部拷贝了。

3.1.1实现

class CopyBan
{
 
private:
 CopyBan(const CopyBan&);
 CopyBan& operator=(const CopyBan&);
};

3.2 c++11

C++11 扩展 delete 的用法， delete 除了释放 new 申请的资源外，如果在默认成员函数后跟上 =delete ，表示让编译器删除掉该默认成员函数。

3.2.1 实现

class CopyBan
{
 CopyBan(const CopyBan&)=delete;
 CopyBan& operator=(const CopyBan&)=delete;
};

4 不能被继承的类

4.1 c++98

不够彻底，能继承，只是不能实例化出对象

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
 static NonInherit GetInstance()
 {
 return NonInherit();
 }
private:
 NonInherit()
 {}
};

4.2 c++11

fifinal 关键字， fifinal 修饰类，表示该类不能被继承。

class A final
{
 // ....
};

5 只能创建一个对象的类(单例模式)

5.1 设计模式

设计模式（ Design Pattern ）是一套 被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编 写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

5.2 单例模式

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

单例模式有两种实现模式：

5.2.1 饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

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

//单例类名按要求随便取
//如何保证全局（一个进程中）只有一个唯一实例对象
//1、构造函数私有，拷贝构造和赋值运算符重载禁用
//2、提供一个GetInstance获取单例对象


//饿汉模式------程序开始main函数执行之前就创建实例对象
//提供一个静态指向单例对象的成员指针，初始化时new一个对象给他
class Singleton 
{
public:
	static Singleton* GetInstance()
	{
		return _inst;
	}

	void print()
	{
		cout << "print():" << _a << endl;
	}

private:
	Singleton()
		:_a(0)
	{}

    Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	int _a;
	static Singleton* _inst;
};

Singleton* Singleton::_inst = new Singleton;

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	Singleton::GetInstance()->print();

	return 0;
}

5.2.2 懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件、初始化网络连接、读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时

非常的缓慢。 所以这种情况使用懒汉模式（ 延迟加载 ）更好。

//单例类名按要求随便取
//如何保证全局（一个进程中）只有一个唯一实例对象
//1、构造函数私有，拷贝构造和赋值运算符重载禁用
//2、提供一个GetInstance获取单例对象


//假设单例类构造函数中，要做很多配置初始化工作，那么饿汉就不合适了，会导致程序启动非常慢
//懒汉模式

#ifdef WIN32
//windows 提供多线程api
#else
//Linux phtread
#endif //WIN32

//标准懒汉实现
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//双检查加锁，保护第一次需要加锁，后面不需要加锁的场景
		//保护线程安全，同时提高效率
		if (_inst == nullptr)
		{
			_mtx.lock();
			if (_inst == nullptr)
			{
				_inst = new Singleton;
			}
			_mtx.unlock();
		}

		return _inst;
	}

	//一般情况下可以不用释放单例对象，进程正常结束后会回收掉
	static Singleton* DelInstance()
	{
		_mtx.lock();
		if (_inst)
		{
			delete _inst;
			_inst = nullptr;
		}
		_mtx.unlock();
	}

	void print()
	{
		cout << "print():" << _a << endl;
	}

private:
	Singleton()
		:_a(0)
	{
		//假设单例类构造函数中，需要做很多配置初始化
	}

	~Singleton()
	{
		//程序结束时，需要处理一下，持久化保存一些数据
	}

	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//实现一个内嵌垃圾回收类
	class CGarbo
	{
	public:
		~CGarbo()
		{
			if (_inst)
			{
				delete _inst;
				_inst = nullptr;
			}
		}
	};

	int _a;
	static Singleton* _inst;
	static std::mutex _mtx;
	static CGarbo _gc;
};

Singleton* Singleton::_inst = nullptr;
std::mutex Singleton::_mtx;
Singleton::CGarbo Singleton:: _gc;

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	Singleton::GetInstance()->print();

	return 0;
}




//其他版本的懒汉实现
// 单例对象在静态区，如果单例对象太大，不太好，不合适。
// 想主动释放单例对象，无法主动控制。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		static Singleton inst;

		return &inst;
	}

	void Print()
	{
		cout << "Print()" << _a << endl;
	}

private:
	Singleton()
		:_a(0)
	{
		// 假设单例类构造函数中，要做很多配置初始化
	}

	~Singleton()
	{
		// 程序结束时，需要处理一下，持久化保存一些数据
	}

	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	int _a;
};

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;

	Singleton::GetInstance()->Print();

	return 0;
}

5.2.3 懒汉模式与饿汉模式的对比

饿汉模式：

①优点：简单

②缺点：如果单例对象构造函数工作多，会导致程序启动慢，迟迟进入不了入口main函数。如果有多个单例对象，他们之间有先后依赖关系，则使用饿汉模式有问题，而懒汉模式则可以通过调用GetInstance函数的先后顺序来处理。

懒汉模式：

①优点：简解决饿汉模式的缺点，因为它是第一次调用GetInstance函数时，创建初始化单例对象。

②缺点：实现上稍微复杂一点点