C++中内存管理的黄金法则是什么？资源释放责任界定

#include <memory>

int main() {
  // 使用 unique_ptr，独占所有权
  std::unique_ptr<int> uniquePtr(new int(10));
  // 当 uniquePtr 离开作用域时，会自动释放 int(10) 的内存

  // 使用 shared_ptr，共享所有权
  std::shared_ptr<int> sharedPtr1(new int(20));
  std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 共享所有权
  // 当 sharedPtr1 和 sharedPtr2 都离开作用域时，int(20) 的内存才会被释放

  return 0;
}

void processData() {
  int* data = new int[100];
  try {
    // ... 一些可能抛出异常的操作
    if (/* 发生错误 */) {
      throw std::runtime_error("处理数据时出错");
    }
    // ...
    delete[] data; // 如果 try 块中抛出异常，这行代码不会执行
  } catch (const std::exception& e) {
    // 处理异常，但忘记释放 data 指向的内存
    // 内存泄漏！
    std::cerr << "发生异常: " << e.what() << std::endl;
    //throw; // 重新抛出异常（可选）
  }
}

#include <memory>

void processData() {
  std::unique_ptr<int[]> data(new int[100]); // 使用 unique_ptr 管理内存
  try {
    // ... 一些可能抛出异常的操作
    if (/* 发生错误 */) {
      throw std::runtime_error("处理数据时出错");
    }
    // ...
  } catch (const std::exception& e) {
    // 处理异常
    std::cerr << "发生异常: " << e.what() << std::endl;
    //throw; // 重新抛出异常（可选）
  }
  // data 在离开作用域时会自动释放，即使抛出异常
}

#include <iostream>
#include <memory>
#include <vector>

class Child; // 前向声明

class Parent {
public:
  std::vector<std::shared_ptr<Child>> children;

  ~Parent() { std::cout << "Parent 析构" << std::endl; }
};

class Child {
public:
  std::shared_ptr<Parent> parent; // 使用 shared_ptr 会导致循环引用

  ~Child() { std::cout << "Child 析构" << std::endl; }
};

int main() {
  std::shared_ptr<Parent> parent = std::make_shared<Parent>();
  std::shared_ptr<Child> child = std::make_shared<Child>();

  parent->children.push_back(child);
  child->parent = parent; // 循环引用

  // parent 和 child 离开作用域，但不会被析构，因为存在循环引用
  return 0;
}

#include <iostream>
#include <memory>
#include <vector>

class Child; // 前向声明

class Parent {
public:
  std::vector<std::shared_ptr<Child>> children;

  ~Parent() { std::cout << "Parent 析构" << std::endl; }
};

class Child {
public:
  std::weak_ptr<Parent> parent; // 使用 weak_ptr 避免循环引用

  ~Child() { std::cout << "Child 析构" << std::endl; }
};

int main() {
  std::shared_ptr<Parent> parent = std::make_shared<Parent>();
  std::shared_ptr<Child> child = std::make_shared<Child>();

  parent->children.push_back(child);
  child->parent = parent; // 不再是循环引用

  // parent 和 child 离开作用域，会被正确析构
  return 0;
}