特殊类设计

系列文章目录

类和对象上
类和对象中上
类和对象中下
类和对象下

---

---

前言

在实际项目中，往往会设计特殊的类，对这个类的默认成员函数有一定的要求。

---

一、特殊类的设计

1.请设计一个类，不能被拷贝

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

• C++98

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

原因：

1. 设置成私有：如果只声明没有设置成·private·，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

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

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

iostream就是一个典型的不让拷贝的对象。因为里面涉及缓冲区。

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

实现方式:

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

#include <iostream>
using namespace std;
class HeapOnly
{
public:
	static HeapOnly* CreateObject()	//static指针对象需要
	{
		return new HeapOnly;
	}
private:
	HeapOnly() {}
	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly&);//HeapOnly* hp2(*hp1);不将拷贝构造私有会有这种操作
	// or
	// C++11
	HeapOnly(const HeapOnly&) = delete;
};
int main()
{
	HeapOnly* hp1 = HeapOnly::CreatObj();
	return 0;
}

析构函数私有化，也创建不了对象，因为要自动调用析构。

class HeapOnly
{
public:
	void Destory()
	{
		delete this;
	}

private:
	//析构私有化
	~HeapOnly() {};
};

int main()
{
	//HeapOnly hp1;
	HeapOnly* hp2 = new HeapOnly;
	hp2->Destory();	//将hp2的地址传过去，类内部调用析构	
	return 0;
}

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

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

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
	// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
	// StackOnly obj = StackOnly::CreateObj();
	// StackOnly* ptr3 = new StackOnly(obj);
	
	// 也可以提供移动构造，如何将拷贝构造delete
	//StackOnly(const StackOnly& s) = delete;
	//StackOnly(StackOnly&& s){}
	//但是可以调用StackOnly* s5 = new StackOnly(move(s4));
	
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	StackOnly()
	:_a(0)
	{}
private:
	int _a;
};
int main()
{
	//static StackOnly s1;
	//StackOnly s2;
	//StackOnly* s3 = new StackOnly;
	StackOnly s4 = StackOnly::CreateObj();
	//StackOnly* s5 = new StackOnly(s4);
	return 0;
}

1.4 请设计一个类，不能被继承

• C++98方式

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

• C++11方法
  final关键字，final修饰类，表示该类不能被继承。

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

1.5 请设计一个类，只能创建一个对象(单例模式)

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

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

单例模式：

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

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

• 饿汉模式:

//单例：全局只有唯一一个对象
//饿汉模式
//优点：简单
// 缺点：
// 1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证
class InfoMag
{
public:
	static InfoMag& GetInstance()
	{
		return _info;	//直接返回已经在静态区的变量
	}
	void Print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffsize << endl;
	}
private:
	//构造时指向静态成员_info
	InfoMag()
	{
		cout << "InfoMag()" << endl;
	}

	//防拷贝和赋值 
	InfoMag(const InfoMag& info) = delete;
	InfoMag& operator=(const InfoMag& info) = delete;
private:
	string _ip = "1.100.0.1";
	int _port = 100;
	size_t _buffsize = 1024 * 1024;
	//...

	//静态变量不在类对象中，属于整个类体系
	static InfoMag _info;
};
InfoMag InfoMag::_info;//在程序入口之前就完成单例对象的初始化

int main()
{
	//不允许下面操作
	//InfoMag info1;
	//InfoMag info2 = InfoMag::GetInstance();	//拷贝
	//InfoMag info3(InfoMag::GetInstance());
	
	InfoMag::GetInstance().Print();
	cout << &InfoMag::GetInstance() << endl;
	cout << &InfoMag::GetInstance() << endl;
	return 0;
}

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

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

//懒汉模式
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
class InfoMag
{
public:
	static InfoMag& GetInstance()
	{
		if (_pinfo == nullptr)
		{
			_pinfo = new InfoMag;
		}
		return *_pinfo;
	}
	void Print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffsize << endl;
	}
	static void DelInstance()
	{
		delete _pinfo;
		_pinfo = nullptr;
	}
private:
	//构造时指向静态成员_info
	InfoMag()
	{
		cout << "InfoMag()" << endl;
	}

	//防拷贝和赋值 
	InfoMag(const InfoMag& info) = delete;
	InfoMag& operator=(const InfoMag& info) = delete;
private:
	string _ip = "1.100.0.1";
	int _port = 100;
	size_t _buffsize = 1024 * 1024;
	//...

	//静态变量不在类对象中，属于整个类体系
	static InfoMag* _pinfo;
};
InfoMag* InfoMag::_pinfo = nullptr;//在程序入口之前就完成单例对象的初始化

int main()
{
	//不允许下面操作
	//InfoMag info1;
	//InfoMag info2 = InfoMag::GetInstance();	//拷贝
	//InfoMag info3(InfoMag::GetInstance());

	InfoMag::GetInstance().Print();
	cout << &InfoMag::GetInstance() << endl;
	cout << &InfoMag::GetInstance() << endl;
	return 0;
}

C++11之后可以这样写懒汉：

class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		// 第一次调用时创建单例对象
		// C++11之后
		static InfoMgr ins;
		return ins;
	}

	void Print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffSize << endl;
	}
private:
	InfoMgr(const InfoMgr&) = delete;
	InfoMgr& operator=(const InfoMgr&) = delete;

	InfoMgr()
	{
		cout << "InfoMgr()" << endl;
	}
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t _buffSize = 1024 * 1024;
	//...
};

---

如果你有所收获可以留下你的点赞和关注，谢谢你的观看！！！