【C++】特殊类的实现

于 2024-04-13 13:36:56 发布
阅读量823 收藏 27
点赞数 9
分类专栏： c++ 文章标签： 单例模式 开发语言 c++ C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzjm/article/details/137713616
版权
本文介绍了C++中几种特殊的类，包括禁止拷贝的CopyBan、仅能在堆上创建的OnlyCreatOnHeap、仅能在栈上创建的OnlyCreatOnStack、不可继承的NonInherit，以及单例模式的两种实现方式——饿汉式和懒汉式，强调了访问控制和线程安全的重要性。
摘要由CSDN通过智能技术生成

目录

【C++】特殊类的实现

不能拷贝的类

只能创建在堆上的类

只能创建在栈上的类

不能被继承的类

单例模式（饿汉）

单例模式（懒汉）

实现原理

1. CopyBan

2. OnlyCreatOnHeap

3. OnlyCreatOnStack

4. NonInherit

5. Singleton

6. singleton

这些类是为了展示C++中不同的编程技巧和设计模式

不能拷贝的类

  1. CopyBan

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

这个类是一个简单的禁止拷贝的类。它通过将拷贝构造函数和拷贝赋值运算符声明为delete来禁止拷贝。

只能创建在堆上的类

  1. OnlyCreatOnHeap

class OnlyCreatOnHeap
{
public:
 static OnlyCreatOnHeap* CreateObeject()
 {
  return new OnlyCreatOnHeap;
 }

 OnlyCreatOnHeap(const OnlyCreatOnHeap& tmp) = delete;
private:
 OnlyCreatOnHeap()
 {}
};

这个类只能在堆上创建。它有一个私有的默认构造函数和一个静态的创建函数CreateObeject，用于在堆上分配并返回这个类的实例。

只能创建在栈上的类

  1. OnlyCreatOnStack

class OnlyCreatOnStack
{
public:
 static OnlyCreatOnStack CreateObj()
 {
  return OnlyCreatOnStack();
 }

 void* operator new(size_t size) = delete;
 void operator delete(void* p) = delete;

private:
 OnlyCreatOnStack()
  :_a(0)
 {}
private:
 int _a;
};

这个类只能在栈上创建。它删除了new和delete运算符，所以不能在堆上分配。此外，它提供了一个静态的创建函数CreateObj，用于在栈上创建并返回这个类的实例。

不能被继承的类

  1. NonInherit

class NonInherit final//私有构造函数或者加final关键字都行
{
public:
 static NonInherit GetInstance()
 {
  return NonInherit();
 }
private:
 NonInherit()
 {}
};

这个类不能被继承。它使用了final关键字来确保没有其他类可以继承它。同时，它的构造函数是私有的，这意味着只有它自己的成员函数和友元函数可以创建它的实例。

单例模式（饿汉）

  1. Singleton

class Singleton//单例模式
{
public:
 static Singleton* GetInstance()
 {
  return &m_instance;
 }
private:
 Singleton()
 {}

 Singleton(const Singleton&) = delete;
 Singleton& operator=(const Singleton&) = delete;
 static Singleton m_instance;
};

Singleton Singleton::m_instance;//在程序入口之前就完成初始化

这是一个简单的单例模式的实现。它有一个私有的静态成员m_instance，并通过一个静态的GetInstance函数返回这个实例的地址。由于构造函数和拷贝构造函数都被删除，所以无法创建这个类的多个实例。

单例模式（懒汉）

  1. singleton

class singleton
{
public:
 static singleton* GetInstance()
 {
  if (pm_instance == nullptr)
  {
   m_mtx.lock();
   if (pm_instance == nullptr)
   {
    pm_instance = new singleton();
   }
   m_mtx.unlock();
  }
  return pm_instance;
 }

 class CGarbo {
 public:
  ~CGarbo()
  {
   if (pm_instance != nullptr)
   {
    delete singleton::pm_instance;
   }
  }
 };
 static CGarbo garbor;


 static singleton* pm_instance;
private:
 static mutex m_mtx;
 
 singleton(){}

 singleton& operator=(const singleton&) = delete;
 singleton(const singleton&) = delete;

};

singleton* singleton::pm_instance = nullptr;
singleton::CGarbo garbor;
mutex singleton::m_mtx;

这是另一个单例模式的实现，但它考虑了线程安全。它使用了互斥锁m_mtx来确保在多线程环境下只创建一个实例。同时，它使用了一个内部类CGarbo作为局部静态对象，当程序结束时，这个对象会被销毁，从而释放单例对象。

测试代码：

#include "your_header_file.h"  // 替换为你的头文件路径

int main() {
    // CopyBan
    CopyBan a;
    // CopyBan b = a;  // 错误：拷贝构造函数被删除
    // a = b;  // 错误：拷贝赋值运算符被删除

    // OnlyCreatOnHeap
    OnlyCreatOnHeap* heapObj = OnlyCreatOnHeap::CreateObeject();
    // OnlyCreatOnHeap stackObj;  // 错误：默认构造函数不可访问

    // OnlyCreatOnStack
    OnlyCreatOnStack stackObj = OnlyCreatOnStack::CreateObj();
    // OnlyCreatOnStack* heapObj2 = new OnlyCreatOnStack;  // 错误：new运算符被删除

    // NonInherit
    NonInherit nonInheritObj = NonInherit::GetInstance();
    // class Derived : public NonInherit {};  // 错误：NonInherit是final的

    // Singleton
    Singleton* singletonObj = Singleton::GetInstance();
    // Singleton anotherSingleton;  // 错误：默认构造函数不可访问

    // singleton
    singleton* singletonPtr = singleton::GetInstance();
    // 删除singleton::pm_instance;  // 错误：pm_instance是私有的

    return 0;
}

这个测试代码只是为了展示如何创建和使用这些类，以及当尝试进行不允许的操作时会发生什么错误。在实际项目中，你应该根据需求来选择合适的类和设计模式。

实现原理

当然可以，我会为你详细解释这些类的实现原理。

1. CopyBan

实现原理：

  • CopyBan(const CopyBan& copy) = delete;：删除了拷贝构造函数，使得无法通过拷贝来创建新的CopyBan对象。

  • CopyBan& operator=(const CopyBan& copy) = delete;：删除了拷贝赋值运算符，使得无法通过赋值来复制CopyBan对象的状态。

2. OnlyCreatOnHeap

实现原理：

  • OnlyCreatOnHeap()：私有默认构造函数，确保外部代码无法直接调用它。

  • static OnlyCreatOnHeap* CreateObeject()：静态成员函数，用于在堆上创建OnlyCreatOnHeap的实例，并返回指向它的指针。

由于默认构造函数是私有的，外部代码不能直接创建OnlyCreatOnHeap的实例。只能通过CreateObeject函数在堆上创建对象，这确保了该类对象只能在堆上分配。

3. OnlyCreatOnStack

实现原理：

  • void* operator new(size_t size) = delete;：删除了new运算符，使得无法在堆上分配OnlyCreatOnStack对象。

  • void operator delete(void* p) = delete;：虽然这行代码在这里没有实际作用（因为new已经被删除），但它通常用于删除自定义的delete运算符。

  • OnlyCreatOnStack()：私有默认构造函数。

  • static OnlyCreatOnStack CreateObj()：静态成员函数，用于在栈上创建并返回OnlyCreatOnStack的实例。

由于new运算符被删除，OnlyCreatOnStack对象无法在堆上分配。只能通过CreateObj函数在栈上创建对象。

4. NonInherit

实现原理：

  • final关键字：确保NonInherit类不能被其他类继承。

  • NonInherit()：私有默认构造函数。

final关键字是C++11引入的，用于禁止类的继承。由于构造函数是私有的，只有NonInherit的成员函数和友元函数能够创建它的实例。

5. Singleton

实现原理：

  • Singleton()：私有默认构造函数，确保外部代码无法直接创建Singleton的实例。

  • static Singleton* GetInstance()：静态成员函数，返回指向Singleton唯一实例的指针。

  • static Singleton m_instance;：静态成员变量，用于存储Singleton的唯一实例。这个实例在程序开始时就被创建，因为静态成员变量的初始化发生在程序的主入口点（如main函数）之前。

由于构造函数是私有的，外部代码无法创建Singleton的实例。只能通过GetInstance函数获取唯一实例的指针。

6. singleton

实现原理：

  • singleton()：私有默认构造函数，确保外部代码无法直接创建singleton的实例。

  • static singleton* GetInstance()：静态成员函数，返回指向singleton唯一实例的指针。如果实例尚未创建，则在此函数中创建它。

  • static singleton* pm_instance;：静态成员指针，用于存储指向singleton唯一实例的指针。

  • static mutex m_mtx;：静态互斥锁，用于在多线程环境下保护pm_instance的访问，确保只创建一个实例。

  • class CGarbo：内部类，用于在程序结束时自动删除singleton的唯一实例。其析构函数会在程序结束时被调用，从而释放资源。

  • static CGarbo garbor;：静态内部类对象，确保在程序结束时释放singleton的唯一实例。

这个版本的单例模式考虑了线程安全。当多个线程同时调用GetInstance函数时，互斥锁m_mtx确保只有一个线程能够进入创建实例的代码块。同时，CGarbo类确保了单例对象在程序结束时能够被正确释放。

这些类的实现原理主要依赖于C++的访问控制（如私有构造函数）、静态成员和运算符重载等特性，以及多线程编程中的互斥锁机制。

正追军梦
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值