【C++】特殊类的实现

最新推荐文章于 2024-09-21 12:14:27 发布

正追军梦

最新推荐文章于 2024-09-21 12:14:27 发布

阅读量808

点赞数 9

分类专栏： c++ 文章标签：单例模式开发语言 c++ C++

本文链接：https://blog.csdn.net/ZHENGZJM/article/details/137713616

版权

c++ 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文介绍了C++中几种特殊的类，包括禁止拷贝的CopyBan、仅能在堆上创建的OnlyCreatOnHeap、仅能在栈上创建的OnlyCreatOnStack、不可继承的NonInherit，以及单例模式的两种实现方式——饿汉式和懒汉式，强调了访问控制和线程安全的重要性。

摘要由CSDN通过智能技术生成

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

不能拷贝的类

CopyBan

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

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

只能创建在堆上的类

OnlyCreatOnHeap

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

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

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

只能创建在栈上的类

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，用于在栈上创建并返回这个类的实例。

不能被继承的类

NonInherit

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

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

单例模式（饿汉）

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函数返回这个实例的地址。由于构造函数和拷贝构造函数都被删除，所以无法创建这个类的多个实例。

单例模式（懒汉）

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的唯一实例。