【C++ 异常 】深入了解C++ 异常机制中的 terminate（）处理 避免不必要的错误（一）

1. 引言

在编程的世界中，我们经常面临各种技术挑战。但是，除了技术之外，我们还需要面对另一个更为复杂的领域：人性。编程不仅仅是一门技术，它也是一种艺术，一种需要深入理解人性的艺术。Freud（弗洛伊德）曾经说过：“人的行为是由他的潜意识所驱使的。”在编程中，这句话同样适用。

C++异常处理的重要性

C++异常处理是C++语言中的一个核心特性，它允许程序员在程序中定义和处理错误情况。但为什么我们需要异常处理呢？答案很简单：因为错误是不可避免的。但从心理学的角度来看，人们对待错误的态度是复杂的。我们都害怕犯错误，但同时，我们也知道错误是成长的源泉。

在C++中，异常（Exception）是程序中的一种特殊情况，它会中断程序的正常流程。当异常发生时，程序会尝试查找并执行特定的代码块来处理这种异常。这就是所谓的异常处理。

例如，考虑以下代码：

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("除数不能为零"); // 抛出异常
    }
    return a / b;
}

在这个例子中，我们定义了一个名为 divide 的函数，它接受两个整数参数并返回它们的商。但是，如果第二个参数（除数）为零，我们会抛出一个异常。

从心理学的角度来看，这段代码反映了我们对错误的恐惧。我们知道除以零是不可能的，所以我们通过抛出异常来避免这种情况。这是一种防御性编程策略，它反映了我们的潜意识对错误的恐惧。

本文目标与受众

本文的目标是深入探讨C++的异常处理机制，从技术和心理学的角度来看。我们将探讨异常处理的基础知识，深入其背后的原理，并通过实例来展示如何在实际编程中应用这些知识。

受众是那些已经有一定C++编程经验，但希望更深入地了解异常处理的程序员。同时，对于那些对心理学感兴趣的读者，本文也会提供一些有趣的洞察。

为什么要结合心理学？

编程不仅仅是关于代码。它也是关于人。当我们编写代码时，我们不仅仅是在与计算机交互，我们也在与其他程序员交互。我们的代码反映了我们的思维方式，我们的恐惧，我们的愿望。通过结合心理学，我们可以更好地理解我们自己，更好地编写代码。

例如，当我们面对一个复杂的编程问题时，我们可能会感到害怕或不安。这种恐惧可能会阻碍我们找到解决方案。但通过理解这种恐惧的来源，我们可以更好地面对它，更有效地解决问题。

2. C++异常处理的基础

在我们深入探讨异常处理的高级概念之前，我们首先需要了解其基础。异常处理是C++中的一个强大工具，但它也是一个双刃剑。正确使用时，它可以帮助我们编写更健壮、更可靠的代码。但如果使用不当，它可能会导致更多的问题。从心理学的角度来看，这与人们如何处理现实生活中的突发情况有异曲同工之妙。

异常的定义与抛出

在C++中，异常是一个对象，它表示程序中的某种错误或特殊情况。当这种情况发生时，我们可以“抛出”一个异常。

throw std::runtime_error("发生了一个错误");

在上面的代码中，我们创建了一个 std::runtime_error 对象，并使用 throw 关键字抛出它。这会立即中断程序的正常执行流程，并开始查找一个可以处理该异常的 catch 块。

从心理学的角度看，抛出异常就像是大脑中的警报系统。当我们面临危险或威胁时，我们的大脑会立即做出反应，准备我们应对这种情况。同样，当程序中发生错误时，抛出异常是程序的方式来告诉我们：“这里有问题，我们需要处理它！”

try-catch 机制简介

为了处理异常，我们使用 try-catch 机制。这允许我们定义一个代码块，该代码块可能会抛出异常，并指定如何处理这些异常。

try {
    // 可能抛出异常的代码
} catch (const std::runtime_error& e) {
    std::cerr << "捕获到异常: " << e.what() << std::endl;
}

在上面的代码中，我们首先定义了一个 try 块，其中包含可能抛出异常的代码。然后，我们定义了一个 catch 块，用于捕获并处理 std::runtime_error 类型的异常。

从心理学的角度看，try-catch 机制就像是我们的应对策略。当我们面临困难或挑战时，我们会制定一个计划来应对这些情况。如果计划失败，我们会有一个备用计划。同样，try-catch 机制允许我们为可能的错误制定一个“备用计划”。

标准异常类

C++标准库提供了一系列的异常类，这些类可以用来表示常见的错误情况。这些类都继承自 std::exception 类，它是所有标准异常类的基类。

以下是一些常见的标准异常类：

当我们面临特定的错误情况时，我们可以选择抛出适当的异常类。这使得我们的代码更具可读性，并允许其他程序员更容易地理解和处理异常。

从心理学的角度看，这就像是我们为特定的情感或情绪打上标签。当我们能够准确地识别和命名我们的情感时，我们就更容易处理它们。

3. 深入异常处理机制

在C++编程中，异常处理是一个非常重要的部分。它不仅仅是技术上的，更多的是与人性的关系。当我们面对错误时，我们的第一反应是什么？是逃避还是面对？异常处理正是这种“面对”的体现。正如心理学家Carl Rogers所说：“当我接受我自己的时候，我才能改变。”

异常的传播

当一个异常被抛出，它会在调用堆栈中向上传播，直到它被一个匹配的catch块捕获或传播到main()函数之外。这种传播机制与人类在面对困境时的反应相似。当我们面对一个问题时，我们可能会寻求帮助，直到找到一个可以解决问题的方法。

void functionA() {
    throw std::runtime_error("An error occurred!"); // 抛出异常
}
void functionB() {
    functionA();
}
int main() {
    try {
        functionB();
    } catch (const std::runtime_error& e) {
        std::cout << e.what() << std::endl; // 捕获并处理异常
    }
    return 0;
}

在上述代码中，functionA抛出一个异常，但它没有在functionA内部被捕获。异常继续在functionB中传播，最终在main函数中被捕获并处理。

多层嵌套的 try-catch 结构

在复杂的程序中，我们可能会遇到多层嵌套的try-catch结构。这反映了我们在面对问题时的层次化思考。首先，我们会尝试最直接的解决方法，如果失败，我们会尝试其他方法。

void complexFunction() {
    try {
        // 尝试一种方法
    } catch (const std::logic_error& le) {
        // 处理逻辑错误
    }
    try {
        // 尝试另一种方法
    } catch (const std::runtime_error& re) {
        // 处理运行时错误
    }
}

这种层次化的处理方式与心理学中的“分层次的需求理论”(Maslow’s hierarchy of needs)相似。我们首先满足基本的需求，然后才考虑更高层次的需求。

异常规格与noexcept

C++11引入了noexcept关键字，用于指示函数是否会抛出异常。这为编译器提供了优化的机会，因为它知道函数不会抛出异常。

void safeFunction() noexcept {
    // 这个函数保证不抛出异常
}

从心理学的角度看，noexcept就像是我们对自己的承诺。当我们承诺不做某事时，我们会更加努力确保自己不违背承诺。

在深入研究异常处理时，我们不仅要理解技术细节，还要理解其背后的人性。正如心理学家Freud所说：“未经意识的东西不会消失，它们只是被压抑，然后在不经意的时刻涌现出来。”

4. 高级异常处理技巧

在深入探索C++的异常处理后，我们现在将转向一些更高级的技巧和策略。与此同时，我们也将探讨这些技巧如何与人的心理特性相互作用，以及如何利用这些知识来编写更健壮、更人性化的代码。

使用捕获所有异常的 catch 块

在某些情况下，我们可能不知道函数可能抛出哪种类型的异常，或者我们可能想要对所有异常进行统一处理。在这种情况下，我们可以使用一个捕获所有异常的catch块。

try {
    // 可能抛出多种异常的代码
} catch (...) {
    // 处理所有类型的异常
}

从心理学的角度看，这种“一刀切”的处理方式可以看作是一种“过度概括”的认知偏见。人们有时会基于有限的信息做出判断，而忽略了个体差异。虽然这在编程中可能是有用的，但在现实生活中，这种偏见可能会导致误解和冲突。

自定义异常类

C++允许我们定义自己的异常类，这为异常处理提供了极大的灵活性。通过自定义异常，我们可以传递更多的错误信息，或者为特定的错误提供特定的处理逻辑。

class CustomException : public std::exception {
public:
    const char* what() const noexcept override {
        return "This is a custom exception.";
    }
};
try {
    throw CustomException();
} catch (const CustomException& e) {
    std::cout << e.what() << std::endl;
}

从心理学的角度看，自定义异常类似于人们为自己的情感和经历找到一个独特的表达方式。每个人都是独特的，有自己的故事和经历，自定义异常提供了一种方式，让我们的代码更好地反映这种独特性。

异常与资源管理（RAII）

资源获取即初始化（RAII, Resource Acquisition Is Initialization）是C++中的一个重要概念，它确保资源（如内存、文件句柄等）在对象的生命周期内被正确管理。当与异常结合使用时，RAII可以确保即使在异常发生时，所有资源也都被正确释放。

class FileHandler {
public:
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file.");
        }
    }
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
        }
    }
private:
    std::fstream file;
};
try {
    FileHandler handler("example.txt");
    // 文件操作
} catch (const std::runtime_error& e) {
    std::cout << e.what() << std::endl;
}

在上述代码中，即使在文件操作过程中发生异常，FileHandler的析构函数仍然会被调用，确保文件被正确关闭。

从心理学的角度看，RAII与人们在面对困境时的应对策略相似。即使在面对挑战时，我们仍然需要确保我们的责任和承诺得到履行。

“人的真正完美不在于他拥有什么，而在于他是什么。” - Sigmund Freud

在深入研究高级异常处理技巧时，我们不仅要理解技术细节，还要理解其背后的人性。这种结合技术和心理学的方法，可以帮助我们编写更健壮、更人性化的代码。

5. 异常处理的性能考量

在深入探讨异常处理的性能考量之前，我们首先要理解为什么性能是一个关键问题。从心理学的角度来看，人们对于程序的响应时间有着固有的期望。当程序的响应时间超过这个期望时，用户的满意度会显著下降。这是因为人们的大脑被训练来期望即时的反馈（Pavlov的条件反射理论）。因此，作为开发者，我们需要确保我们的代码不仅是正确的，而且是高效的。

5.1. 异常处理的开销

异常处理机制确实带来了一些运行时开销。这主要是因为当异常被抛出时，程序需要查找匹配的catch块，这可能涉及多个函数调用的堆栈展开。

例如，考虑以下代码：

void functionA() {
    throw std::runtime_error("An error occurred!");
}
void functionB() {
    functionA();
}
int main() {
    try {
        functionB();
    } catch (const std::runtime_error& e) {
        std::cout << e.what() << std::endl;
    }
}

当functionA中的异常被抛出时，程序需要回溯到main函数来找到匹配的catch块。这个回溯过程涉及到堆栈展开，这是一个相对昂贵的操作。

但是，这种开销只在异常实际被抛出时发生。如果异常很少被抛出，那么这种开销在实际应用中可能可以忽略不计。

5.2. 设计考虑：异常频繁抛出的影响

从心理学的角度来看，当我们面对频繁的打断和中断时，我们的注意力和专注力会受到影响（多任务处理的心理学成本）。同样，当程序频繁地抛出异常时，它的性能也会受到影响。

考虑一个循环中频繁抛出异常的情况：

for (int i = 0; i < 1000000; ++i) {
    try {
        if (i % 2 == 0) {
            throw std::runtime_error("Even number!");
        }
    } catch (const std::runtime_error& e) {
        // Handle exception
    }
}

在这种情况下，由于异常频繁地被抛出和捕获，程序的性能会受到显著的影响。

5.3. 优化技巧与建议

5.3.1. 避免不必要的异常

异常应该仅用于表示真正的异常情况，而不是常规的程序流程。例如，使用返回值或状态码来表示常见的错误情况，而不是抛出异常。

5.3.2. 使用noexcept

C++11引入了noexcept规范，它指示函数不会抛出异常。这可以帮助编译器进行优化，因为它知道在某些情况下不需要生成异常处理代码。

void myFunction() noexcept {
    // This function will not throw exceptions
}

5.3.3. 技术对比

总之，异常处理是C++中强大的工具，但与此同时，它也带来了一些性能开销。通过深入了解这些开销及其原因，以及如何优化它们，我们可以写出更高效、更健壮的代码。同时，从心理学的角度来看，了解这些开销和优化技巧可以帮助我们更好地满足用户的期望，提供更好的用户体验。

“人的大脑并不是为了处理逻辑或进行数学运算而进化的，而是为了解决与生存和繁殖相关的实际问题而进化的。” - Steven Pinker

6. 未捕获异常的后果

在C++编程中，异常处理是一个至关重要的部分。当我们谈论异常时，我们通常指的是程序运行时出现的意外情况，这可能会导致程序的非正常终止。但是，当这些异常没有被适当地捕获和处理时，它们会产生什么后果呢？

6.1 std::terminate()的角色与行为

当C++程序中抛出了一个异常，但没有相应的捕获处理程序来捕获它时，会自动调用std::terminate()函数。这是C++标准库中的一个特殊函数，它的默认行为是终止程序。

6.1.1 默认行为与std::abort()

默认情况下，std::terminate()会调用std::abort()函数，导致程序发送一个SIGABRT（中止信号）并异常终止。这个信号是为了告诉操作系统进程由于某种内部错误而被中止。这种行为确保了程序不会在一个不确定的状态下继续运行，从而可能导致更严重的问题。

#include <iostream>
#include <stdexcept>
int main() {
    try {
        throw std::runtime_error("An error occurred!");
    }
    // 没有捕获到异常，程序会调用 std::terminate()
}

在上面的示例中，我们抛出了一个std::runtime_error异常，但没有提供相应的catch块来捕获它。因此，程序会调用std::terminate()并终止。

【C++ 异常 】深入了解C++ 异常机制中的 terminate（）处理 避免不必要的错误（二）https://developer.aliyun.com/article/1467410