C++----特殊类的设计

文章目录

特殊类的设计
- 设计一个类不能被拷贝
- 设计一个类，只能在堆上创建对象
- 设计一个类，只能在栈上创建对象
- 设计一个类，不能被继承
- 设计一个类，只能创建一个对象（单例模式）
- - 设计模式
  - 单例模式
  - - 概念
    - 单例模式的实现

特殊类的设计

设计一个类不能被拷贝

IO流也是不允许拷贝的

思路
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
实现：分为C++11之前和C++11以及C++11之后
- C++98
  将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
```
class CopyBan
{// ...
private:CopyBan(const CopyBan&);CopyBan& operator=(const CopyBan&);//...
};
```
  - 设计为私有的原因：如果不设计为私有，那么用户可以在类外对这个构造函数和析构函数进行定义，这样的话就又能拷贝了。为了防止这种情况才设计为私有。赋值重载设置为私有的原因也是如此
    设计为公有导致在类外定义构造函数，使得又能被拷贝的场景
```
class ListNode
{
public:ListNode(const ListNode& node);ListNode() = default;
private:string _s;
};ListNode::ListNode(const ListNode& node)
{_s = node._s;cout << _s << endl;
}int main()
{ListNode node;ListNode copenode(node);
}
```
  - 只声明不定义的原因：不定义是因为该函数根本不会调用，定义了其实也没有什么意义
- C++11
  - C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上 =delete，表示让编译器删除掉该默认成员函数。*
    delete后，就删除掉了该默认成员函数，在public中删除，还是在private中删除都是可以的。类外无法去定义该函数，因为该函数被删除了
  - 样例
```
class ListNode
{
public:ListNode(const ListNode& node) = delete;ListNode() = default;
private:string _s;
};//ListNode::ListNode(const ListNode& node)
//{
//	_s = node._s;
//	cout << _s << endl;
//}int main()
{ListNode node;//ListNode copenode(node);
}
```

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

思路1
**将类的构造函数私有，拷贝构造声明成私有/删除拷贝构造。**防止别人调用拷贝在栈上生成对象。 然后提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

样例

class HeapOnly
{
public:static HeapOnly* CreateObject(){return new HeapOnly;}
private:HeapOnly() {}// C++98// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要// 2.声明成私有HeapOnly(const HeapOnly&);// or// C++11    HeapOnly(const HeapOnly&) = delete;
};int main()
{	HeapOnly* p1 = HeapOnly::GreatObj();//HeapOnly p2(*p1); 上面防拷贝是为了应对这种情况。
}

思路2：析构函数私有化，然后提供一个销毁new出来对象的函数Destroy

class HeapOnly
{
public:void Destroy(){delete this;}
private:~HeapOnly(){}
};int main()
{	HeapOnly* p1 = HeapOnly::GreatObj();//HeapOnly p2(*p1); 上面不用封拷贝构造的原因是 析构函数被封了，p2创建不出来
}

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

**关于operator new 与 operator delete：**当一个类重载了关键字new后，那么new 这个对象的时候，是调用这个operator new 来创建对象。

思路1
将构造函数私有化，然后设计静态方法创建对象返回即可。并且把 operator new 给delete。

样例

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉// StackOnly obj = StackOnly::CreateObj();// StackOnly* ptr3 = new StackOnly(obj);void* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private:StackOnly():_a(0){}
private:int _a;
};int main()
{// StackOnly* p1 = new StackOnly; 是调不动的StackOnly p2 = StackOnly::CreateObj();StackOnly p3(p2);
}

缺陷：该方法无法给封住静态成员，而静态成员在静态区。

思路2
把构造函数，拷贝构造封死。提供移动构造

样例

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}StackOnly(StackOnly&& sty){}StackOnly(const StackOnly& cop) = delete;
private:StackOnly():_a(0){}
private:int _a;
};int main()
{// StackOnly* p1 = new StackOnly; 是调不动的//StackOnly p3(p2);StackOnly p2 = StackOnly::CreateObj();//缺陷static StackOnly p3(move(p2));StackOnly p4 = new StackOnly(move(p2));
}

缺陷：当原对象被move后，可以把对象创建到堆上，也可以创建到栈上

设计一个类，不能被继承

C++98方式
C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承。

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}};

C++11方式：final关键字
通过final关键字修饰类
```
class A final
{//...
};
```
设计一个类，只能创建一个对象（单例模式）

设计模式

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

单例模式

概念

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

单例模式的实现

单例模式的实现有两种方式：饿汉模式，懒汉模式

饿汉模式

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么使用饿汉模式来避免资源竞争，提高响应速度更好。
- 概念：无论将来用不用，程序启动时就创建一个唯一的实例对象。
- 思路
  将析构函数设为私有，此举防止了直接构造出对象
  在类域中声明该类的静态对象。注意：这也是此后该类实例化的唯一一个成员
  防拷贝。这是为了防止通过该类的静态对象拷贝构造出新的对象
  注意：静态变量是在进入main函数前就被创建的
- 代码实现样例
```
class Singleton
{
public:static Singleton* GetInstance(){return &m_instance;}
private:// 构造函数私有Singleton() {};// C++98 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);// or// C++11Singleton(Singleton const&) = delete;Singleton& operator=(Singleton const&) = delete;//这里的m_instance不是Singleton的成员，而是声明静态变量m_instance，并将其限制到类域中static Singleton m_instance;
};
Singleton Singleton::m_instance;
```
- 缺点
  1. 多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序慢
  2. 如果A和B两个饿汉对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证
懒汉模式

懒汉模式是在第一次使用实例对象的时候创建对象
- 概念：如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。
- 思路：在饿汉模式的基础上，将声明的静态对象改为静态对象指针，静态对象指针定义为nullptr，并且在调用时当静态对象指针为nullptr时对其实例化，后续不再实例化
- 代码实现样例
```
//懒汉模式
class InfoMgr
{
public://C++11前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(){cout << "InfoMgr()" << endl;}
private:string _ip = "127.0.0.1";int _port = 80;size_t _buffSize = 1024 * 1024;//...static InfoMgr* _pins;
};InfoMgr* InfoMgr::_pins = nullptr;
```
- 缺点：有线程安全的风险