C++怎么处理资源管理 C++资源管理的智能指针应用

c++处理资源管理的核心是raii思想，通过智能指针实现自动内存管理。1. unique_ptr用于独占所有权，确保单一所有者销毁时释放资源；2. shared_ptr用于共享所有权，通过引用计数自动释放资源；3. weak_ptr作为观察者避免循环引用问题。智能指针相比原始指针更安全、简洁，还可通过自定义删除器管理其他资源如文件句柄。选择智能指针应根据所有权需求：仅需一个所有者用unique_ptr，多个所有者用shared_ptr，解决循环引用则用weak_ptr。

C++处理资源管理的核心在于RAII (Resource Acquisition Is Initialization) 思想，也就是在对象构造时获取资源，对象析构时释放资源。智能指针是RAII的一种具体实现，能够自动管理动态分配的内存，避免内存泄漏。

解决方案

C++通过智能指针来优雅地管理资源，特别是动态分配的内存。主要有三种智能指针：

unique_ptr

shared_ptr

weak_ptr

• unique_ptr

  : 独占所有权的智能指针。一个

  unique_ptr

  同一时间只能指向一个对象。当

  unique_ptr

  销毁时，它所指向的对象也会被自动删除。适用于明确只有一个所有者的情况。

  立即学习“C++免费学习笔记（深入）”；

  

  #include 
  #include 
  
  class MyClass {
  public:
      MyClass() { std::cout << "MyClass created\n"; }
      ~MyClass() { std::cout << "MyClass destroyed\n"; }
      void doSomething() { std::cout << "Doing something...\n"; }
  };
  
  int main() {
      std::unique_ptr ptr(new MyClass()); // 使用new初始化，C++14后推荐使用make_unique
      ptr->doSomething();
  
      // std::unique_ptr ptr2 = ptr; // 错误：unique_ptr 不支持复制
      std::unique_ptr ptr2 = std::move(ptr); // 正确：使用 std::move 转移所有权
      if (ptr2) {
          ptr2->doSomething();
      }
  
      if (ptr) { // 此时 ptr 为空
          ptr->doSomething();
      }
  
      return 0; // ptr2 销毁时，MyClass 对象被删除
  }

• shared_ptr

  : 共享所有权的智能指针。多个

  shared_ptr

  可以指向同一个对象，内部维护一个引用计数。当最后一个指向该对象的

  shared_ptr

  销毁时，对象才会被删除。适用于多个对象需要共享资源的情况。

  #include 
  #include 
  
  class MyClass {
  public:
      MyClass() { std::cout << "MyClass created\n"; }
      ~MyClass() { std::cout << "MyClass destroyed\n"; }
      void doSomething() { std::cout << "Doing something...\n"; }
  };
  
  int main() {
      std::shared_ptr ptr1 = std::make_shared();
      std::shared_ptr ptr2 = ptr1; // 共享所有权
  
      ptr1->doSomething();
      ptr2->doSomething();
  
      std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 输出引用计数
  
      return 0; // ptr1 和 ptr2 销毁时，引用计数减为 0，MyClass 对象被删除
  }

• weak_ptr

  :

  shared_ptr

  的观察者，不增加引用计数。用于解决

  shared_ptr

  可能产生的循环引用问题。可以通过

  weak_ptr

  来判断对象是否还存活。
  

  考拉新媒体导航

  考拉新媒体导航——新媒体人的专属门户网站

  下载

  #include 
  #include 
  
  class MyClass; // 前向声明
  
  class ClassA {
  public:
      std::shared_ptr myClassPtr;
      ~ClassA() { std::cout << "ClassA destroyed\n"; }
  };
  
  class MyClass {
  public:
      std::weak_ptr classAPtr; // 使用 weak_ptr 避免循环引用
      ~MyClass() { std::cout << "MyClass destroyed\n"; }
  };
  
  int main() {
      std::shared_ptr a = std::make_shared();
      std::shared_ptr b = std::make_shared();
  
      a->myClassPtr = b;
      b->classAPtr = a; // weak_ptr 不会增加引用计数
  
      return 0; // 没有循环引用，对象可以正常释放
  }

如何选择合适的智能指针？

选择哪种智能指针取决于你的需求。

unique_ptr

shared_ptr

weak_ptr

unique_ptr

shared_ptr

weak_ptr

shared_ptr

智能指针相比原始指针的优势是什么？

智能指针最大的优势在于自动管理内存，避免手动

new

delete

除了内存，智能指针还可以管理其他资源吗？

虽然智能指针主要用于管理动态分配的内存，但实际上，它们也可以用来管理其他类型的资源，例如文件句柄、网络连接、互斥锁等。关键在于自定义删除器（custom deleter）。通过自定义删除器，可以在智能指针销毁时执行特定的清理操作，从而释放相应的资源。例如：

#include 
#include 
#include 

class FileDeleter {
public:
    void operator()(std::ofstream* file) const {
        if (file) {
            file->close();
            std::cout << "File closed\n";
            delete file;
        }
    }
};

int main() {
    std::unique_ptr filePtr(new std::ofstream("example.txt"), FileDeleter());

    if (filePtr->is_open()) {
        *filePtr << "Hello, world!\n";
    }

    return 0; // 文件会在 filePtr 销毁时自动关闭
}

在这个例子中，

FileDeleter

FileDeleter

unique_ptr

unique_ptr

如何避免智能指针的循环引用问题？

循环引用是指两个或多个对象互相持有对方的

shared_ptr

weak_ptr

weak_ptr

weak_ptr

shared_ptr

#include 
#include 

class ClassA; // 前向声明

class ClassB {
public:
    std::weak_ptr aPtr;
    ~ClassB() { std::cout << "ClassB destroyed\n"; }
};

class ClassA {
public:
    std::shared_ptr bPtr;
    ~ClassA() { std::cout << "ClassA destroyed\n"; }
};

int main() {
    std::shared_ptr a = std::make_shared();
    std::shared_ptr b = std::make_shared();

    a->bPtr = b;
    b->aPtr = a; // 使用 weak_ptr 避免循环引用

    if (auto sharedAPtr = b->aPtr.lock()) { // 尝试将 weak_ptr 转换为 shared_ptr
        std::cout << "ClassA is still alive\n";
    } else {
        std::cout << "ClassA has been destroyed\n";
    }

    return 0; // 没有循环引用，对象可以正常释放
}