C++ 内存管理与单例模式剖析

目录

引言

一、堆上唯一对象：HeapOnly类

（一）设计思路

（二）代码实现

（三）使用示例及注意事项

二、栈上唯一对象：StackOnly类

（一）设计思路

（二）代码实现

（三）使用示例及注意事项

三、单例模式：饿汉模式与懒汉模式

（一）单例模式概述

（二）饿汉模式

（三）懒汉模式

（四）单例模式使用示例

总结

---

引言

在C++ 编程中，内存管理和设计模式是非常重要的两个方面。合理的内存管理能确保程序高效、稳定地运行，而设计模式则有助于构建更具可维护性、可扩展性的软件架构。今天，我们将深入探讨C++ 中关于内存管理的一些特殊类设计，以及经典的单例模式。

一、堆上唯一对象：HeapOnly类

（一）设计思路

 HeapOnly  类的设计目的是强制对象只能在堆上创建。这是通过将构造函数设为私有来实现的。外部代码无法直接调用构造函数在栈上创建对象，也不能使用  static  关键字在静态存储区创建对象。

（二）代码实现

class HeapOnly
{
public:static HeapOnly* CreateObj(){return new HeapOnly;}
private:HeapOnly(){//...}HeapOnly(const HeapOnly& hp) = delete;HeapOnly& operator=(const HeapOnly& hp) = delete;
};

这里，唯一能创建  HeapOnly  对象的方式是通过静态成员函数  CreateObj  ，它使用  new  操作符在堆上分配内存并构造对象。同时，将拷贝构造函数和赋值运算符重载函数设为删除状态，防止对象被拷贝，进一步保证对象的唯一性和内存管理的安全性。

（三）使用示例及注意事项

//int main()//{
// //HeapOnly hp1; // 错误，无法在栈上创建
// //static HeapOnly hp2; // 错误，无法在静态存储区创建
// //HeapOnly* hp3 = new HeapOnly; // 错误，构造函数私有
// HeapOnly* hp3 = HeapOnly::CreateObj();
// HeapOnly copy(*hp3); // 错误，拷贝构造函数被删除
// return 0;
//}

在使用时，要严格遵循其设计规则，只能通过  CreateObj  获取对象指针，并且不能进行拷贝操作。

二、栈上唯一对象：StackOnly类

（一）设计思路

 StackOnly  类与  HeapOnly  类相反，它的设计是为了确保对象只能在栈上创建。通过将  operator new  设为删除状态，禁止了使用  new  操作符在堆上创建对象。

（二）代码实现

class StackOnly
{
public:static StackOnly CreateObj(){StackOnly st;return st;}
private:StackOnly(){//...}void* operator new(size_t size) = delete;};

 CreateObj  函数在函数内部的栈空间上创建  StackOnly  对象，并返回该对象的副本。由于  operator new  被删除，无法在堆上创建对象。

（三）使用示例及注意事项

int main()
{//StackOnly hp1; // 错误，构造函数私有//static StackOnly hp2; // 错误，构造函数私有//StackOnly* hp3 = new StackOnly; // 错误，operator new被删除StackOnly hp3 = StackOnly::CreateObj();StackOnly copy(hp3); // 这里如果类没有合适的拷贝构造函数会有问题// new operator new + 构造// StackOnly* hp4 = new StackOnly(hp3); // 错误，operator new被删除return 0;}

使用时要注意只能通过  CreateObj  来获取对象，并且要确保类的拷贝构造函数等符合需求，避免出现意外的错误。

三、单例模式：饿汉模式与懒汉模式

（一）单例模式概述

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。在很多场景下，比如日志记录器、数据库连接池等，只需要一个全局唯一的对象来进行管理和操作，单例模式就能很好地满足这种需求。

（二）饿汉模式

1. 设计思路：饿汉模式在程序启动（ main  函数之前）就创建单例对象。无论后续是否会用到这个单例对象，它都会被提前创建。

2. 代码实现

namespace hungry
{class Singleton{public:static Singleton& GetInstance(){return _sinst;}void func();void Add(const pair<string, string>& kv){_dict[kv.first] = kv.second;}void Print(){for (auto& e : _dict){cout << e.first << ":" << e.second << endl;}cout << endl;}private:Singleton(){// ...}Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;map<string, string> _dict;static Singleton _sinst;};Singleton Singleton::_sinst;void Singleton::func(){_dict["xxx"] = "1111";}}

这里， _sinst  是静态成员变量，在类外进行了定义和初始化。 GetInstance  函数返回这个唯一的单例对象的引用。

3. 优缺点

优点：实现简单，在程序启动时就创建好对象，不存在多线程并发创建对象的问题。

缺点：如果单例对象初始化内容很多，会影响程序的启动速度。并且当有多个互相依赖的单例类时，难以保证初始化顺序。

（三）懒汉模式

1. 设计思路：懒汉模式是在第一次调用获取单例对象的函数时才创建对象。这样可以避免在程序启动时就创建不必要的对象，提高程序的启动效率。

2. 代码实现

namespace lazy
{class Singleton{public:static Singleton& GetInstance(){if (_psinst == nullptr){_psinst = new Singleton;}return *_psinst;}static void DelInstance(){if (_psinst){delete _psinst;_psinst = nullptr;}}void Add(const pair<string, string>& kv){_dict[kv.first] = kv.second;}void Print(){for (auto& e : _dict){cout << e.first << ":" << e.second << endl;}cout << endl;}class GC{public:~GC(){lazy::Singleton::DelInstance();}}private:Singleton(){// ...}~Singleton(){cout << "~Singleton()" << endl;FILE* fin = fopen("map.txt", "w");for (auto& e : _dict){fputs(e.first.c_str(), fin);fputs(":", fin);fputs(e.second.c_str(), fin);fputs("\n", fin);}}Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;map<string, string> _dict;static Singleton* _psinst;static GC _gc;};Singleton* Singleton::_psinst = nullptr;Singleton::GC Singleton::_gc;
}

这里通过  GetInstance  函数中的  if  判断来实现延迟创建对象。同时，定义了一个内部类  GC  ，利用其析构函数在程序结束时释放单例对象，确保资源的正确回收。

3. 优缺点

优点：延迟创建对象，提高启动速度，并且可以在程序运行中根据需要释放单例对象，在一些特殊场景（如中途需要释放资源或程序结束时做持久化操作）下很有用。

缺点：在多线程环境下，如果不进行同步处理，可能会出现多个线程同时创建对象的问题，导致违反单例模式的原则。

（四）单例模式使用示例

int main()
{cout << &lazy::Singleton::GetInstance() << endl;cout << &lazy::Singleton::GetInstance() << endl;cout << &lazy::Singleton::GetInstance() << endl;//Singleton copy(Singleton::GetInstance()); // 错误，拷贝构造函数被删除lazy::Singleton::GetInstance().Add({ "xxx", "111" });lazy::Singleton::GetInstance().Add({ "yyy", "222" });lazy::Singleton::GetInstance().Add({ "zzz", "333" });lazy::Singleton::GetInstance().Add({ "abc", "333" });lazy::Singleton::GetInstance().Print();//lazy::Singleton::DelInstance();lazy::Singleton::GetInstance().Add({ "abc", "444" });lazy::Singleton::GetInstance().Print();//lazy::Singleton::DelInstance();return 0;
}

在  main  函数中，多次调用  GetInstance  获取单例对象，并对其进行操作，验证了单例对象的唯一性和可操作性。

总结

通过对  HeapOnly  类、 StackOnly  类以及单例模式的饿汉模式和懒汉模式的深入剖析，我们了解了C++ 中一些特殊的内存管理方式和经典的设计模式。这些知识在实际编程中非常实用，合理运用它们可以让我们的程序在内存管理上更加合理，架构上更加清晰和稳定。在具体应用时，要根据实际需求和场景选择合适的方案，同时注意避免出现内存泄漏、对象创建错误等问题。