C++：特殊类设计

UtoCoo

于 2024-08-28 19:03:14 发布

阅读量443

点赞数 11

分类专栏： c++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_74098337/article/details/141502766

版权

c++ 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

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

拷贝一般发生在拷贝构造函数和赋值运算符重载函数中，禁止生成这两个函数即可。

C++98处理方式

C++98一般会对这两个类只声明不定义，并且设置权限为私有。

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

C++11扩展了delete的用法，表示编译器会删除该默认成员函数

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

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

1.由于构造函数生成的对象是局部变量，因此为了防止调用构造函数，
需要将类的构造函数、拷贝构造函数声明为私有
2.提供一个静态的成员函数，在该静态成员中完成堆对象的创建。

class HeapOnly
{
public:
	template<class... Args>
	static HeapOnly* CreateObj(Args&&... args)
	{
		return new HeapOnly(args...);
	}
    //删除部分函数
	HeapOnly(const HeapOnly&) = delete;
	HeapOnly& operator=(const HeapOnly&) = delete;
private:
	// 构造私有化
	HeapOnly()
	{}
	HeapOnly(int x, int y)
		:_x(x)
		,_y(y)
	{}

	int _x;
	int _y;
	vector<int> _a;
};
int main()
{
    HeapOnly* ho4 = HeapOnly::CreateObj(1,1);
	return 0;
}

同时，还有一种巧妙的设计，可以将析构函数私有化

class HeapOnly
{
public:
	HeapOnly()
	{}

	HeapOnly(int x, int y)
		:_x(x)
		,_y(y)
	{}

	void Destroy()
	{
		delete this;
	}

private:
	// 析构函数私有
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}

	int _x;
	int _y;
	vector<int> _a;
};

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

同第二种特殊类的设计，这里也要将构造函数私有化，防止直接调用构造函数初始化的对象在堆上申请空间。

class StackOnly
{
public:
	template<class... Args>
	static StackOnly CreateObj(Args&&... args)
	{
		return StackOnly(args...);
	}

	StackOnly& operator=(const StackOnly&) = delete;
	// 禁止使用new，重载一个类专属的operator new
	void* operator new(size_t n) = delete;

private:
	// 构造私有化
	StackOnly()
	{}

	StackOnly(int x, int y)
		:_x(x)
		, _y(y)
	{}

	int _x;
	int _y;

};

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

C++98，将基类构造函数私有化

class NonInherit
{
public:
 static NonInherit GetInstance()
 {
 return NonInherit();
 }
private:
 NonInherit()
 {}
};

C++11使用关键字final

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

五、设计一个类，只能创建一个对象

这里可以利用设计模式来实现目的。

设计模式：

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

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化。

其中，单例模式是设计模式的一种。

如果想让一些数据在整个程序中只有一份，那么就可以把这些数据放进一个类，再把这个类设计成单例，这些数据就只有一份了。

单例模式

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

单例模式有两种实现模式

饿汉模式

饿汉模式的设计中，该唯一对象创建于调用main函数之前。

将构造函数设置属性为私有，同时，删除拷贝构造函数和赋值运算符重载，只有这样做，才能保证整个程序中只有一个对象；

该对象定义为全局静态static对象；

提供公有函数GetInstance来让外界获取该单例对象；

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &_sint;
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
private:
	Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "yyyy","xxxx" })
		:_x(x)
		, _y(y)
		, _vstr(vstr)
	{}
	int _x;
	int _y;
	vector<string> _vstr;
    //因为构造函数是私有，所有该静态对象定义在类中
	static Singleton _sint;
};

Singleton Singleton::_sint(1, 2, { "a" ,"b"});

饿汉模式的缺陷：

如果这个单例对象成员变量比较多，构造初始化开销大，就会影响程序启动的速度，迟迟进不了main函数
多个单例类之间如果有初始化启动依赖关系，饿汉无法控制。假设：A和B两个单例，假设要求A先初始化，B再初始化，饿汉模式无法满足需求。

懒汉模式

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

懒汉模式：第一次使用实例对象时，创建对象，进程启动无负载，多个单例启动顺序自由控制，完美解决了饿汉模式的问题。

将构造函数设置属性为私有，同时，删除拷贝构造函数和赋值运算符重载，只有这样做，才能保证整个程序中只有一个对象；

提供static指针，在程序入口前完成定义；

提供全局获取单例对象GetInstance()；

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		// 第一次调用时，创建单例对象
		if (_psint == nullptr)
		{
			_psint = new Singleton;
		}

		return _psint;
	}
	//为了释放空间
	static void DelInstance()
	{
		if (_psint)
		{
			delete _psint;
			_psint = nullptr;
		}
	}

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

private:
	Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "yyyyy","xxxx" })
		:_x(x)
		, _y(y)
		, _vstr(vstr)
	{}

	~Singleton()
	{
		cout << "~Singleton()" << endl;
	}

	int _x;
	int _y;
	vector<string> _vstr;

	static Singleton* _psint;

	// 内部类，该设计是为了调用析构函数释放空间，如果不需要释放单例对象，则不用写
	class GC
	{
	public:
		~GC()
		{
			Singleton::DelInstance();
		}
	};
	static GC gc;
};

Singleton* Singleton::_psint = nullptr;
Singleton::GC Singleton::gc;