• 作者:老汪软件
  • 发表时间:2024-01-13 07:00
  • 浏览量:

目录

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

//1、请设计一个类,不能被拷贝
// 
// 拷贝一个类,要么调用拷贝构造函数,要么调用赋值重载函数,所以要令一个类不能
// 被拷贝,只需要让该类不能调用拷贝构造和赋值重载函数就可以了。
// 
// 在C++98语法下,只需要把该类的拷贝构造函数和赋值重载函数声明为私有,
// 并且不定义即可
// 
//原因:拷贝构造函数和赋值重载函数只要我们声明了,编译器就不会再默认生成,但是
//我们又不定义它,所以这两个函数就不能被调用,如果定义了,反而在类内部会被调用
// 拷贝构造函数和赋值重载函数,不符合题意;并且我们声明为私有函数,别人想要
//从类外面自己定义也是做不到的,所以这样的类是不能被拷贝的
class A
{
public:
private:
	A(const A& a);
	A& operator=(const A& a);
};
// C++11语法下:
// 
// C++11扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上 = delete,
// 表示让编译器删除掉该默认成员函数。
// 所以直接用关键字delete把拷贝构造函数和赋值重载函数删除掉即可
class A
{
private:
	A(const A& a) = delete;
	A& operator=(const A& a) = delete;
};

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

//2、请设计一个类,只能在堆上创建对象
// 
//方法一:要想设计一个类只能在堆上创建对象,只需要将析构函数私有即可
//原因:因为只要定义出对象的,对象是自定义类型,必然需要调用构造
// 函数和析构函数,而现在把析构函数私有,则定义的对象在销毁的时候
// 无法调用析构函数,就一定会报错
//但是如果是在堆上创建对象,返回值是一个对象的指针,指针是内置类型,
//不会调用构造函数和析构函数,所以即使析构函数是私有的,也可以通过
//new在堆上创建对象
class HeapOnly
{
public:
	void func()
	{
		cout << "func" << endl;
	}
	void Destroy()
	{
		//这里delete掉this指针等于是释放了调用
		//该函数的类的指针,这种写法是正确的
		delete this;
		cout << "~HeapOnly()" << endl;
	}
private:
	//析构函数私有
	~HeapOnly()
	{}
private:
	int _b;
};
//方法二:把构造函数私有,然后提供一个CreateObj的函数,
// 这个函数内部用new创建一个对象,然后返回对象的指针即可,
// 但是要注意把拷贝构造和赋值重载函数delete掉,防止别人
// 在栈上构造对象
//
class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		HeapOnly* ptr = new HeapOnly;
		return ptr;
	}
private:
	HeapOnly()
	{}
	HeapOnly(const HeapOnly& ho) = delete;
	HeapOnly& operator=(const HeapOnly& ho) = delete;
};
int main()
{
	//static B b;
	HeapOnly* pb = new HeapOnly;
	pb->func();
	//HeapOnly b(*pb);
	pb->Destroy();
	return 0;
}
//int main()
//{
//	HeapOnly* ho = HeapOnly::CreateObj();
//
//	return 0;
//}

三、设计一个类,只能从栈上创建对象

//3、请设计一个类,只能在栈上创建对象
//不能完全设计出只在栈上创建对象的类;
//沿用2的设计思路,把构造函数私有,然后提供一个CreateObj的函数,
//该函数返回一个在栈上创建的对象。
//因为这个返回的是临时对象,所以不能把拷贝构造函数和赋值函数delete掉,
//因为传值返回对象需要被拷贝。
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
	void func()
	{
		cout << "StackOnly()" << endl;
	}
private:
	StackOnly()
	{}
	// 对一个类实现专属operator new,这句代码的意思是把用new
	//创建该类对象的方法delete掉,外部不能再利用new来创建对象了
	void* operator new(size_t size) = delete;
};
int main()
{
	StackOnly so = StackOnly::CreateObj();
	cout << &so << endl;
	int a = 0;
	cout << &a << endl;
	so.func();
	//因为用户可能用new调用拷贝构造函数在堆上创建对象,所以需要
	// 把类的专属的operator new给delete掉,禁止用new在堆上创建对象
	//StackOnly* pso = new StackOnly(so);
	//这个类唯一不能禁止的就是在静态区创建对象,因为要在栈上创建对象就
	//一定要有拷贝构造函数,有拷贝构造函数就可以在静态区创建静态对象
	static StackOnly so1= StackOnly::CreateObj();
	static int b = 0;
	cout << &so1 << endl;
	cout << &b << endl;
	return 0;
}

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

//4. 请设计一个类,不能被继承
// 
//C++98语法
//构造函数私有,然后提供一个CreateObj函数创建对象
// 原因:构造函数私有,也就意味着构造函数不能被显式地调用,
// 因为在继承体系中,子类成员中父类的成员必须调用父类的构造函数
// 初始化父类那一部分成员的,所以如果把父类的构造函数私有,子类
// 就没有办法调用父类的构造函数初始化父类那一部分成员,所以就继承不了
//
class Final
{
public:
private:
	Final(int f)
		:_f(f)
	{}
	int _f = 0;
};
class A:public Final
{
public:
	//A的构造函数无法调用Final的构造函数,所以Final类不能被继承
	A()
		:Final(2)
		,_a(1)
	{}
private:
	int _a;
};
//C++11语法:
//C++11提供了一个关键字final,即直接在类后面加上final表示该类不能被继承
class Final final
{
public:
	Final(int f)
		:_f(f)
	{}
private:
	int _f = 10;
};
这里就会报错了,因为Final是不可被继承的
//class F :public Final
//{
//
//};

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

设计模式:

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

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

单例模式:

一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置

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

5.1 饿汉模式

//1、饿汉模式:一开始(main函数之前)就创建单例对象
//优点:简单
//缺点:
// (1) 如果单例对象要初始化的内容很多,启动速度慢。
// (2) 如果A单例对象的创建依赖B单例对象,要求B对象先创建好,但是我们无法保证先让B单例对象创建好。
// (3) 如果单例对象很大,占用资源很多,但是单例对象创建出来之后不是立刻使用,
//     会占用着大量的内存,导致其它需要内存的地方获取不到内存。
namespace hungry
{
	class Singalton
	{
	public:
		static Singalton& GetInstance()
		{
			return _Inst;
		}
	private:
		//构造函数私有,防止别人随意创建对象
		Singalton()
		{}
		//把拷贝构造函数和赋值重载函数删除掉,防止拷贝
		Singalton(const Singalton& sg) = delete;
		Singalton& operator=(const Singalton& sg) = delete;
		//因为全局只有唯一的一个对象,如何保证我们每次获取到的都是同一个对象呢?
		// 因为静态的全局变量在main函数之前就会定义好的,所以静态的全局变量是全局唯一的。
		// 所以这里一般都是在类里面声明一个静态的Singalton对象(类外定义),
		// 在Singalton类里面可以声明Singalton的静态对象吗?
		// 声明静态对象static Singalton是可以的,
		// 但是声明普通对象Singalton就不行,为什么呢?
		// 因为声明普通对象的话就会出现无限套娃的情况了,对象里面又会套一个对象;但
		// 是声明静态的Singalton对象为什么就可以了呢?
		// 因为静态的Singalton对象本身并不存在于Singalton类的空间里面,而是存在于
		// 静态区中,属于所有对象共有的,所以不存在套娃的情况的,所以可以声明静态的Singalton对象的。
		// 
		// 同时要注意,这里只是声明,普通静态对象必须在类外面定义,但是const static对象比较特殊,
		// 可以在类内定义这样每一次调用GetInstance的时候就返回这个静态的对象就可以保证每次返回的都是
		// 同一个_Inst了
		static Singalton _Inst;
 
		// 在C++中,允许在类内部声明一个本类的静态对象的原因是为了方便和灵活性,
		//当声明一个类的静态成员时,编译器只需要知道该成员的类型和名称,而不需要
		//知道成员的具体定义和大小。这样做的好处是可以避免一些循环依赖的问题。如
		// 果不允许在类内部声明本类的静态对象,那么在类定义之前就无法实例化包含静
		// 态成员的对象,因为在类定义之前,编译器还不知道该类的完整定义。
		//通过在类内部声明本类的静态对象,可以为程序提供更高的灵活性。在类定义之后
		// 的任何位置,都可以在需要的时候进行定义和初始化这个静态对象。这样,程序员
		// 可以根据需要更具灵活性地控制对象的创建和使用。
		//需要注意的是,在定义之前使用这个静态对象可能会导致未定义的行为,因此在类
		// 定义之后的某个地方,一定要进行静态对象的定义和初始化,以确保它的正确使用。
	};
	//定义,在main函数之前就已经创建好了单例对象
	Singalton Singalton::_Inst;
}
int main()
{
	//每次调用GetInstance获取到的对象都是同一个
	cout << &hungry::Singalton::GetInstance() << endl;
	cout << &hungry::Singalton::GetInstance() << endl;
	cout << &hungry::Singalton::GetInstance() << endl;
	return 0;
}

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

5.2 懒汉模式

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

//2、懒汉模式
//比较懒,到有人定义对象的时候才创建对象
//(1) 优点:第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
//(2) 缺点:复杂。
namespace lazy
{
	class Singalton
	{
	public:
		static Singalton* GetInstance()
		{
			//这里要使用双判断加锁的方式处理,这样才能很好地提高效率
			
			//这个if是判断第一次调用实例对象时需要先创建对象
			if (_pInst == nullptr)
			{
				//加锁避免线程安全的问题,两个线程同时进入了这里,需要先竞争锁
				_pmtx->lock();
				//这个if是判断如果两个进程同时来到了这里,竞争到锁的进程
				//先来到这个判断条件,如果_pInst还是nullptr,说明这是第一次调用实例对象
				//此时创建一个Singalton,后竞争到锁的进程在再一次if判断时_pInst就不再是nullptr
				//了,此时说明单例对象已经存在了,就不会再创建了
				if (_pInst == nullptr)
				{
					_pInst = new Singalton;
				}
				_pmtx->unlock();
			}
			return _pInst;
		}
		//一般情况下,单例对象不需要释放,因为程序正常结束就释放了,
		// 并且单例对象一般也不大,所以可以把析构函数设置成私有
		//
		// 但是有些特殊场景:
		// 1、中途需要显式释放;
		//2、程序结束时需要做一些持久化(把数据写入到文件中);
		// 所以需要提供一个显式调用的DelInstance函数(里面封装析构函数)
		static void DelInstance()
		{
			cout << "DelInstance()" << endl;
			if (_pInst != nullptr)
			{
				//自定义对象,调用_pInst对象的析构函数
				delete _pInst;
				delete _pmtx;
			}
		}
		void Add(const pair& val)
		{
			_um.insert(val);
		}
	private:
		//构造函数
		Singalton()
		{}
		//析构函数
		~Singalton()
		{
			//显式调用析构函数书写日志或者持久化(数据写入文件)
			cout << "~Singalton()" << endl;
			FILE* fp = fopen("test.txt", "w");
			for (const auto& e : _um)
			{
				fputs(e.first.c_str(), fp);
				fputs(":", fp);
				fputs(e.second.c_str(), fp);
				fputs("\n", fp);
			}
		}
		//拷贝构造函数,单例模式防拷贝
		Singalton(const Singalton& sg) = delete;
		//赋值重载函数
		Singalton& operator=(const Singalton& sg) = delete;
		//相当于一个垃圾回收类
		class GC
		{
		public:
			//用Gc的析构函数管理单例类的析构函数,因为在Singalton中声明了一个Gc的静态的
			//成员变量,所以在进程结束的时候会调用析构函数,而Gc析构函数又管理着Singalton的
			// 析构函数DelInstance,所以无论如何进程结束的时候都会自动调用Singalton的析构
			// 函数的,所以就不存在内存泄漏的隐患了
			//
			~GC()
			{
				DelInstance();
			}
		};
	private:
		//如何保证每次调用GetInstance函数的时候获取到的_Inst都是同一个呢?因为这里是运行时
		//才创建对象的,所以不能用静态的对象,而这里要获取到同一个对象,所以只能在堆上开辟;
		//但是这里为什么是用静态的呢?因为GetInstance是静态的,没有this指针,但是GetInstance
		//函数中需要用到_Inst,所以需要这个_Inst也要设置为静态的,这样GetInstance函数才能访问_Inst
		//同理_mtx也要是静态的
		static Singalton* _pInst;
		static mutex* _pmtx;
		unordered_map _um;
		//在单例类中声明一个Gc类型的静态的成员变量,在类外定义;该对象在进入main函数前就已经创建好了,
		//到进程结束时才调用析构函数销毁,说明这个变量是整个进程都有效的
		static GC gc;
	};
	//必须在类外定义类内的静态成员变量
	Singalton* Singalton::_pInst = nullptr;
	mutex* Singalton::_pmtx = new mutex;
	Singalton::GC Singalton::gc;
}
//GC也可以这样写,这样写更容易理解,用GC创建一个全局对象,进程结束时GC调用析构函数,
// 进而调用lazy::Singalton::DelInstance()释放单例对象,但是遇到多个单例类就把它们
// 全部放到~GC函数中即可,上面那种写法就是把GC定义到单例类内部,每一个GC对象管理一个单例类
//class GC
//{
//public:
//	~GC()
//	{
//		lazy::Singalton::DelInstance();
//	}
//};
//GC gc;
int main()
{
	//lazy::Singalton* p1 = lazy::Singalton::GetInstance();
	//lazy::Singalton* p2 = lazy::Singalton::GetInstance();
	//lazy::Singalton* p3 = lazy::Singalton::GetInstance();
	//cout << p1 << endl;
	//cout << p2 << endl;
	//cout << p3 << endl;
	lazy::Singalton* p1 = lazy::Singalton::GetInstance();
	p1->Add(make_pair("string", "字符串"));
	p1->Add(make_pair("left", "左边"));
	p1->Add(make_pair("right", "右边"));
	return 0;
}

以上就是常见的特殊类的设计,你学会了吗?今天的分享就到这里啦,如果你感觉到有所收获,那么就点点小心心点点关注呗,后期还会持续更新C++的相关知识哦,我们下期见!!!