特殊类设计
1.请设计一个类,不能被拷贝2.请设计一个类,只能在堆上创建对象3.请设计一个类,只能在栈上创建对象4.请设计一个类,不能被继承5.请设计一个类,只能创建一个对象(单例模式)
1.请设计一个类,不能被拷贝
拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。
class CopyBan{ // ... private: CopyBan(const CopyBan&); CopyBan& operator=(const CopyBan&); //...};
为什么只声明不实现呢?
因为自己不声明,库就会自动生成。因此只要自己写库就不会默认生成。
为什么声明私有呢?
如果声明为公有类外面可以实现别人就可以调用。
C++11扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上=delete,表示让编译器删除掉该默认成员函数。
class CopyBan{ // ... CopyBan(const CopyBan&)=delete; CopyBan& operator=(const CopyBan&)=delete; //...};
2.请设计一个类,只能在堆上创建对象
1.首先我们必须要把构造函数私有
如果不把构造私有分分钟钟就创建出三个对象,并且这三个对象在不同的位置栈、堆、静态区。
class HeapOnly{};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}
因此把构造私有
class HeapOnly{private:HeapOnly(){}};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}
这样类外面就调不了构造函数。外面就不随便创建对象!
但是我还是需要创建需要的对象,因此类内部写一个创建对象的成员函数
class HeapOnly{public:HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};
但是现在问题就来了,外面根本不能创建出对象,也就是说根本调不动CreteObj。
那怎么办呢?
2.提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建
静态成员函数没有this指针,可以不用对象去调用,使用类域::类的成员函数调用
class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};int main(){//HeapOnly hp1;//HeapOnly* php2 = new HeapOnly;//static HeapOnly hp3;HeapOnly* php4=HeapOnly::CreateObj();return 0;}
现在这个写法有没有什么地方没有考虑到?
就是不只在堆上,还可以在别的地方创建出对象,假如是栈。
int main(){HeapOnly* php4=HeapOnly::CreateObj();//hp5在栈上!HeapOnly hp5(*php4);//拷贝构造return 0;}
3.防拷贝
class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}HeapOnly(const HeapOnly&) = delete;//这里赋值不用delete的,自己不写编译器默认生成的是浅拷贝,对象还是在堆上};
这是一种完整方法,只能在堆上创建对象!
还有一种方法析构函数私有+拷贝构造delete!
class HeapOnly{public:HeapOnly(){}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly hp1;return 0;}
原因在于出了作用域会调用析构函数,这里不让调用编译就报错了。
这种写法确实只可以在堆上申请对象!但是有没有什么问题?
int main(){//HeapOnly hp1;HeapOnly* php2 = new HeapOnly;return 0;}
最显然就是没有办法delete释放资源了,有没有什么办法解决一下?
在类内部写一个Destory去释放资源。
class HeapOnly{public:HeapOnly(){}void Destory(){delete this;//或者调用显示调用析构1:对象.析构 2:this->析构//this->~HeapOnly();}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly* php2 = new HeapOnly;php2->Destory();return 0;}
3.请设计一个类,只能在栈上创建对象
方法1:同上将构造函数私有化,然后设计静态方法创建对象返回
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();return 0;}
还有一种方法说的禁掉new和delete。
因为new在底层调用void* operator new(size_t size),只需要将该函数屏蔽掉即可。
注意:也要防止定位new
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}void* operator new(size_t size) = delete;void* operator delete(size_t size) = delete;//private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();StackOnly* pso = new StackOnly;//静态封不掉static StackOnly so2;return 0;}
这种方法是有问题的,如果只禁用operator new、operator delete,只是不想在堆上创建对象,但是可以在除了堆上的其他地方创建对象,全局、局部、静态都可以!
如果加上也可以,但是还是要把构造给封掉,不然静态还是可以的。
方法1的代码还有没有其他问题?
有的,方法1并没有把路封死!
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();static StackOnly so2 = StackOnly::CreateObj();return 0;}
静态对象还可以实现
那把拷贝构造封掉试一试
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};
但是这里又不行了
这里拷贝构造不行了,那我提供一个移动构造
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(StackOnly&&){}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};
但这里又行了
这里想说的是这个类封不死!静态的确实没有很好的办法解决。
如果真的把这里封死就一种办法,把拷贝构造封死,不让用的人这样使用。
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}//StackOnly(StackOnly&&)//{}void Print() const{cout << "StackOnly::Print()" << endl;}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};int main(){//不用这样使用//StackOnly so1=StackOnly::CreateObj();//static StackOnly so2 = StackOnly::CreateObj();//而是这样用//1.StackOnly::CreateObj().Print();//2.const StackOnly& so1= StackOnly::CreateObj();so1.Print();return 0;}
4.请设计一个类,不能被继承
C++98方式// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承class NonInherit{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}};
子类继承父类,必须要调用父类的构造函数,如果自己没有调用显示写调用父类,编译器就会自动调用父类的构造函数,但是父类构造私有了因此就会报错。即使在子类种显示写了调用父类构造,但是因为父类构造还是私有的,还会报错。因此这个父类就不能被子类继承!
C++11方法final关键字,final修饰类,表示该类不能被继承。
class A final{ // ....};
5.请设计一个类,只能创建一个对象(单例模式)
设计模式:
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
设计模式有二十多种但是常见就那么几种。C++常见的就是迭代器模式、适配器模式、单例模式,今天就主要说说单例模式,有兴趣的可以在扩展了解工厂模式、观察者模式。
单例模式:
一个类只能创建一个全局的唯一对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
任何一个类都可以写成单例模式。单例模式的类的特定:全局只有一个唯一对象。
现在考虑这样一个问题,如何让一个类全局只有一个唯一对象呢?
和上面的思路是一样的。首先还是让构造私有!不然就随意创建对象了。
class InfoSingleton{public:private:InfoSingleton(){}map<string, int> _info;//...};int main(){//InfoSingleton s1;//InfoSingleton s2;//InfoSingleton s3;return 0;}
其次单例一般都会提供一个GetInstance()的静态成员函数去获取全局的唯一对象。
class InfoSingleton{public:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}map<string, int> _info;//...};
该如何获取呢全局的唯一对象呢?
直接定义一个全局的行不行?
class InfoSingleton{public:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}map<string, int> _info;//...};//类外直接定义一个全局的InfoSingleton ins;
是不行的,这里调用不了构造函数!
我们先见见第一种方法
class InfoSingleton{public:static InfoSingleton& GetInstance(){//直接返回就行return _sins;}private:InfoSingleton(){}map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义,因为它的类里面的因此可以调用构造函数
可以认为静态的成员就是全局的,生命周期也是全局的。并且在main之前就初始化了。它和定义一个全局的没有任何区别,只是属于这个类域而已。
想获取这个对象就直接使用类域::成员函数。
int main(){InfoSingleton::GetInstance();return 0;}
假设这个类提供一些其他函数,我们就可以如下访问。
class InfoSingleton{public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}}private:InfoSingleton(){}map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义,因为它的类里面的因此可以调用构造函数//InfoSingleton ins;int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();return 0;}
单例模式有两种实现模式:
第一种:饿汉模式就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象(也就是说一开始(main函数之前)就创建对象),上面那种写法就是饿汉模式。
但是目前现在写的这种方法有一些不好的地方。保证不了单例!
int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造InfoSingleton copy = InfoSingleton::GetInstance();copy.insert("赵六", 20000);copy.Print();infos1.Print();return 0;}
现在已经产生了两个对象了。
因此这里也要禁掉拷贝构造,甚至我也不想要赋值发生!
class InfoSingleton{public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义,因为它的类里面的因此可以调用构造函数//InfoSingleton ins;int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造//InfoSingleton copy = InfoSingleton::GetInstance();//copy.insert("赵六", 20000);//copy.Print();infos1.Print();return 0;}
饿汉模式的优点:
简单饿汉模式的缺点:
单例对象初始化数据太多,导致启动慢(因为在main函数之前就会初始化)多个单例有初始化依赖关系,饿汉模式无法控制![在这里插入图片描述](http://zhangshiyu.com/zb_users/upload/2024/03/20240320162253171092297381812.png)
因为饿汉都是全局对象,全局对象到底谁先初始化谁后初始化,主要看编译器自己。同一个文件有先后顺序,不同文件先后顺序很难自己控制!
基于这些问题,单例还有另一种模式
懒汉模式如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
不要一开始就创建,用的时候在创建!并且只在第一次的时候创建对象,其他直接返回即可。
饿汉模式 —> 静态对象
懒汉模式 —> 静态指针
class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){//第一次获取单例对象的时候创建对象if (_psins == nullptr){_psins = new InfoSingleton;}return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton* _psins;};InfoSingleton* InfoSingleton::_psins=nullptr;
懒汉模式把上面的问题都给解决了
懒汉模式的优点:
对象在main函数之后才会创建,不会影响启动顺序可以主动空间创建顺序懒汉模式的缺点:
复杂接下来我们看看复杂在那些方面
目前这段代码有没有什么问题?
多个线程一起调用GetInstace(),存在线程安全的风险
有两个线程来了之后,可能都会进入到if里面,会new两次,最终_psins指向的是第二个线程new出来的对象,这就有问题了。
如何解决呢?
加锁!
注意因为GetInstace()是静态成员函数,没有this指针只能访问静态成员变量,因此锁也要是一个静态的锁!
class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){_smtx.lock();if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton* _psins;static mutex _smtx;};InfoSingleton* InfoSingleton::_psins=nullptr;mutex InfoSingleton::_smtx;
加锁之后就是线程安全的了,但是这样加锁有没有什么问题?
我只想保证第一次加锁解锁后面不需要加锁解锁了。但是现在每次线程进来都需要加锁解锁,但加锁解锁也是需要资源的!
能不能把锁放在if里面?
这样是不行的!可能两个线程还是都进入if里面,其他一个线程先加锁new一个对象然后解锁,但是时间片到了就切走了,另一个线程就开始加锁然后也new一个对象最后解锁,现在就是线程不安全的了!
这里真正的解决办法:双检查加锁
不仅是这里,以后只要是想保护第一次申请都可以用这种方法!
static InfoSingleton& GetInstance(){//第一次if,对象new出来之后,避免每次都加锁的检查,提高性能if (_psins == nullptr){_smtx.lock();//第二次if,保证线程安全且只能new一次if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();}return *_psins;}
饿汉模式没有线程安全吗?需要加锁吗?
饿汉模式没有线程安全的问题,因此不需要加锁!main函数之前没有可能存在两个线程去调用GetInstance(),在main函数之前这个单例模式的静态对象就已经初始化好了。而这个线程是自己些的并且在main函数之后才会调用的。但是对象已经创建好了因此不存在线程安全的问题。
再看这段代码,还有没有什么问题?
new可能抛异常,造成没解锁
第一次解决方法就是捕捉异常
static InfoSingleton& GetInstance(){if (_psins == nullptr){_smtx.lock();try{if (_psins == nullptr){_psins = new InfoSingleton;}}catch (...){_smtx.unlock();throw;}}return *_psins;}
但是这种写法有点挫。
第二种解决方法RAII管理锁
构造时加锁,析构时解锁!
可以自己写一个RAII锁管理类
//RAII锁管理类template<class Lock>class LockGuard{public:LockGuard(Lock& mtx):_mtx(mtx)//锁不能拷贝构造,1.传锁的地址过来 2.私有成员给个引用{_mtx.lock();}~LockGuard(){_mtx.unlock();}private:Lock& _mtx;//引用的成员变量,必须在初始化列表初始化};class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){if (_psins == nullptr){LockGuard<mutex> lockguard(_smtx);//_smtx.lock();if (_psins == nullptr){_psins = new InfoSingleton;}//_smtx.unlock();}return *_psins;}//。。。。};
或者用库里提供的RAII风格的锁
static InfoSingleton& GetInstance(){if (_psins == nullptr){std::lock_guard<mutex> lock(_smtx);if (_psins == nullptr){_psins = new InfoSingleton;}}return *_psins;}
现在这个代码还有没有可以优化的呢?
可能会想到释放的问题。
一般单例对象不需要考虑释放!单例对象在整个程序运行期间都要在都要用,所以一般不需要释放,那new了就不delete会有问题吗?其实也并没有什么问题。进程正常结束之后会清理资源。
有些地方需要考虑释放问题: 如单例对象不用时,一些资源需要保存,必须要手动处理!
就可以提供一个静态的DelInstance()
static void DelInstance(){//保存数据到文件//...std::lock_guard<mutex> lock(_smtx);if (_psins){delete _psins;_psins = nullptr;}}
如果忘记调用,但是必须要把数据存到文件中呢?
可以内部再实现一个类,实现自动回收!
class InfoSingleton{public:static InfoSingleton& GetInstance(){if (_psins == nullptr){std::lock_guard<mutex> lock(_smtx);if (_psins == nullptr){_psins = new InfoSingleton;}}return *_psins;}static void DelInstance(){//保存数据到文件//...std::lock_guard<mutex> lock(_smtx);if (_psins){delete _psins;_psins = nullptr;}}class GC//内部类是外部类有元{public:~GC(){if (_psins){DelInstance();//所以这里可以直接调}}};//。。。private:static InfoSingleton* _psins;static mutex _smtx;static GC _gc;};InfoSingleton* InfoSingleton::_psins=nullptr;mutex InfoSingleton::_smtx;InfoSingleton::GC InfoSingleton::_gc;//定义一个GC类的对象,main函数结束之后会自动调用GC的析构函数
这两种写法既可以手动调用主动回收,也可以让它在程序结束之后自动回收。
见识到懒汉的复杂之处了把,其实懒汉还有一种非常方便的写法。
懒汉模式二
class InfoSingleton{public://静态函数中写个该类静态对象static InfoSingleton& GetInstance(){static InfoSingleton sinst;return sinst;}//。。。private:InfoSingleton(){cout << "InfoSingleton()" << endl;}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...};
这种写法能不能称为懒汉?
可以的。懒汉只有在第一次调用的时候在创建对象。
现在这个局部静态对象它就是main函数之前初始化,还是在main函数之后初始化的?
局部静态是在main函数之后才会初始化,并且只会在第一次调用才会调用构造函数,第二次开始之后就不会在调用构造了,而是直接用。
所以这种写法就是懒汉模式。
但是这种写法需要注意一些问题:
是懒汉,因为静态的局部变量是在main函数之后才创建初始化的C++11之前,这里是不能保证static的初始化是线程安全的C++11之后,可以