当前位置：首页 > ai >正文

特殊类设计

ai 2025/8/5 15:55:28

1. 请设计一个类，不能被拷贝

2. 请设计一个类，只能在堆上创建对象

3. 请设计一个类，只能在栈上创建对象

4. 请设计一个类，不能被继承

5. 请设计一个类，只能创建一个对象（单例模式）

1. 请设计一个类，不能被拷贝

有时候有些地方会有一些特殊的要求，对一些类进行一些特殊的要求，设计，比如一个类不能被拷贝，一个类不能被拷贝，这个需求是非常的常见的，比如说像IO流就是不能被拷贝的。

拷贝构造都是被禁掉的，就算是移动构造的话也只能再类内部进行使用，在外部是不能使用的。IO流底层设计的缓冲区，不允许拷贝的，线程也是不允许拷贝的，

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

C++98

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其风闻权限设置为私有即可，设置为公有的话别人会在外面实现的。

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

原因：

1、设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了

2、只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

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

2. 请设计一个类，只能在堆上创建对象

实现方式：

1、将类的构造函数私有，拷贝构造声明或私有，防止别再调用拷贝在栈上生成对象。

2、提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

方法1：

#include <iostream>
using namespace std;class HeapOnly
{
public:static HeapOnly* CreateObj(){return new HeapOnly;}HeapOnly(const HeapOnly&) = delete;HeapOnly& operator=(const HeapOnly&) = delete;
private:// 构造函数私有化HeapOnly(){}
};int main()
{// static HeapOnly hp0; // 静态区创建// HeapOnly hp1; // 栈上创建// HeapOnly* hp2 = new HeapOnly; // 堆上创建HeapOnly* hp3 =  HeapOnly::CreateObj(); // 堆上// HeapOnly hp4(*hp3); // 栈上delete hp3;return 0;
}/*
把路全部堵死，然后提供在堆上创建对象的方法。
然后掉创建对象的方法，可是没有对象啊，这就是先有鸡还是先
有蛋的问题，所以我们可以用static来打破这个循环
*/// 拷贝构造和赋值重载禁掉，防止拷贝和赋值
// 外面不能用，但是在类里面可以用。

方法2：将析构函数私有化

class HeapOnly
{
public:void Destroy(){delete this; // 析构私有，在类外不可以，在类里面可以}
private:// 析构函数私有化~HeapOnly(){}
};int main()
{static HeapOnly hp0; // 静态区创建HeapOnly hp1; // 栈上创建HeapOnly* hp2 = new HeapOnly; // 堆上创建//delete hp2;hp2->Destroy();return 0;
}// 析构函数私有化hp0和hp1创建不了，因为生命周期结束以后
// 他们要自动调用析构函数，析构函数调不动啊。
// hp2没问题，是指针，只有自定义类型的对象才会自动调用
// 构造和析构，上面的是断前路，这个是断后路
// 当然我们要delete hp2也delete不了，delete是由析构和
// operator delete构成，那么这个时候就要提供静态的Destroy
// 函数，在里面delete，因为私有的在类里面可以调用的
// 这个时候可以考虑布冯拷贝构造，因为析构封了，对象创建不
// 出来

3. 请设计一个类，只能在栈上创建对象

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

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}// 不能封死,否则CreateObj用不了，// StackOnly(const StackOnly& s) = delete;void* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private:StackOnly():_a(0){}
private:int _a;
};int main()
{//static StackOnly s1; // 静态的//StackOnly s2; // 局部的//StackOnly* s3 = new StackOnly; // new的StackOnly s4 = StackOnly::CreateObj();// new调的是构造，那么也可以调拷贝构造// 把拷贝构造封了？那CreateObj走的是传值返回// 栈上创建的局部对象，只能走传值返回// 局部对象走传值返回一定要调用拷贝构造啊，// 所以这个地方封拷贝构造是不好封的，// 我们可以考虑封operator new和operator delete// new由两部分构成，一部分是operator new,另外// 一部分才是构造，operator new怎么封呢？// operator new默认是全局函数，但是C++固定，如果一个// 类重载了专属的operator new的话，它必须得调用专属// 的operator new，// StackOnly* s5 = new StackOnly(s4);// delete掉new和delete可以封死上面的，但是封不死下面的static StackOnly s6(s4); // 拷贝构造不封的话始终有问题StackOnly s7(s4); // 拷贝构造不封的话始终有问题return 0;
}

反正这里还是没有封死，拷贝构造不能封，但是不封拷贝构造能调也是有问题的，那么我们可以从C++11的角度解决一下这个问题。我们还是考虑封拷贝构造。

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}// 提供移动构造StackOnly(StackOnly &&s){}// 为什么移动构造就可以呢？/*return匿名对象就是右值，就算是左值，也可以move一下，弄成右值以后，哪怕生成中间的临时对象，走移动构造，临时对象再走s4也是移动构造，当然编译器优化不会产生临时对象，直接走到s4，甚至是直接一步构造，不管编译器优化不优化，这里要么走构造，要么走移动构造，不会走拷贝构造。*/StackOnly(const StackOnly& s) = delete;
private:StackOnly():_a(0){}
private:int _a;
};int main()
{//static StackOnly s1; // 静态的//StackOnly s2; // 局部的//StackOnly* s3 = new StackOnly; // new的StackOnly s4 = StackOnly::CreateObj();//StackOnly* s5 = new StackOnly(s4);// delete掉new和delete可以封死上面的，但是封不死下面的//static StackOnly s6(s4); // 拷贝构造不封的话始终有问题//StackOnly s7(s4); // 拷贝构造不封的话始终有问题// 就算封死拷贝构造，提供移动构造，还可以这样玩static StackOnly s6(move(s4));StackOnly* s5 = new StackOnly(move(s6));return 0;
}

还是第一种方法更好一点，最起码把new给堵死了。

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）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

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

比如迭代器模式、适配器模式、还有现在的单例模式，还有工厂模式、观察者模式、装饰器模式。

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务i进程中的其他对象再通过这个单例对象获取到这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式：

饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

// 饿汉模式
// 1、多个饿汉模式的单例，某些对象初始化内容较多(读文件)，初始化程序启动慢
// 因为单例要在main函数开始前创建好,main函数前也没有多线程的概念,要不然还
// 可以并发
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，A再初始化，饿汉
// 无法保证
class InfoMgr
{
public:static InfoMgr& GetInstance(){return _ins;}void print(){cout << _ip << endl;cout << _port << endl;cout << _buffSize << endl;}
private:InfoMgr(const InfoMgr&) = delete;InfoMgr& operator=(const InfoMgr&) = delete;InfoMgr(){}
private:string _ip = "127.0.0.1";int _port = 80;size_t _buffSize = 1024 * 1024;// ...// 不是对象中创建自己, 类里面声明static InfoMgr _ins; // 静态的在静态区，就是一个全局的静态
};InfoMgr InfoMgr::_ins; // 类外面定义int main()
{/*InfoMgr info1;InfoMgr info2;static InfoMgr info3;*/InfoMgr::GetInstance().print();//InfoMgr copy(InfoMgr::GetInstance()); // 要封拷贝构造return 0;
}

懒汉模式

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

// 懒汉模式 - 针对饿汉进行的改良的版本class InfoMgr
{
public:static InfoMgr& GetInstance(){// 第一次调用时创建单例对象// 线程安全的风险if (_pins == nullptr){_pins = new InfoMgr;}return *_pins;}void print(){cout << _ip << endl;cout << _port << endl;cout << _buffSize << endl;}static void DelInstance(){delete _pins;_pins = nullptr;}
private:InfoMgr(const InfoMgr&) = delete;InfoMgr& operator=(const InfoMgr&) = delete;InfoMgr(){}
private:string _ip = "127.0.0.1";int _port = 80;size_t _buffSize = 1024 * 1024;// ...static InfoMgr* _pins;
};InfoMgr* InfoMgr::_pins = nullptr; // 类外面定义int main()
{InfoMgr::GetInstance().print();return 0;
}/*
1、线程安全的风险
2、懒汉模式单例释放，因为是new出来的，所以要手动释放，但是
因为是全局的，程序结束也就释放了，而且只有一份，倒也不影响,
内存怕的是持续不断的内存泄漏
*/

懒汉模式还有一种更简单的方式。

// 懒汉模式还有一种更简单的方式，这种方式再C++11之后比较推荐class InfoMgr
{
public:static InfoMgr& GetInstance(){// 第一次调用时创建单例对象// 局部静态的特点不是再main函数之前就初始化，而是// 在第一次调用的时候初始化，局部的静态跟全局的静态// 不一样，类里面的静态是全局的静态，main函数之前就// 初始化了，这个不是main函数之前就初始化的，不是main// 函数之前就初始化的，创建出来就是懒汉,main函数之前就// 创建出来的就是饿汉，// C++11之后是线程安全的，C++11之前都写的是上面的static InfoMgr ins;return ins;}void print(){cout << _ip << endl;cout << _port << endl;cout << _buffSize << endl;}
private:InfoMgr(const InfoMgr&) = delete;InfoMgr& operator=(const InfoMgr&) = delete;InfoMgr(){}
private:string _ip = "127.0.0.1";int _port = 80;size_t _buffSize = 1024 * 1024;// ...
};int main()
{// 就算多次调用，但只有一份InfoMgr::GetInstance().print();InfoMgr::GetInstance().print();cout << &InfoMgr::GetInstance() << endl;cout << &InfoMgr::GetInstance() << endl;return 0;
}

带锁的懒汉模式。

// 懒汉
// 有点: 第一次使用实例对象时，创建对象。进程启动无负载。多个单例
// 实例启动顺序自由控制// 缺点: 复杂#include <iostream>
#include <mutex>
#include <thread>
using namespace std;class Singleton
{
public:static Singleton* GetInstance(){// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全if (nullptr == m_pInstance){m_mtx.lock();if (nullptr == m_pInstance){m_pInstance = new Singleton();}m_mtx.unlock();}return m_pInstance;}// 实现一个内嵌垃圾回收类class CGarbo{public:~CGarbo(){if (Singleton::m_pInstance)delete Singleton::m_pInstance;}};// 定义一个静态成员变量，程序结束时，系统就会自动调用它的// 析构函数从而释放单例对象static CGarbo Garbo;private:// 构造函数私有Singleton() {};// 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);static Singleton* m_pInstance; // 单例对象指针static mutex m_mtx; // 互斥锁
};Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;int main()
{//thread t1([] {cout << &Singleton::GetInstance() << endl; });//thread t2([] {cout << &Singleton::GetInstance() << endl; });thread t1([] {cout << Singleton::GetInstance() << endl; });thread t2([] {cout << Singleton::GetInstance() << endl; });t1.join();t2.join();//cout << &Singleton::GetInstance() << endl;//cout << &Singleton::GetInstance() << endl;cout << Singleton::GetInstance() << endl;cout << Singleton::GetInstance() << endl;return 0;
}/*
单独再设计一个内部类，这个内部类的析构函数去释放这个单例，然后把
这个对象定义成全局对象或者静态对象，main函数结束会调用析构，
它的析构中就会delete Instance，delete Instance会反向火来调到它的
析构，只要程序结束，一定保证会调到这个单例的析构。
你想要一些东西再main函数结束之后自动做，是可以考虑定义一个类，然后
用这个类设计一个全局对象，全局对象出了作用域就会调用析构函数，那么
你就可以再这个析构函数中干你相干的事情
*/

查看全文

http://www.xdnf.cn/news/8653.html