17370845950

C++中可通过智能指针模拟自动内存管理，std::shared_ptr基于引用计数实现对象生命周期管理，避免内存泄漏；循环引用问题可用std::weak_ptr解决；自定义SimplePtr可演示原理，但实际推荐使用标准库智能指针。

在C++中，虽然没有像Java或C#那样的自动垃圾回收机制（GC），但我们可以通过智能指针和引用计数的方式模拟一个简单的自动内存管理机制。这种方式能有效避免内存泄漏，提升代码的安全性和可维护性。

智能指_ptr与引用计数的基本原理

引用计数是一种常见的资源管理技术：每当有一个对象指针指向某块内存时，该内存的引用计数加1；当指针被销毁或指向其他对象时，引用计数减1；当引用计数变为0时，说明没有指针再使用这块内存，可以安全释放。

C++标准库中的 std::shared_ptr 就是基于引用计数实现的智能指针。它自动管理动态分配的对象生命周期，无需手动调用 delete。

示例代码：

#include 
#include 

struct MyClass {
    MyClass() { std::cout << "MyClass 构造\n"; }
    ~MyClass() { std::cout << "MyClass 析构\n"; }
};

int main() {
    {
        std::shared_ptr ptr1 = std::make_shared();
        {
            std::shared_ptr ptr2 = ptr1; // 引用计数 +1
            std::cout << "当前引用计数: " << ptr1.use_count() << "\n"; // 输出 2
        } // ptr2 离开作用域，引用计数 -1
        std::cout << "ptr2 销毁后引用计数: " << ptr1.use_count() << "\n"; // 输出 1
    } // ptr1 销毁，引用计数为0，自动析构对象
    return 0;
}

如何避免循环引用问题

引用计数最大的问题是循环引用：两个或多个对象互相持有 shared_ptr，导致引用计数永远不为0，内存无法释放。

解决方法是使用 std::weak_ptr，它是一个弱引用指针，不会增加引用计数，仅用于临时访问 shared_ptr 管理的对象。

示例：用 weak_ptr 打破循环

#include 

struct Node {
    std::shared_ptr parent;
    std::weak_ptr child; // 使用 weak_ptr 避免循环

    ~Node() { std::cout << "Node 被销毁\n"; }
};

int main() {
    auto node1 = std::make_shared();
    auto node2 = std::make_shared();

    node1->child = node2;
    node2->parent = node1; // parent 是 shared_ptr，但 child 是 weak_ptr

    // 当 main 结束时，两个节点都能正确释放
    return 0;
}

自定义简单GC思路（教学用途）

如果你想从零实现一个极简的引用计数GC，可以封装一个带计数器的结构体，手动管理增减计数。

以下是一个简化版示例：

template
class SimplePtr {
private:
    T* ptr;
    int* count;

public:
    explicit SimplePtr(T* p) : ptr(p), count(new int(1)) {}

    SimplePtr(const SimplePtr& other) : ptr(other.ptr), count(other.count) {
        (*count)++;
    }

    SimplePtr& operator=(const SimplePtr& other) {
        if (this != &other) {
            release();
            ptr = other.ptr;
            count = other.count;
            (*count)++;
        }
        return *this;
    }

    void release() {
        (*count)--;
        if (*count == 0) {
            delete ptr;
            delete count;
        }
    }

    ~SimplePtr() { release(); }

    T& operator*() { return *ptr; }
    T* operator->() { return ptr; }
};

这个简易指针展示了引用计数的核心逻辑：构造、拷贝、赋值、析构时正确操作计数器。

基本上就这些。实际开发中推荐直接使用 std::shared_ptr 和 std::weak_ptr，它们经过充分测试且线程安全。自己实现GC容易出错，除非有特殊需求，否则没必要重复造轮子。理解其原理更重要。