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++ 中一些特殊的内存管理方式和经典的设计模式。这些知识在实际编程中非常实用，合理运用它们可以让我们的程序在内存管理上更加合理，架构上更加清晰和稳定。在具体应用时，要根据实际需求和场景选择合适的方案，同时注意避免出现内存泄漏、对象创建错误等问题。