C++中的`std::terminate`调用机制：何时发生二次异常与程序终止处理

C++ std::terminate 调用机制：二次异常与程序终止处理

大家好，今天我们来深入探讨C++中std::terminate的调用机制，以及它在处理异常，尤其是二次异常时的作用。理解std::terminate的行为对于编写健壮的C++程序至关重要，因为它可以帮助我们更好地理解程序在遇到无法恢复的错误时会发生什么。

1. std::terminate 的基本概念

std::terminate 是C++标准库提供的一个函数，定义在 <exception> 头文件中。它的作用非常简单：它终止程序的执行。更具体地说，它会调用当前已安装的终止处理函数（termination handler）。

默认情况下，这个终止处理函数是 std::abort，它会发出 SIGABRT 信号，通常导致程序产生一个核心转储（core dump）。然而，我们可以使用 std::set_terminate 来自定义这个终止处理函数。

代码示例：默认行为

#include <iostream>
#include <exception>

void my_terminate() {
  std::cerr << "Custom terminate handler called!n";
  std::abort(); // 仍然调用 abort
}

int main() {
  std::set_terminate(my_terminate);

  try {
    throw std::runtime_error("An error occurred!");
  } catch (...) {
    std::cerr << "Exception caught, but cannot handle it.n";
    std::terminate(); // 调用 terminate
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

在这个例子中，尽管我们捕获了异常，但我们选择不处理它，而是调用 std::terminate。程序会调用我们自定义的 my_terminate 函数，该函数会输出一条错误消息，然后调用 std::abort，最终导致程序终止。

2. 何时调用 std::terminate

std::terminate 主要在以下几种情况下被调用：

• 异常处理机制无法找到匹配的 catch 块： 当一个异常被抛出，但没有合适的 catch 块来处理它时，C++运行时环境会调用 std::terminate。
• 在异常处理过程中抛出异常（二次异常）： 这是我们今天要重点讨论的情况。如果在异常处理过程中（即在 catch 块或异常规范中）又抛出了一个异常，并且这个异常没有被立即捕获，那么 C++运行时环境也会调用 std::terminate。
• 析构函数抛出异常： 析构函数不应该抛出异常。如果析构函数抛出了异常，并且这个异常逃离了析构函数，C++运行时环境会调用 std::terminate。
• noexcept 函数抛出异常： 如果一个声明为 noexcept 的函数抛出了异常，C++运行时环境会调用 std::terminate。
• 栈展开过程中抛出异常： 在栈展开（stack unwinding）的过程中，如果抛出异常，程序调用std::terminate。

3. 二次异常的产生与处理

二次异常是指在异常处理过程中抛出的另一个异常。这通常发生在 catch 块或异常规范中。C++标准的设计原则是，在异常处理过程中如果再次抛出异常，程序的行为将变得不可预测，因此会直接调用 std::terminate 来终止程序。

代码示例：catch 块中的二次异常

#include <iostream>
#include <exception>

int main() {
  try {
    throw std::runtime_error("Initial exception!");
  } catch (const std::exception& e) {
    std::cerr << "Caught exception: " << e.what() << std::endl;
    try {
      throw std::logic_error("Secondary exception!"); // 在 catch 块中抛出异常
    } catch (const std::exception& e2) {
      std::cerr << "Caught secondary exception: " << e2.what() << std::endl;
    }
  } catch (...) {
    std::cerr << "Caught some other exception.n";
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

在这个例子中，我们首先抛出一个 std::runtime_error 异常。在处理这个异常的 catch 块中，我们又抛出了一个 std::logic_error 异常。虽然我们在 catch 块中嵌套了另一个 try-catch 块来尝试捕获这个二次异常，但是程序仍然会调用 std::terminate。原因在于，在第一次异常的栈展开过程中，如果在 catch 块内又抛出异常，并且没有立即在同一个catch块内捕获（注意，这里是同一个catch块内，而不是像上面代码那样用另一个try-catch块包裹），那么就会导致std::terminate被调用。 修改后的代码如下：

#include <iostream>
#include <exception>

int main() {
  try {
    throw std::runtime_error("Initial exception!");
  } catch (const std::exception& e) {
    std::cerr << "Caught exception: " << e.what() << std::endl;
    try {
      throw std::logic_error("Secondary exception!"); // 在 catch 块中抛出异常
    } catch (const std::exception& e2) {
      std::cerr << "Caught secondary exception: " << e2.what() << std::endl;
    }
  } catch (...) {
    std::cerr << "Caught some other exception.n";
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

关键点：

• 二次异常是指在异常处理过程中抛出的异常。
• 默认情况下，C++运行时环境会调用 std::terminate 来处理二次异常。
• 即使在 catch 块中嵌套了 try-catch 块，如果二次异常没有在第一次异常栈展开的过程中立即被捕获，仍然会导致 std::terminate 被调用. （注意这里是立即捕获的意思）

代码示例：异常规范中的二次异常

#include <iostream>
#include <exception>

void throwing_function() noexcept(false) {
  throw std::runtime_error("Exception from throwing_function!");
}

int main() {
  try {
    throwing_function();
  } catch (...) {
    std::cerr << "Caught exception.n";
    //  这里再抛出异常，会导致terminate
  }
  return 0;
}

在这个例子中，throwing_function 可能会抛出异常。如果在 main 函数的 catch 块中再次抛出异常，将会导致std::terminate的调用。

4. noexcept 与 std::terminate

noexcept 是C++11引入的一个异常规范，用于声明函数不会抛出异常。如果一个声明为 noexcept 的函数抛出了异常，C++运行时环境会立即调用 std::terminate。

代码示例：noexcept 函数抛出异常

#include <iostream>
#include <exception>

void no_throw() noexcept {
  std::cout << "Entering no_throw function.n";
  throw std::runtime_error("Exception from no_throw function!"); // 违反 noexcept 规范
  std::cout << "Leaving no_throw function.n"; // 不会被执行
}

int main() {
  try {
    no_throw();
  } catch (...) {
    std::cerr << "Caught exception.n"; // 不会被执行
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

在这个例子中，no_throw 函数被声明为 noexcept，但它实际上抛出了一个 std::runtime_error 异常。由于违反了 noexcept 规范，C++运行时环境会立即调用 std::terminate，程序不会执行 catch 块中的代码，也不会输出 "Caught exception."。

noexcept 的重要性：

• noexcept 可以帮助编译器进行优化，因为它表明函数不会抛出异常。
• noexcept 可以提高程序的可靠性，因为它可以防止异常在不应该抛出异常的地方传播。
• noexcept 可以使代码更易于理解和维护，因为它明确地表明了哪些函数可能会抛出异常，哪些函数不会。

5. 自定义终止处理函数

我们可以使用 std::set_terminate 函数来自定义终止处理函数。这允许我们在程序终止之前执行一些清理工作，或者记录错误信息。

代码示例：自定义终止处理函数

#include <iostream>
#include <exception>
#include <cstdlib> // For std::abort

void my_terminate() {
  std::cerr << "Custom terminate handler called!n";
  // 在终止之前执行一些清理工作
  // 例如：关闭文件、释放资源等
  std::cerr << "Performing cleanup...n";
  std::abort(); // 仍然调用 abort，或者可以调用 exit
}

int main() {
  std::set_terminate(my_terminate);

  try {
    throw std::runtime_error("An error occurred!");
  } catch (...) {
    std::cerr << "Exception caught, but cannot handle it.n";
    std::terminate(); // 调用 terminate，然后调用 my_terminate
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

在这个例子中，我们自定义了一个名为 my_terminate 的终止处理函数。当我们调用 std::terminate 时，C++运行时环境会调用 my_terminate 函数，该函数会输出一些调试信息，然后调用 std::abort 来终止程序。

注意事项：

• 终止处理函数不应该抛出异常。如果终止处理函数抛出了异常，C++运行时环境会调用 std::abort 来强制终止程序。
• 终止处理函数应该尽快完成，因为它是在程序即将终止之前执行的。
• 终止处理函数应该尽量避免依赖于全局状态，因为在程序终止时，全局状态可能已经损坏。

6. 二次异常与析构函数

析构函数的设计目标是在对象生命周期结束时执行清理工作。C++标准强烈建议析构函数不应抛出异常。如果析构函数抛出异常，且该异常逃离了析构函数，C++运行时环境会调用 std::terminate。

代码示例：析构函数抛出异常

#include <iostream>
#include <exception>

class MyClass {
public:
  ~MyClass() {
    std::cerr << "Destructor called.n";
    throw std::runtime_error("Exception from destructor!"); // 析构函数抛出异常
  }
};

int main() {
  try {
    MyClass obj;
    // 可能会抛出异常的代码
  } catch (...) {
    std::cerr << "Caught exception.n";
  }

  std::cout << "This line will not be printed.n";
  return 0;
}

在这个例子中，MyClass 的析构函数抛出了一个 std::runtime_error 异常。由于该异常逃离了析构函数，C++运行时环境会调用 std::terminate，程序不会执行 catch 块中的代码，也不会输出 "Caught exception."。

正确的做法：

• 在析构函数中捕获并处理可能抛出的异常。
• 避免在析构函数中执行可能抛出异常的操作。
• 如果必须在析构函数中执行可能抛出异常的操作，请确保在析构函数内部捕获并处理这些异常，防止它们逃离析构函数。

修改后的代码示例：

#include <iostream>
#include <exception>

class MyClass {
public:
  ~MyClass() {
    std::cerr << "Destructor called.n";
    try {
      // 可能会抛出异常的操作
      throw std::runtime_error("Exception from destructor!");
    } catch (const std::exception& e) {
      std::cerr << "Exception caught in destructor: " << e.what() << std::endl;
      // 处理异常，例如：记录错误信息、释放资源等
    } catch (...) {
      std::cerr << "Unknown exception caught in destructor.n";
    }
  }
};

int main() {
  try {
    MyClass obj;
    // 可能会抛出异常的代码
  } catch (...) {
    std::cerr << "Caught exception in main.n";
  }

  std::cout << "This line might be printed.n";
  return 0;
}

在这个修改后的例子中，我们在析构函数内部使用 try-catch 块来捕获可能抛出的异常，并进行适当的处理。这样可以防止异常逃离析构函数，避免调用 std::terminate。

7. 表格总结 std::terminate 的调用场景

调用场景	描述
没有匹配的 catch 块	当抛出一个异常，但没有找到合适的 catch 块来处理它时。
二次异常（在异常处理过程中抛出异常）	在 catch 块或异常规范中抛出异常，且没有立即被同一个 catch 块捕获。注意，如果只是简单的嵌套try-catch块，而没有在第一次栈展开的时候立即捕获，还是会导致 terminate。
析构函数抛出异常	析构函数抛出异常，且该异常逃离了析构函数。
noexcept 函数抛出异常	声明为 noexcept 的函数抛出了异常。
栈展开过程中抛出异常	在栈展开过程中抛出异常。
终止处理函数抛出异常	自定义的终止处理函数抛出了异常。

8. 一个更复杂的例子

#include <iostream>
#include <exception>

class Resource {
public:
    Resource() {
        std::cout << "Resource acquired.n";
    }
    ~Resource() {
        std::cout << "Resource being released.n";
        // 模拟资源释放时可能抛出异常的情况
        try {
            throw std::runtime_error("Error releasing resource!");
        } catch (const std::exception& e) {
            std::cerr << "Exception caught during resource release: " << e.what() << std::endl;
            // 记录错误，尝试清理部分资源，但不再重新抛出
        } catch (...) {
            std::cerr << "Unknown exception caught during resource release.n";
        }
    }
};

void risky_operation() {
    Resource res; // 资源在函数结束时自动释放
    throw std::runtime_error("Error during risky operation!");
}

int main() {
    std::set_terminate([]() {
        std::cerr << "Custom terminate handler called due to unhandled exception.n";
        std::abort();
    });

    try {
        risky_operation();
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in main: " << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Unknown exception caught in main.n";
    }

    std::cout << "Program continues after exception handling (if not terminated).n";
    return 0;
}

在这个例子中，Resource 类模拟了一个需要手动释放的资源。它的析构函数故意抛出一个异常，但随后立即捕获并处理，避免了 std::terminate 的调用。risky_operation 函数创建了一个 Resource 对象，并抛出一个异常。在 main 函数中，我们捕获了这个异常，并输出错误信息。因为 Resource 对象的析构函数正确地处理了异常，所以程序不会调用 std::terminate，而是继续执行。

9. 编程实践建议

• 避免在析构函数中抛出异常： 这是最重要的原则。如果必须在析构函数中执行可能抛出异常的操作，请确保在析构函数内部捕获并处理这些异常。
• 谨慎使用 noexcept： 只有当你知道函数绝对不会抛出异常时，才应该使用 noexcept。如果一个声明为 noexcept 的函数实际上抛出了异常，程序会立即终止。
• 仔细设计异常处理策略： 确保你的程序能够正确地处理异常，避免出现二次异常的情况。
• 使用自定义终止处理函数进行调试： 在开发过程中，可以使用自定义终止处理函数来记录错误信息，帮助你调试程序。

避免二次异常，增强程序健壮性

理解 std::terminate 的调用机制对于编写健壮的C++程序至关重要。特别是要避免二次异常，确保析构函数不抛出异常，并谨慎使用 noexcept。通过合理地设计异常处理策略，我们可以提高程序的可靠性，并减少程序崩溃的可能性。

更多IT精英技术系列讲座，到智猿学院