RAII 智能指针 C++

CS106L p17 Part 6.1 RAII and Smart Pointers

RAII

RAII（Resource Acquisition Is Initialization） 是 C++ 编程中一种非常重要且常用的编程技术，旨在通过对象生命周期管理资源（如内存、文件句柄、网络连接等）的获取和释放，确保资源能够在程序执行过程中得到有效管理并避免资源泄露。RAII 的核心思想是“资源的获取就是初始化，资源的释放就是对象销毁时进行的析构操作”。

1. RAII 的基本原理

RAII 的基本思想是通过在对象的构造函数中获得资源，并在对象的析构函数中释放资源。换句话说，资源（如内存、文件句柄、数据库连接等）通过对象的生命周期来管理，确保资源在对象超出作用域时自动释放，从而避免了手动释放资源的复杂性。

关键点：

资源的获取：在对象的构造函数中获得资源，通常在构造函数中进行动态内存分配、文件打开、数据库连接等操作。
资源的释放：在对象的析构函数中释放资源，通常在析构函数中执行释放内存、关闭文件、断开数据库连接等操作。

2. RAII 的工作原理

RAII 在 C++ 中依赖于自动变量的生命周期。程序中定义的局部变量在作用域结束时会被销毁，而其析构函数会被自动调用。如果这些变量管理了某些资源（如内存、文件、互斥锁等），那么在析构函数中释放这些资源，就能确保资源得到了及时的释放。

举个例子，假设我们有一个管理文件资源的类 FileGuard，它在对象创建时打开文件，在对象销毁时自动关闭文件。

#include <iostream>
#include <fstream>

class FileGuard {
private:
    std::ifstream file;
public:
    // 构造函数中打开文件
    FileGuard(const std::string& filename) {
        file.open(filename);
        if (!file) {
            throw std::runtime_error("File could not be opened.");
        }
        std::cout << "File opened successfully!" << std::endl;
    }
    
    // 析构函数中关闭文件
    ~FileGuard() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed." << std::endl;
        }
    }
};

int main() {
    try {
        FileGuard fg("example.txt");  // 自动打开文件
        // 在此处可以进行文件操作
    } catch (const std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    // 当fg超出作用域时，它会被销毁，析构函数自动关闭文件
}

在这个例子中，FileGuard 类负责打开和关闭文件。通过在构造函数中打开文件，并在析构函数中关闭文件，我们确保了文件始终在使用后被关闭，即使在发生异常时也能自动关闭文件。这就是 RAII 的一个典型应用。

输出：

1 2	`File opened successfully! File closed.`

3. RAII 的优点

RAII 的核心优势之一就是它确保了资源的自动释放，避免了资源泄漏。它提供了以下几个明显的优点：

自动管理资源：RAII 自动管理资源的生命周期，不需要手动释放。程序员不必担心忘记释放资源，或因异常导致资源没有释放。
异常安全：在 RAII 中，资源的释放发生在对象的析构函数中，这样即使发生异常，也能确保资源会被正确释放（避免了资源泄漏）。因此，RAII 提供了一种异常安全的机制，即使在复杂的控制流中（例如，在异常发生时）也能保持资源的正确管理。
简化代码：RAII 使得资源的管理更加直观和简洁。程序员只需要关注对象的创建和销毁，而不需要显式地释放资源。
增强可维护性：由于资源管理是与对象的生命周期紧密绑定的，程序的维护和扩展更加方便。对象的创建、使用和销毁过程通常在同一个地方进行管理，减少了跨多个函数或类管理资源的复杂性。

4. RAII 和资源泄漏

资源泄漏通常发生在程序没有正确释放资源的情况下。RAII 通过将资源的获取和释放与对象的生命周期紧密关联起来，从而有效避免了资源泄漏。例如，在上述 FileGuard 类中，无论是正常退出作用域还是发生异常，fg 对象都会被销毁，~FileGuard 析构函数会被自动调用，从而确保了文件被正确关闭。

假设不使用 RAII，我们可能需要手动在每个可能的退出点释放资源：

void openFile(const std::string& filename) {
    std::ifstream file;
    file.open(filename);
    
    if (!file) {
        std::cerr << "Failed to open file." << std::endl;
        return;
    }

    // 其他处理代码

    file.close();  // 必须显式关闭文件
}

如果在文件打开后发生异常（例如在“其他处理代码”中发生了异常），那么 file.close() 可能就永远不会被执行，导致资源泄漏。而使用 RAII 技术，可以避免这种问题。

5. RAII 的应用场景

RAII 不仅适用于内存管理，还可以应用于其他资源的管理。以下是一些常见的应用场景：

动态内存管理：使用 std::unique_ptr 和 std::shared_ptr 来管理动态分配的内存。std::unique_ptr 在对象生命周期结束时自动释放内存，避免了手动释放内存的麻烦。
1
2
std::unique_ptr<int> ptr = std::make_unique<int>(10); // 自动分配内存 // ptr 超出作用域时，内存会自动释放
文件管理：如前所述，通过定义一个类来在对象构造时打开文件，在析构时自动关闭文件，避免了文件泄漏问题。

锁管理：使用 std::lock_guard 或 std::unique_lock 等来管理互斥锁的获取和释放。锁在构造时被获取，在析构时自动释放，避免死锁和锁没有释放的问题。

std::mutex mtx;
void threadSafeFunction() {
    std::lock_guard<std::mutex> lock(mtx);  // 锁定互斥量
    // 执行线程安全操作
}  // 当lock超出作用域时，mutex会自动解锁

数据库连接：使用 RAII 管理数据库连接。当对象创建时建立数据库连接，析构时断开连接，确保连接始终处于正确的状态。

6. RAII 的限制

尽管 RAII 是一种非常有用的技术，但它也有一些限制和挑战：

资源的类型限制：RAII 主要适用于那些在对象销毁时需要释放的资源。如果资源的释放不依赖于对象的生命周期（例如某些全局资源或跨多个对象共享的资源），RAII 可能就不适用。
跨线程资源管理：在多线程环境中，RAII 可能无法有效地管理共享资源的访问，特别是在多个线程之间共享资源时，需要额外的同步机制来保证线程安全。

7. 总结

RAII（Resource Acquisition Is Initialization）是 C++ 中一种强大且优雅的技术，它通过将资源的管理与对象的生命周期绑定，自动管理资源的获取和释放，避免了资源泄漏和内存管理的复杂性。RAII 不仅可以用于内存管理，还可以广泛应用于文件、网络连接、数据库连接、互斥锁等资源的管理，是 C++ 编程中非常重要的设计思想之一。

Smart Pointer

C++中的智能指针（smart pointer）是一种封装原始指针（raw pointer）的对象，它通过自动管理内存的分配和释放，帮助程序员避免内存泄漏和悬空指针等问题。智能指针的核心思想是将动态内存的管理从程序员手中转移到一个管理对象（智能指针）中，减少手动管理内存的复杂性和风险。

C++标准库提供了几种类型的智能指针，主要包括：

std::unique_ptr
std::shared_ptr
std::weak_ptr

这些智能指针是C++11引入的，旨在提高代码的安全性和可维护性，特别是在复杂的内存管理场景中。

1. `std::unique_ptr`

std::unique_ptr 是最基本的智能指针，它表示对动态分配内存的独占所有权。一个 std::unique_ptr 在任何时候只能指向一个对象，并且该指针是唯一的（即只能有一个 std::unique_ptr 拥有某个资源）。当 std::unique_ptr 被销毁时，它所管理的对象会自动被销毁，内存会被释放。

特性：

独占所有权：每个资源只能由一个 std::unique_ptr 拥有，不能复制（没有复制构造函数和复制赋值运算符）。
自动释放内存：当 std::unique_ptr 超出作用域时，它会自动调用析构函数释放资源，避免了手动 delete 的需要。

使用示例：

#include <iostream>
#include <memory>  // 引入 std::unique_ptr

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor\n";
    }
    ~MyClass() {
        std::cout << "MyClass destructor\n";
    }
};

int main() {
    // 创建一个 unique_ptr，管理 MyClass 对象
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();

    // ptr1 离开作用域时，MyClass 的对象会被销毁，自动释放内存
}

输出：

1 2	`MyClass constructor MyClass destructor`

转移所有权：

std::unique_ptr 的所有权不能被复制，但可以通过 std::move 转移所有权。转移所有权后，原来的 std::unique_ptr 变为空指针（nullptr）。

1	`std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 转移所有权`

2. `std::shared_ptr`

std::shared_ptr 是一种共享所有权的智能指针，允许多个指针共享同一块内存资源。每当创建一个新的 std::shared_ptr 来指向同一个对象时，它们的引用计数会增加。当一个 std::shared_ptr 被销毁时，引用计数会减少，直到没有任何 shared_ptr 指向该对象时，资源会被释放。

特性：

共享所有权：多个 std::shared_ptr 可以共同拥有同一个资源。每个指针都可以访问资源，并通过引用计数机制来判断何时释放资源。
引用计数：每个 std::shared_ptr 都会持有一个引用计数，记录有多少个智能指针共享这个资源。当引用计数归零时，资源会自动释放。

使用示例：

#include <iostream>
#include <memory>  // 引入 std::shared_ptr

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor\n";
    }
    ~MyClass() {
        std::cout << "MyClass destructor\n";
    }
};

int main() {
    // 创建一个 shared_ptr，管理 MyClass 对象
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();

    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";

    // 创建另一个 shared_ptr，指向相同的对象
    std::shared_ptr<MyClass> ptr2 = ptr1;

    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
    std::cout << "ptr2 use_count: " << ptr2.use_count() << "\n";

    // 退出作用域时，ptr1 和 ptr2 都会被销毁，引用计数为 0，资源自动释放
}

输出：

MyClass constructor
ptr1 use_count: 1
ptr1 use_count: 2
ptr2 use_count: 2
MyClass destructor

引用计数：

use_count() 方法返回当前 std::shared_ptr 所管理资源的引用计数。

循环引用：

std::shared_ptr 的引用计数机制可能导致循环引用的问题。例如，两个对象通过 shared_ptr 相互持有对方的指针，这样会导致它们永远不会被销毁，造成内存泄漏。

class A;
class B {
public:
    std::shared_ptr<A> a;
};

class A {
public:
    std::shared_ptr<B> b;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b = b;
    b->a = a;  // 循环引用，内存不会被释放
}

为避免循环引用的问题，可以使用 std::weak_ptr。

3. `std::weak_ptr`

std::weak_ptr 是一种不拥有对象的智能指针，它主要用来解决 std::shared_ptr 中的循环引用问题。std::weak_ptr 不会增加引用计数，因此它不会影响对象的生命周期。std::weak_ptr 主要用于观察某个对象是否已经被销毁，或者作为缓存机制的补充。

特性：

不增加引用计数：std::weak_ptr 不会导致引用计数增加，因此它不会阻止对象的销毁。
**可以转换为 shared_ptr**：通过调用 std::weak_ptr::lock()，可以将 std::weak_ptr 转换为一个 std::shared_ptr。如果对象已经被销毁，lock() 会返回一个空指针。

使用示例：

#include <iostream>
#include <memory>  // 引入 std::weak_ptr

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor\n";
    }
    ~MyClass() {
        std::cout << "MyClass destructor\n";
    }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weakPtr = ptr1;  // weak_ptr 不增加引用计数

    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";

    std::shared_ptr<MyClass> ptr2 = weakPtr.lock();  // 将 weak_ptr 转换为 shared_ptr
    if (ptr2) {
        std::cout << "Successfully locked weak_ptr\n";
    } else {
        std::cout << "Failed to lock weak_ptr\n";
    }

    ptr1.reset();  // 销毁 ptr1

    std::shared_ptr<MyClass> ptr3 = weakPtr.lock();  // weak_ptr 转换失败
    if (ptr3) {
        std::cout << "Successfully locked weak_ptr\n";
    } else {
        std::cout << "Failed to lock weak_ptr\n";
    }
}

输出：

MyClass constructor
ptr1 use_count: 1
Successfully locked weak_ptr
MyClass destructor
Failed to lock weak_ptr

4. 总结

C++中的智能指针（std::unique_ptr、std::shared_ptr 和 std::weak_ptr）是现代C++中非常重要的工具，它们帮助程序员有效地管理动态内存和其他资源，减少内存泄漏、悬空指针和重复释放资源等问题。每种智能指针有其独特的使用场景：

**std::unique_ptr**：用于独占资源，适用于动态内存管理，资源的所有权不能被共享。
**std::shared_ptr**：用于共享资源，适用于多个指针共享同一块内存，引用计数机制确保资源在没有指针指向时被释放。
**std::weak_ptr**：用于避免循环引用，允许观察资源而不干扰其生命周期。

通过智能指针的使用，可以大大简化内存管理并提升程序的安全性和可维护性。

文件流

在C++中，文件流（fstream）是用于处理文件输入输出的类库。它允许程序读取和写入文件，广泛应用于文件操作。文件流提供了三个主要的类，分别对应不同的操作方式：

ifstream（Input File Stream）：用于从文件中读取数据。
ofstream（Output File Stream）：用于将数据写入文件。
fstream（File Stream）：即可以读取也可以写入文件。

1. `ifstream`（输入文件流）

ifstream 是用来从文件读取数据的流对象。它继承自 istream 类，并可以通过成员函数如 open() 和 close() 来操作文件。

示例：使用 `ifstream` 读取文件内容

#include <iostream>
#include <fstream> // 引入文件流头文件
#include <string>

int main() {
    std::ifstream file("example.txt"); // 打开文件
    if (!file) { // 检查文件是否成功打开
        std::cerr << "无法打开文件!" << std::endl;
        return 1;
    }
    
    std::string line;
    while (std::getline(file, line)) { // 逐行读取文件
        std::cout << line << std::endl; // 输出文件内容
    }
    
    file.close(); // 关闭文件流
    return 0;
}

`ifstream` 常用成员函数：

open(): 打开文件进行读取。
close(): 关闭文件。
getline(): 逐行读取文件内容。
eof(): 检查是否到达文件末尾。
fail(): 检查文件操作是否成功。

2. `ofstream`（输出文件流）

ofstream 用于向文件写入数据。它继承自 ostream 类，可以通过 open() 函数打开文件，使用 << 运算符将数据写入文件。

示例：使用 `ofstream` 写入文件内容

#include <iostream>
#include <fstream> // 引入文件流头文件

int main() {
    std::ofstream file("output.txt"); // 打开文件进行写入
    if (!file) { // 检查文件是否成功打开
        std::cerr << "无法打开文件!" << std::endl;
        return 1;
    }
    
    file << "Hello, World!" << std::endl; // 向文件写入数据
    file << "C++ 文件流示例。" << std::endl;
    
    file.close(); // 关闭文件流
    return 0;
}

`ofstream` 常用成员函数：

open(): 打开文件进行写入。
close(): 关闭文件。
flush(): 将缓冲区内容强制写入文件。
eof(): 检查是否到达文件末尾。

3. `fstream`（文件流）

fstream 类结合了 ifstream 和 ofstream 的功能，它既可以用于读取文件，也可以用于写入文件。使用 fstream 可以在一个程序中同时执行文件的输入输出操作。

示例：使用 `fstream` 进行读写操作

#include <iostream>
#include <fstream> // 引入文件流头文件

int main() {
    std::fstream file("example.txt", std::ios::in | std::ios::out); // 打开文件进行读写
    if (!file) { // 检查文件是否成功打开
        std::cerr << "无法打开文件!" << std::endl;
        return 1;
    }
    
    // 读取文件
    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << std::endl; // 输出文件内容
    }
    
    // 移动文件指针到文件开头
    file.clear(); // 清除 EOF 标志
    file.seekg(0, std::ios::beg); // 文件读取指针移到文件开头
    
    // 向文件写入数据
    file << "\n新的数据行\n";
    
    file.close(); // 关闭文件流
    return 0;
}

`fstream` 常用成员函数：

open(): 打开文件进行读写操作。
close(): 关闭文件流。
seekg(): 设置读取文件的指针位置。
seekp(): 设置写入文件的指针位置。
eof(): 检查是否到达文件末尾。
clear(): 清除文件流状态标志。

文件操作模式

在打开文件时，除了可以指定文件名外，还可以传递一个文件打开模式。常用的打开模式包括：

std::ios::in: 打开文件用于输入（读取）。
std::ios::out: 打开文件用于输出（写入）。
std::ios::app: 打开文件用于追加写入（文件末尾）。
std::ios::ate: 打开文件并将文件指针指向文件末尾。
std::ios::trunc: 打开文件并清空文件内容（默认行为，当以 std::ios::out 模式打开时）。
std::ios::binary: 以二进制模式打开文件。

示例：使用不同的文件模式

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("example.txt", std::ios::app); // 以追加模式打开文件
    if (!file) {
        std::cerr << "无法打开文件!" << std::endl;
        return 1;
    }
    
    file << "追加的内容" << std::endl;
    file.close();
    return 0;
}

错误处理和流状态

在文件操作中，错误处理是一个重要环节。流类提供了几个成员函数来检测流的状态：

fail(): 流的操作失败时返回 true。
eof(): 是否到达文件末尾。
good(): 流的状态是否正常。
bad(): 流的状态是否出现致命错误。

错误处理示例：

#include <iostream>
#include <fstream>

int main() {
    std::ifstream file("nonexistent.txt");
    if (!file) { // 检查是否成功打开文件
        std::cerr << "文件打开失败!" << std::endl;
        return 1;
    }
    // 读取文件操作
    file.close();
    return 0;
}

总结

C++中的文件流类库提供了一系列强大和灵活的接口来操作文件，无论是读取、写入还是同时进行文件的输入输出操作。通过使用 ifstream、ofstream 和 fstream，程序员可以轻松实现各种文件操作，并且可以在不同模式下打开文件。流状态的管理也是进行文件操作时需要注意的重点。

重定向（指定输入来源或输出去向）

freopen("input.txt", "r", stdin); 这一行是 C 或 C++ 中的一个标准库函数 freopen 的调用。它的作用是重新指定标准输入流（stdin）的来源，使其从文件 input.txt 中读取数据，而不是从默认的标准输入设备（通常是键盘）读取。

解释：

freopen 函数用于重新打开一个文件并将其与一个标准流（如 stdin、stdout 或 stderr）关联。其基本语法是：

1	`FILE* freopen(const char* filename, const char* mode, FILE* stream);`

filename: 要打开的文件名（可以是相对路径或绝对路径）。
mode: 文件的打开模式（类似于 fopen 的模式，比如 "r"、"w" 等）。
stream: 要重定向的标准流，通常是 stdin（标准输入）、stdout（标准输出）或 stderr（标准错误输出）。

在你的例子中：

1	`freopen("input.txt", "r", stdin);`

input.txt：这是你想要打开的文件名，它作为标准输入流的数据来源。
"r"：表示以“只读”模式打开文件。
stdin：是标准输入流，表示程序从哪里读取输入数据。默认情况下，它指向键盘输入。通过 freopen，你将标准输入流重定向到 input.txt 文件。

作用：

这行代码的作用是将标准输入重定向为从 input.txt 文件中读取数据。之后，所有从标准输入读取的数据（例如通过 scanf 或 cin）都会从 input.txt 文件中获取，而不是从键盘输入。

示例代码：

假设有一个 input.txt 文件，内容如下：

1
2
3

5
10
15

如果你有如下的 C++ 代码：

#include <iostream>
#include <cstdio>

int main() {
    // 将标准输入重定向到 input.txt 文件
    freopen("input.txt", "r", stdin);

    int a, b, c;
    std::cin >> a >> b >> c;  // 从 input.txt 文件中读取三个整数

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
    
    return 0;
}

这时程序执行时，std::cin 会从 input.txt 文件中读取数据。
input.txt 文件的内容会按顺序被读取并存储到 a、b 和 c 变量中。
程序输出的结果将是：
1
a: 5, b: 10, c: 15

使用场景：

文件输入重定向：这种用法常见于处理文件输入输出的程序中。通过将 stdin 重定向为文件，可以模拟用户从文件中提供输入，特别在批量测试中非常有用。
多文件处理：如果程序需要处理多个输入文件，可以用 freopen 来切换不同的输入源，而不需要修改程序中所有读取输入的代码。
竞赛编程：在编程竞赛中，常常会将输入从文件中读取，而不是通过键盘输入。这时使用 freopen 可以方便地将标准输入重定向到文件。

注意事项：

在使用 freopen 时，一定要确保文件存在且可访问，否则会导致程序出现错误。如果 freopen 打开文件失败，它会返回 nullptr，这时应该检查返回值来处理错误。
freopen 会关闭原本的 stdin，如果你需要恢复标准输入，可以在适当的时机调用 freopen 重新将标准输入流恢复为控制台或其他流。

示例代码中的错误处理：

#include <iostream>
#include <cstdio>

int main() {
    // 将标准输入重定向到 input.txt 文件
    if (freopen("input.txt", "r", stdin) == nullptr) {
        std::cerr << "无法打开 input.txt 文件" << std::endl;
        return 1;  // 出现错误时退出
    }

    int a, b, c;
    std::cin >> a >> b >> c;

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;

    return 0;
}

在上面的代码中，如果 freopen 无法成功打开 input.txt 文件，程序会输出错误信息并退出。

总结：

freopen("input.txt", "r", stdin); 通过将标准输入流重定向到文件 input.txt，使得后续通过 std::cin 或 scanf 的输入都来自该文件，而不是来自键盘。这种方法在需要从文件读取输入数据时非常有用。

异常处理

C++中的异常处理是一种程序控制机制，它使程序能够在运行时检测并响应错误或异常情况，从而避免程序崩溃并允许程序员采取适当的补救措施。C++的异常处理系统通过关键字 try、catch 和 throw 来实现，这种机制与其他语言如Java或Python中的异常处理机制有相似之处，但也具有其独特性。

1. 异常的基本概念

在C++中，异常是一种被抛出的对象，通常用于指示程序发生了错误或不正常的情况。抛出的异常通常是一个对象的实例，这个对象可以是任何类型，C++并不限制异常的类型，因此，程序员可以定义自己的异常类型。

异常处理机制的基本目标是：

捕获异常：当发生异常时，程序能够捕获异常并做出适当的处理。
恢复程序流：程序能够在处理完异常后恢复正常的控制流。

2. 异常处理的关键字

C++中异常处理的核心有三个关键字：try、throw 和 catch。

2.1 `try` 块

try 块用于包含可能会抛出异常的代码。其基本语法如下：

1
2
3

try {
    // 可能抛出异常的代码
}

try 块中的代码会被正常执行，如果在执行过程中抛出了异常，则控制流会立即跳转到相应的 catch 块。

2.2 `throw` 关键字

throw 关键字用于抛出异常。它后面跟着异常对象，异常对象可以是任何类型的对象。常见的做法是抛出类对象、基础类型或标准库异常类的实例。

抛出异常的基本语法如下：

1	`throw exception_object;`

例如，抛出一个整数类型的异常：

1	`throw 10; // 抛出整数 10`

或者抛出一个自定义的异常对象：

class MyException {
public:
    const char* what() const noexcept {
        return "An error occurred!";
    }
};

throw MyException();

2.3 `catch` 块

catch 块用于捕获 try 块中抛出的异常，并对其进行处理。catch 块必须紧随 try 块之后，且它可以根据异常的类型定义不同的处理方式。

基本语法如下：

try {
    // 可能抛出异常的代码
} catch (exception_type& e) {
    // 异常处理代码
}

其中，exception_type 是捕获的异常类型，e 是该类型的引用变量，允许在 catch 块中访问异常对象。

例如，捕获并处理整数类型的异常：

try {
    throw 10;
} catch (int e) {
    std::cout << "Caught an integer exception: " << e << std::endl;
}

3. 异常传递与处理过程

当异常发生时，程序会开始从 try 块中的代码执行位置开始寻找一个合适的 catch 块来处理该异常。如果在当前函数内没有找到匹配的 catch 块，异常会被传递到调用该函数的上层函数中，并继续进行匹配过程，直到找到合适的 catch 块或者程序终止。

在C++中，异常处理是基于栈展开机制进行的。即当异常发生时，程序会依次销毁栈上所有的局部对象，执行它们的析构函数，这一过程称为“栈展开”。这种机制有助于确保资源能够被正确地释放。

4. 自定义异常类型

C++允许程序员定义自己的异常类型。自定义异常通常通过继承标准异常类（如 std::exception）来实现。std::exception 是C++标准库中所有异常类的基类，它提供了一个 what() 方法来返回异常的描述信息。

自定义异常类的例子：

#include <iostream>
#include <exception>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Custom exception occurred!";
    }
};

int main() {
    try {
        throw MyException();
    } catch (const MyException& e) {
        std::cout << e.what() << std::endl;
    }
}

5. 异常处理中的资源管理

在异常处理中，资源管理是一个重要的考虑因素。为了避免资源泄露，C++推荐使用 RAII（Resource Acquisition Is Initialization）模式来管理资源。RAII是通过在对象的生命周期内管理资源来确保资源得到适时释放的一种技术。

例如，使用 std::unique_ptr 或 std::shared_ptr 来管理动态分配的内存，可以确保即使发生异常，内存也能自动释放。

#include <memory>

void function() {
    std::unique_ptr<int> p = std::make_unique<int>(10);
    // 其他可能抛出异常的操作
    // p会在函数结束时自动释放内存
}

6. 异常规范（Exception Specification）

在C++98和C++03中，函数可以声明它们可能抛出哪些类型的异常，使用 throw 关键字。例如：

1	`void myFunction() throw (std::exception);`

这表示 myFunction 可能抛出 std::exception 类型的异常。然而，这种异常规范在C++11及以后版本被废弃，取而代之的是 noexcept 关键字，后者用于声明函数不会抛出任何异常：

1
2
3

void myFunction() noexcept {
    // 这个函数不会抛出异常
}

7. 异常安全

在编写C++程序时，必须考虑异常安全。异常安全指的是程序在发生异常时，能够保持一致性并防止资源泄漏。C++提供了不同级别的异常安全保证：

基本保证（Basic Guarantee）：即使发生异常，程序的状态不会处于不一致的状态。对象的析构函数将被正确调用，资源将被释放。
强保证（Strong Guarantee）：即使发生异常，程序的状态也不会发生变化，相当于回滚到异常发生前的状态。
无保证（No Guarantee）：没有提供任何保证，异常发生时可能会破坏程序状态。

对于复杂的代码，通常使用“强保证”或“基本保证”来确保程序在异常发生时的稳定性。

8. 总结

C++的异常处理机制为程序员提供了一种优雅的方式来处理运行时错误。通过 try、catch 和 throw 关键字，程序员可以在错误发生时捕获并处理异常，避免程序崩溃。同时，C++中的异常处理还涉及到自定义异常类型、异常规范、资源管理和异常安全等多个方面，这些都需要程序员仔细设计和实现。

标准库中的异常类

是的，C++标准库包含了一些用于异常处理的类。这些异常类都继承自 std::exception 类，std::exception 是所有标准异常类的基类，它提供了基本的异常信息功能。除了 std::exception，C++标准库还定义了一些具体的异常类，用于表示不同类型的错误情况。

以下是一些常见的C++标准库异常类的概述：

1. `std::exception`

std::exception 是所有标准异常类的基类。它提供了一个 what() 成员函数，用于返回关于异常的描述信息。通常可以通过重载这个函数来提供自定义的异常信息。

#include <iostream>
#include <exception>

void func() {
    throw std::exception();
}

int main() {
    try {
        func();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: std::exception`

2. `std::runtime_error`

std::runtime_error 是 std::exception 的派生类，用于表示程序运行时发生的错误，通常用于逻辑错误、状态不一致等。它的构造函数接受一个 const char* 类型的参数，用来提供详细的错误信息。

#include <iostream>
#include <stdexcept>

void func() {
    throw std::runtime_error("Runtime error occurred!");
}

int main() {
    try {
        func();
    } catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: Runtime error occurred!`

3. `std::logic_error`

std::logic_error 也是 std::exception 的一个派生类，用于表示程序逻辑上的错误，通常是违反了某种约定、使用不当等。例如，访问空指针、无效的输入等问题可能会引发此类异常。

常见的 std::logic_error 的子类有：

std::invalid_argument：表示传递给函数的参数无效。
std::domain_error：表示输入值不在定义的范围内。
std::length_error：表示容器超出了允许的最大长度。
std::out_of_range：表示尝试访问超出范围的元素。

例如：

#include <iostream>
#include <stdexcept>

void func(int n) {
    if (n < 0) {
        throw std::invalid_argument("Negative number is not allowed!");
    }
}

int main() {
    try {
        func(-5);
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: Negative number is not allowed!`

4. `std::bad_alloc`

std::bad_alloc 是 std::exception 的一个派生类，专门用来表示内存分配失败的异常。它通常在 new 操作符无法分配内存时抛出。

#include <iostream>
#include <new>  // 引入 std::bad_alloc

int main() {
    try {
        int* arr = new int[1000000000];  // 试图分配过多的内存
    } catch (const std::bad_alloc& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: std::bad_alloc`

5. `std::out_of_range`

std::out_of_range 继承自 std::logic_error，用于表示访问容器中不存在的元素，通常出现在数组、向量、字符串等容器的下标超出有效范围时。

#include <iostream>
#include <stdexcept>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3};

    try {
        std::cout << v.at(5) << std::endl;  // 超出范围
    } catch (const std::out_of_range& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: vector::_M_range_check: __n (which is 5) >= this->size() (which is 3)`

6. `std::overflow_error` 和 `std::underflow_error`

std::overflow_error 和 std::underflow_error 都是继承自 std::runtime_error 的异常类，分别用于表示算术运算中的溢出和下溢错误。

例如，溢出可能发生在数值运算时，如超出了类型的最大表示范围。

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::overflow_error("Overflow error occurred!");
    } catch (const std::overflow_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: Overflow error occurred!`

7. `std::ios_base::failure`

std::ios_base::failure 是一个用于处理输入输出流错误的异常类。它继承自 std::exception，通常在流操作失败时抛出，例如读取或写入文件时发生错误。

#include <iostream>
#include <fstream>
#include <stdexcept>

int main() {
    try {
        std::ifstream file("non_existent_file.txt");
        if (!file) {
            throw std::ios_base::failure("Failed to open file!");
        }
    } catch (const std::ios_base::failure& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

输出：

1	`Caught exception: Failed to open file!`

8. `std::bad_cast` 和 `std::bad_typeid`

std::bad_cast：当尝试进行不合法的类型转换（例如，dynamic_cast 失败）时抛出此异常。
std::bad_typeid：当对一个空指针调用 typeid 时抛出此异常。

9. 总结

C++标准库提供了丰富的异常类，能够涵盖程序中多种常见的错误类型。通过继承自 std::exception 和其它专门的子类，C++的异常机制能够为程序提供强大的错误处理能力。这些标准异常类帮助程序员捕获和处理各种不同类型的错误，确保程序的稳定性和健壮性。

C++ > CS106L

#RAII #智能指针 #文件流 #异常处理

RAII 智能指针 C++

http://wang-jiahao.github.io/posts/60866.html

作者

Jiahao Wang

发布于

2024年12月5日

更新于

2024年12月11日

许可协议

多线程 C++ 上一篇

继承和模板类 C++ 下一篇

RAII 智能指针 C++

RAII

1. RAII 的基本原理

关键点：

2. RAII 的工作原理

输出：

3. RAII 的优点

4. RAII 和资源泄漏

5. RAII 的应用场景

6. RAII 的限制

7. 总结

Smart Pointer

1. std::unique_ptr

特性：

使用示例：

转移所有权：

2. std::shared_ptr

特性：

使用示例：

引用计数：

循环引用：

3. std::weak_ptr

特性：

使用示例：

4. 总结

文件流

1. ifstream（输入文件流）

示例：使用 ifstream 读取文件内容

ifstream 常用成员函数：

2. ofstream（输出文件流）

示例：使用 ofstream 写入文件内容

ofstream 常用成员函数：

3. fstream（文件流）

示例：使用 fstream 进行读写操作

fstream 常用成员函数：

文件操作模式

示例：使用不同的文件模式

错误处理和流状态

错误处理示例：

总结

重定向（指定输入来源或输出去向）

解释：

在你的例子中：

作用：

示例代码：

使用场景：

注意事项：

示例代码中的错误处理：

总结：

异常处理

1. 异常的基本概念

2. 异常处理的关键字

2.1 try 块

2.2 throw 关键字

2.3 catch 块

3. 异常传递与处理过程

4. 自定义异常类型

5. 异常处理中的资源管理

6. 异常规范（Exception Specification）

7. 异常安全

8. 总结

标准库中的异常类

1. std::exception

2. std::runtime_error

3. std::logic_error

4. std::bad_alloc

5. std::out_of_range

6. std::overflow_error 和 std::underflow_error

7. std::ios_base::failure

8. std::bad_cast 和 std::bad_typeid

9. 总结

1. `std::unique_ptr`

2. `std::shared_ptr`

3. `std::weak_ptr`

1. `ifstream`（输入文件流）

示例：使用 `ifstream` 读取文件内容

`ifstream` 常用成员函数：

2. `ofstream`（输出文件流）

示例：使用 `ofstream` 写入文件内容

`ofstream` 常用成员函数：

3. `fstream`（文件流）

示例：使用 `fstream` 进行读写操作

`fstream` 常用成员函数：

2.1 `try` 块

2.2 `throw` 关键字

2.3 `catch` 块

1. `std::exception`

2. `std::runtime_error`

3. `std::logic_error`

4. `std::bad_alloc`

5. `std::out_of_range`

6. `std::overflow_error` 和 `std::underflow_error`

7. `std::ios_base::failure`

8. `std::bad_cast` 和 `std::bad_typeid`