C++析构函数调用 资源释放时机分析

析构函数在对象生命周期结束时自动释放资源，调用时机取决于存储类型：局部对象在离开作用域时调用，全局或静态对象在程序结束时调用，动态对象需显式调用delete触发；成员对象析构顺序与其声明顺序相反，基类析构函数最后调用；析构函数中抛出异常可能导致程序终止，应避免；智能指针如unique_ptr和shared_ptr通过RAII机制自动管理内存，避免手动delete和内存泄漏。

C++析构函数主要负责在对象生命周期结束时释放其占用的资源，包括内存、文件句柄、网络连接等等。它确保程序不会因为资源泄漏而崩溃或变得不稳定。理解析构函数的调用时机至关重要，能帮助你编写更健壮、更可靠的C++代码。

析构函数在对象不再需要时自动调用，但具体时机取决于对象的存储类型和作用域。

析构函数调用时机分析

析构函数的调用时机主要取决于对象的生命周期，而对象的生命周期又取决于它的存储类型（例如，自动存储、静态存储、动态存储）。

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

• 自动存储对象（局部变量）： 析构函数在对象离开其作用域时调用。这意味着当函数或代码块执行完毕，局部变量的析构函数会被自动调用，释放其占用的资源。

  #include <iostream>
  
  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called\n"; }
      ~MyClass() { std::cout << "Destructor called\n"; }
  };
  
  void myFunction() {
      MyClass obj; // obj 在 myFunction 作用域内
      std::cout << "Inside myFunction\n";
  } // obj 的析构函数在这里被调用
  
  int main() {
      myFunction();
      std::cout << "Back in main\n";
      return 0;
  }

  登录后复制

  输出：

  Constructor called
  Inside myFunction
  Destructor called
  Back in main

  登录后复制

• 静态存储对象（全局变量、静态变量）： 析构函数在程序结束时调用。全局变量和静态变量在程序启动时创建，在程序结束时销毁。

  #include <iostream>
  
  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called\n"; }
      ~MyClass() { std::cout << "Destructor called\n"; }
  };
  
  MyClass globalObj; // 全局对象
  
  int main() {
      std::cout << "Inside main\n";
      return 0;
  } // globalObj 的析构函数在这里被调用

  登录后复制

  输出：

  Constructor called
  Inside main
  Destructor called

  登录后复制

• 动态存储对象（

  new

  登录后复制
  创建的对象）： 析构函数需要显式调用

  delete

  登录后复制
  运算符来触发。如果你使用

  new

  登录后复制
  创建对象，但忘记使用

  delete

  登录后复制
  释放内存，就会发生内存泄漏。

  #include <iostream>
  
  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called\n"; }
      ~MyClass() { std::cout << "Destructor called\n"; }
  };
  
  int main() {
      MyClass* obj = new MyClass(); // 使用 new 创建对象
      std::cout << "Object created on heap\n";
      delete obj; // 显式调用 delete 触发析构函数
      std::cout << "After delete\n";
      return 0;
  }

  登录后复制

  输出：

  Constructor called
  Object created on heap
  Destructor called
  After delete

  登录后复制

  如果省略

  delete obj;

  登录后复制
  ，则会发生内存泄漏，析构函数不会被调用。

• 对象作为类的成员： 当包含对象的类实例被销毁时，成员对象的析构函数会被调用。析构函数的调用顺序与成员对象的声明顺序相反。

  #include <iostream>
  
  class Member {
  public:
      Member(int id) : id_(id) { std::cout << "Member " << id_ << " Constructor called\n"; }
      ~Member() { std::cout << "Member " << id_ << " Destructor called\n"; }
  private:
      int id_;
  };
  
  class Container {
  public:
      Container() : member1(1), member2(2) { std::cout << "Container Constructor called\n"; }
      ~Container() { std::cout << "Container Destructor called\n"; }
  private:
      Member member1;
      Member member2;
  };
  
  int main() {
      Container container;
      std::cout << "Container created\n";
      return 0;
  }

  登录后复制

  输出：

  Member 1 Constructor called
  Member 2 Constructor called
  Container Constructor called
  Container created
  Container Destructor called
  Member 2 Destructor called
  Member 1 Destructor called

  登录后复制

析构函数抛出异常的潜在风险是什么？

在析构函数中抛出异常通常被认为是不良实践，因为它可能导致程序崩溃或未定义行为。这是因为：

• 异常处理机制： 当异常被抛出时，C++运行时系统会搜索能够处理该异常的

  catch

  登录后复制
  块。如果在析构函数中抛出异常，并且没有在析构函数内部捕获它，异常会传播到调用析构函数的地方。

• 栈展开： 异常传播的过程中，会发生栈展开（stack unwinding），这意味着运行时系统会按照相反的顺序调用已构造对象的析构函数。如果在栈展开过程中，某个析构函数又抛出了异常，并且没有被捕获，

  std::terminate

  登录后复制
  函数会被调用，程序会立即终止。这被称为“双重异常（double exception）”问题。

• 资源泄漏： 在栈展开过程中，如果某个对象的析构函数抛出异常，后续对象的析构函数可能不会被调用，导致资源泄漏。

如何避免析构函数抛出异常？

Android开发笔记 模拟器、应用教程pdf版

Android开发笔记，内容涉及模拟器参数、进程与线程、Android 释放手机资源，进程释放优先级、分析HelloAndroid、添加编辑框与按钮、使用Intent启动另一个Activity、在不同Task中启动Activity、Intent与Intent filters、添加新的Activity等相关知识。

10

查看详情

避免析构函数抛出异常的最佳方法是确保析构函数中的操作不会引发异常。这通常意味着：

1. 资源释放操作： 确保资源释放操作（例如，释放内存、关闭文件句柄）是安全的，不会抛出异常。可以使用

   try-catch

   登录后复制
   块来捕获和处理可能发生的异常。

2. 异常安全编程： 遵循异常安全编程原则，确保在异常发生时，程序的状态保持一致，没有资源泄漏。

3. 避免复杂逻辑： 尽量避免在析构函数中执行复杂的逻辑，将复杂的清理操作放在其他地方进行。

智能指针如何简化资源管理，避免手动

delete

智能指针是 C++ 中用于自动管理动态分配内存的类模板。它们通过在对象不再使用时自动释放内存，从而避免了手动调用

delete

C++ 提供了几种类型的智能指针：

• std::unique_ptr

  登录后复制
  ：独占所有权，确保只有一个智能指针指向给定的对象。当

  unique_ptr

  登录后复制
  被销毁时，它所指向的对象也会被销毁。

  #include <iostream>
  #include <memory>
  
  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called\n"; }
      ~MyClass() { std::cout << "Destructor called\n"; }
  };
  
  int main() {
      std::unique_ptr<MyClass> ptr(new MyClass()); // 使用 unique_ptr 管理内存
      std::cout << "Object created using unique_ptr\n";
      // ptr 在离开作用域时，会自动调用 delete 释放内存
      return 0;
  }

  登录后复制

  输出：

  Constructor called
  Object created using unique_ptr
  Destructor called

  登录后复制

• std::shared_ptr

  登录后复制
  ：共享所有权，允许多个智能指针指向同一个对象。只有当最后一个

  shared_ptr

  登录后复制
  被销毁时，对象才会被销毁。

  #include <iostream>
  #include <memory>
  
  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called\n"; }
      ~MyClass() { std::cout << "Destructor called\n"; }
  };
  
  int main() {
      std::shared_ptr<MyClass> ptr1(new MyClass());
      std::shared_ptr<MyClass> ptr2 = ptr1; // 多个 shared_ptr 指向同一个对象
      std::cout << "Object created using shared_ptr\n";
      return 0; // 当 ptr1 和 ptr2 都离开作用域时，对象才会被销毁
  }

  登录后复制

  输出：

  Constructor called
  Object created using shared_ptr
  Destructor called

  登录后复制

• std::weak_ptr

  登录后复制
  ：弱引用，不增加对象的引用计数。

  weak_ptr

  登录后复制
  可以用来检测对象是否仍然存在，避免悬挂指针。

智能指针通过 RAII (Resource Acquisition Is Initialization) 原则，将资源的获取和释放与对象的生命周期绑定在一起，从而简化了资源管理，减少了内存泄漏和悬挂指针的风险。

如何处理类中包含其他类对象的情况，析构函数调用顺序是怎样的？

当一个类包含其他类的对象作为成员时，析构函数的调用顺序非常重要，以确保资源被正确释放。C++ 保证析构函数按照与构造函数相反的顺序调用。

1. 成员对象的析构函数： 首先，成员对象的析构函数按照它们在类定义中声明的顺序的相反顺序被调用。这意味着最后一个声明的成员对象的析构函数首先被调用，然后是倒数第二个，依此类推。

2. 基类的析构函数： 如果类是从其他类继承的，基类的析构函数在成员对象的析构函数之后被调用。如果存在多层继承，析构函数按照继承层次结构的相反顺序被调用。

3. 类的析构函数体： 最后，类的析构函数体中的代码被执行。

理解析构函数的调用顺序对于正确管理资源至关重要。例如，如果一个类包含一个文件句柄和一个动态分配的内存块，应该首先释放内存块，然后关闭文件句柄，以避免潜在的问题。

以上就是C++析构函数调用 资源释放时机分析的详细内容，更多请关注php中文网其它相关文章！