• 【C++】特殊类的设计

    特殊类的设计

    一、设计一个类，不能被拷贝

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

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

    原因：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • C++11
      C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
    // 禁止拷贝的类
class copyban
{
public:
	copyban(const copyban& cb) = delete;
	const copyban& operator=(const copyban& cb) = delete;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

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

    1、思路一：封锁构造函数

    实现方式：

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

    原因：
    对象只能通过构造函数或者拷贝构造的方式进行创建，由于构造是私有的，类外不可以访问，如果想要创建对象只能调用这个静态成员函数，而静态成员函数里面创建的对象全都被我们设计在堆上了。

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

	HeapOnly(const HeapOnly& ho) = delete;

private:
	HeapOnly(int x)
		:_x(x)
	{}

	int _x;
};

int main()
{
	//报错，
	//HeapOnly ho(1);
	
	// 正常运行
	HeapOnly* p =  HeapOnly::CreateObj(1);
}

    • 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

    2、思路二：封锁析构函数

    实现方式：

    1. 将类的析构函数私有，使用new完成堆对象的创建。
    2. 提供一个公开的成员函数，用此公开的成员函数来析构对象。

    原因：

    1. C++在栈上创建的对象析构时会隐式调用析构函数，由于析构函数是私有的，栈上如果创建了对象，就没有办法正常销毁。

    2. C++堆上的对象创建时不需要管析构函数，因为堆上的对象析构时要显示调用析构函数（不调用就会造成内存泄漏）

    3. 堆上的对象销毁时要调用析构函数，由于析构函数是私有的，为了完成资源清理，我们可以提供一个公开的成员函数，用此公开的成员函数来析构对象。

    // 封锁析构
class HeapOnly
{
public:
	HeapOnly(int x)
		:_x(x)
	{}
	
	void Release()
	{
		delete this;
	}

private:
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}

	int _x;
};


int main()
{
	//报错，
	//HeapOnly ho(1);
	
	HeapOnly* ptr = new HeapOnly(1);
	ptr->Release();
}

    • 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

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

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

    class StackOnly
{
public:
	static StackOnly CreateObj(int x)
	{
		return StackOnly(x);
	}

	//禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
	// StackOnly obj = StackOnly::CreateObj(obj_1);
	void* operator new(size_t size) = delete;

private:
	StackOnly(int x)
		:_x(x)
	{}

	int _x;
};

int main()
{
	StackOnly so = StackOnly::CreateObj(1);
	// 报错
	//StackOnly* ptr = new StackOnly(so);
}

    • 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

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

    • 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
    • 12
    • C++11方法
      final关键字，final修饰类，表示该类不能被继承。
    class A final
{
	// ....
};

    • 1
    • 2
    • 3
    • 4

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

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

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

    单例模式：
    一个类只能创建一个对象，即单例模式    ，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

    比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

    1、单例模式的实现思路：

    1. 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
    2. 提供一个全局访问点获取单例对象。

    两种实现模式：

    • 饿汉模式：不管你将来用不用，程序启动时就先创建一个唯一的实例对象。
    class singleton
{
public:
	// 全局访问点
	static singleton* GetInstance()
	{
		return _psin;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;

	mutex _mtx;
	//唯一对象的数据
	vector<string> _vstr;
	//指向唯一的对象
	static singleton* _psin;
};
// 得到唯一对象，在程序入口之前就完成单例对象的初始化
singleton* singleton::_psin = new singleton;

int main()
{
	singleton::GetInstance()->Add("main : " + to_string(1));
	int n = 100;

	singleton::GetInstance()->Print();
	cout << singleton::GetInstance()->Count() << endl;
	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
    • 优点：简单
    • 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

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

    • 懒汉模式，程序运行时需要使用单例对象时才实例对象

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

    class singleton
{
public:
	static singleton* GetInstance()
	{
		// 双检查
		// 这一层用于提高效率
		if (_psin == nullptr)
		{
			_smtx.lock();
			// 这一层用于保证线程安全
			if (_psin == nullptr)
			{
				_psin = new singleton;
			}
			_smtx.unlock();
		}
		return _psin;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}

	static void DelInstance()
	{
		_smtx.lock();
		if (_psin)
		{
			delete _psin;
		}
		_smtx.unlock();
	}
	// 内部类 保证完成单例对象的回收
	struct GC
	{
		~GC()
		{
			DelInstance();
		}
	};
	// 当_gc对象销毁时自动调用析构函数。
	static GC _gc;

	~singleton()
	{
		// 一些持久化工作...这里就不再写出
		//...
		cout << "~singleton()" << endl;
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;

	vector<string> _vstr;
	// 这把锁用来保护_vstr
	mutex _mtx;
	static singleton* _psin;
	// 这把锁用来保护 _psin
	static mutex _smtx;
};
// 初始化静态对象
singleton* singleton::_psin = nullptr;
mutex  singleton::_smtx;
singleton::GC singleton::_gc;

    • 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
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71

    线程安全相关问题：

    • 懒汉模式是等到某个线程需要使用这个单例对象时再进行创建，也就是GetInstance函数第一次被调用时创建单例对象。
    • 在调用GetInstance函数获取单例对象时，需要先判断这个static指针是否为空，如果为空则说明这个单例对象还没有创建，此时需要先创建这个单例对象然后再将单例对象返回。
    • GetInstance函数第一次调用时需要对static指针进行写入操作，这个过程不是线程安全的，因为多个线程可能同时调用GetInstance函数，如果不对这个过程进行保护，此时这多个线程就会各自创建出一个对象。

    懒汉模式还有一种比较经典的实现方式：

    在单例类的GetInstance函数中定义一个静态的单例对象并返回，由于实际只有第一次调用GetInstance函数时才会定义这个静态的单例对象，这也就保证了全局只有这一个唯一实例。

    class singleton
{
public:
	static singleton* GetInstance()
	{
		// 创建静态对象进行返回，利用static关键字的特性
		static singleton sing;
		return &sing;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}

	~singleton()
	{
		// 一些持久化工作...
		cout << "~singleton()" << endl;
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;
	// 唯一对象的数据
	vector<string> _vstr;
	mutex _mtx;
	static singleton* _psin;
};
singleton* singleton::_psin = nullptr;

    • 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

    这种版本的懒汉模式的优点：

    • 实现起来比较简单，在实例化对象时不需要双检查，不需要写GC这样的类创建gc对象，也能够主动销毁对象。

    缺点：

    • 单例对象定义在静态区，因此太大的单例对象不适合使用这种方式。
    • 单例对象创建在静态区后没办法主动释放。
    • 兼容性不是很好，C++98标准不保证多线程初始化static变量不会发生数据竞争，而C++11以后可以保证多线程初始化static变量不会发生数据竞争。

    2、饿汉模式和懒汉模式对比

    • 饿汉模式
      优点：简单。

      缺点: 饿汉模式在程序运行主函数之前就会创建单例对象，如果单例类的构造函数中所做的工作比较多，就会导致程序迟迟无法进入主函数，在外部看来就好像是程序卡住了。
      此外，如果有多个单例类需要创建单例对象，并且它们之间的初始化存在某种依赖关系，比如单例对象A的创建必须在单例对象B之后，此时饿汉模式也会存在问题，因为我们无法保证这多个单例对象中的哪个对象先创建。

    • 懒汉模式
      优点：很好的解决上述饿汉模式的缺点，并且懒汉模式中各个单例对象创建的顺序是由各个单例类中的GetInstance函数第一次被调用的顺序决定，因此是可控制的。

      缺点: 在编码上比饿汉模式复杂，在创建单例对象时需要考虑线程安全的问题。

  • 相关阅读:
    vue项目 的创建
    【C++从0到王者】第二十八站：二叉搜索树的应用
    计算摄影——图像去噪（二）
    基于虚拟力优化的无线传感器网络覆盖率matlab仿真
    【论文笔记】Scene as Occupancy
    Hungarian algorithm
    Js进行base64编码、解码、中文乱码
    MySQL 日志管理、备份与恢复
    《canvas》之第19章 canvas游戏开发
    数据结构之双向链表
  • 原文地址：https://blog.csdn.net/qq_65207641/article/details/132542351