大龄工找工作哪个网站好,南宁企业门户网站建设价格,wordpress 搭建知识库,用手机制作ppt用什么软件目录 一、设计一个类#xff0c;不能被拷贝二、设计一个类#xff0c;只能在堆上创建对象三、设计一个类#xff0c;只能从栈上创建对象四、设计一个类#xff0c;不能被继承五、设计一个类#xff0c;只能创建一个对象#xff08;单例模式#xff09;5.1 饿汉模式5.2 懒… 目录 一、设计一个类不能被拷贝二、设计一个类只能在堆上创建对象三、设计一个类只能从栈上创建对象四、设计一个类不能被继承五、设计一个类只能创建一个对象单例模式5.1 饿汉模式5.2 懒汉模式 一、设计一个类不能被拷贝
//1、请设计一个类不能被拷贝
//
// 拷贝一个类要么调用拷贝构造函数要么调用赋值重载函数所以要令一个类不能
// 被拷贝只需要让该类不能调用拷贝构造和赋值重载函数就可以了。
//
// 在C98语法下只需要把该类的拷贝构造函数和赋值重载函数声明为私有
// 并且不定义即可
//
//原因拷贝构造函数和赋值重载函数只要我们声明了编译器就不会再默认生成但是
//我们又不定义它所以这两个函数就不能被调用如果定义了反而在类内部会被调用
// 拷贝构造函数和赋值重载函数不符合题意并且我们声明为私有函数别人想要
//从类外面自己定义也是做不到的所以这样的类是不能被拷贝的class A
{
public:
private:A(const A a);A operator(const A a);
};// C11语法下
//
// C11扩展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. 请设计一个类不能被继承
//
//C98语法
//构造函数私有然后提供一个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;
};
//C11语法
//C11提供了一个关键字final即直接在类后面加上final表示该类不能被继承
class Final final
{
public:Final(int f):_f(f){}private:int _f 10;
};这里就会报错了因为Final是不可被继承的
//class F :public Final
//{
//
//};五、设计一个类只能创建一个对象单例模式
设计模式 设计模式Design Pattern是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 使用设计模式的目的为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化设计模式是软件工程的基石脉络如同大楼的结构一样。
单例模式 一个类只能创建一个对象即单例模式该模式可以保证系统中该类只有一个实例并提供一个访问它的全局访问点该实例被所有程序模块共享。比如在某个服务器程序中该服务器的配置 信息存放在一个文件中这些配置数据由一个单例对象统一读取然后服务进程中的其他对象再通过这个单例对象获取这些配置信息这种方式简化了在复杂环境下的配置管理。
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 pairstring, string 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_mapstring, string _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的相关知识哦我们下期见
