C++ 3.编程风格-RAII (资源获取即初始化)

系列文章目录

点击直达——文章总目录

Overview

1.编程风格-RAII (资源获取即初始化)

在 C++ 中，“资源获取即初始化”（Resource Acquisition Is Initialization，RAII）是一种管理资源如内存、文件描述符、互斥锁等的编程技术。RAII 通过将资源的生命周期绑定到对象的生命周期来确保资源的正确获取和释放，从而避免资源泄漏和其他错误。

1.1.核心概念

  1. 资源绑定到对象：在对象构造时获取资源，在对象析构时释放资源。
  2. 对象生命周期管理：对象的创建和销毁通常由作用域管理，当对象离开作用域时自动调用其析构函数。

1.2.RAII 的优势

  • 自动资源管理：自动获取和释放资源，减少遗漏。
  • 异常安全：即使在抛出异常时，也能确保资源正确释放。
  • 代码清晰：使资源管理逻辑更加明确和集中。

1.3.实现 RAII

1.3.1. 智能指针

智能指针如 std::unique_ptr 和 std::shared_ptr 是 RAII 的典型应用，它们在构造时分配内存，在析构时释放内存。

#include 
#include 

void useUniquePtr() {
    std::unique_ptr<int> uniquePtr(new int(42));
    std::cout << *uniquePtr << std::endl;
    // uniquePtr 离开作用域，自动释放内存
}

int main() {
    useUniquePtr();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
1.3.2. 文件处理

使用文件流（如 std::ifstream、std::ofstream）时，文件在构造时打开，在析构时关闭。

#include 
#include 

void writeFile() {
    std::ofstream outFile("example.txt");
    if (outFile.is_open()) {
        outFile << "Hello, world!" << std::endl;
        // outFile 离开作用域，文件自动关闭
    }
}

int main() {
    writeFile();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
1.3.3. 互斥锁

使用 std::lock_guard 或 std::unique_lock 管理互斥锁的锁定和解锁。

#include 
#include 
#include 

std::mutex mtx;
int shared_data = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++shared_data; // 锁定互斥体，离开作用域时自动解锁
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << shared_data << std::endl;
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

1.4.注意事项

  • 避免早期返回：在 RAII 对象的构造和资源的获取之间提前返回，会导致资源未被正确初始化。
  • 复制和赋值：默认的复制和赋值操作可能导致资源管理问题，通常需要自定义拷贝构造函数和拷贝赋值操作符。
  • 异常处理：构造函数中应避免抛出异常，或者确保在抛出异常时已经获取的资源能够被正确释放。

RAII 是现代 C++ 编程的核心理念之一，正确使用 RAII 可以显著提高代码的安全性和可维护性。

2.如何使用 RAII 原则来管理 C++ 中的文件流？

在 C++ 中，使用 RAII 原则管理文件流是一种非常普遍的做法。RAII 通过将资源（在这种情况下是文件）的生命周期与对象（这里是文件流对象）的生命周期绑定，确保文件在不再需要时能够被正确关闭。

2.1.使用 std::fstream、std::ifstream 和 std::ofstream

C++ 标准库提供了几种文件流类来处理文件 I/O，包括 std::fstream（可同时进行读和写操作）、std::ifstream（只读）和 std::ofstream（只写）。这些类在构造函数中打开文件，在析构函数中关闭文件。

2.1.1.示例：使用 std::ifstream 读取文件
#include 
#include 
#include 

void readFile(const std::string& filename) {
    std::ifstream file(filename);  // 文件在构造时打开
    if (!file) {
        std::cerr << "Failed to open " << filename << std::endl;
        return;
    }

    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << std::endl;
    }

    // 文件在 file 对象离开作用域时自动关闭
}

int main() {
    readFile("example.txt");
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

在这个示例中，std::ifstream 对象 file 在创建时尝试打开指定的文件。当 file 对象超出作用域并被销毁时，文件自动关闭。

2.1.2.示例：使用 std::ofstream 写入文件
#include 
#include 
#include 

void writeFile(const std::string& filename) {
    std::ofstream file(filename);  // 文件在构造时打开
    if (!file) {
        std::cerr << "Failed to open " << filename << std::endl;
        return;
    }

    file << "Hello, world!\n";
    file << "This is a test file.\n";

    // 文件在 file 对象离开作用域时自动关闭
}

int main() {
    writeFile("example.txt");
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

在这个示例中，std::ofstream 对象 file 在创建时尝试打开指定的文件以写入。当 file 对象超出作用域并被销毁时，文件自动关闭。

2.3.注意事项

  1. 检查文件打开状态：在进行文件操作之前，应检查文件是否成功打开。
  2. 异常安全：文件流的异常安全性意味着即使在写入文件时发生异常，文件流的析构函数也会被调用，从而关闭文件。
  3. 文件打开模式：可以指定文件打开模式（如追加模式、二进制模式等），这在构造文件流对象时通过成员函数设置。
  4. 避免早期返回：如果在文件操作中早期返回，应确保文件已正确关闭或传递给其他管理责任。

通过将文件流对象的作用域限制在需要文件操作的代码块内，可以确保文件在使用完成后立即关闭，从而避免资源泄漏和其他潜在问题。

3.在C++中，除了智能指针，还有哪些RAII技术可以用于资源管理？

在 C++ 中，RAII（Resource Acquisition Is Initialization）是一种编程习惯，用于确保资源的正确管理。除了智能指针，还有很多其他的 RAII 技术可以用于资源管理。以下是一些常见的 RAII 应用：

  1. 文件和 I/O 流：

    • std::fstream、std::ifstream、std::ofstream：在构造时打开文件，在析构时关闭文件。

  2. 互斥锁：

    • std::lock_guard、std::unique_lock：在构造时自动获取互斥锁，在析构时自动释放互斥锁。

  3. 线程：

    • std::thread：在构造时创建线程，在析构时如果线程还在运行则加入（join）它。

  4. 线程同步原语：

    • std::condition_variable：通常与互斥锁一起使用，但在其等待（wait）函数中会原子性地释放互斥锁，并在条件满足时重新获取。

  5. 动态内存：

    • 自定义分配器类，通过构造函数分配内存，在析构函数中释放。

  6. 网络连接：

    • 套接字类：在构造时建立连接，在析构时关闭连接。

  7. 数据库连接：

    • 数据库连接类：在构造时打开数据库连接，在析构时关闭连接。

  8. 操作系统资源：

    • std::unique_ptr、std::shared_ptr 可以用于管理如动态分配的数组、系统句柄等资源。

  9. 事件和计时器：

    • 封装了事件或计时器的类：在构造时创建，在析构时销毁或取消。

  10. 互斥锁的高级封装：

    • std::mutex、std::recursive_mutex：通常与锁哨兵一起使用，但也可以封装在类中以提供 RAII 机制。

  11. 日志对象：

    • 日志器类：在构造时打开日志文件或准备日志缓冲区，在析构时刷新并关闭日志文件。

  12. Windows句柄：

    • 封装了 Windows API 句柄的类：在析构时自动调用 CloseHandle。

  13. OpenGL资源：

    • 封装了 OpenGL 资源（如纹理、缓冲区、着色器）的类：在析构时自动调用相应的 OpenGL 删除函数。

  14. COM对象：

    • 封装了 COM 对象的类：在析构时调用 Release 方法。

  15. 临时文件和目录：

    • 创建临时文件或目录的类：在析构时自动删除临时文件或目录。

通过将资源封装在对象中，并在对象的生命周期结束时释放资源，RAII 帮助开发者编写更安全、更清晰的代码。记住，RAII 原则可以应用于任何需要在特定时间点释放资源的场景。

4.RAII原则在多线程编程中如何应用，以避免死锁和资源竞争？

RAII（Resource Acquisition Is Initialization）原则是一种在C++中管理资源的编程技术，它通过将资源的获取放在对象的构造函数中，将资源的释放放在对象的析构函数中，从而确保资源在对象生命周期结束时自动释放。在多线程编程中，RAII原则同样适用，并且可以帮助避免死锁和资源竞争的问题。

在多线程环境中，RAII原则通常通过使用如 std::lock_guard、std::unique_lock 等互斥锁管理类来实现。这些类在构造时自动获取互斥锁，并在析构时自动释放互斥锁，这样就不需要手动调用锁的获取和释放函数，减少了因忘记释放锁而导致的死锁风险。

例如，使用 std::lock_guard 可以确保即使在抛出异常的情况下，互斥锁也能被正确释放：

std::mutex m;
void safeFunction() {
    std::lock_guard<std::mutex> lk(m);
    // 临界区代码
    // 如果函数提前返回或抛出异常，lk 的析构函数会自动调用，互斥锁会被释放
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在多线程环境中，避免死锁的一个常见策略是确保所有线程获取锁的顺序一致。RAII原则通过保证锁的释放与对象的生命周期绑定，有助于减少因锁顺序不当造成的死锁。

此外，RAII原则也可以用来管理其他类型的资源，如数据库连接、网络连接、文件句柄等。通过封装资源的获取和释放操作，RAII原则使得代码更加安全和易于维护。

在实际应用中，RAII原则可以帮助开发者编写出更健壮、更易于维护的多线程程序，因为它减少了资源管理的复杂性，并提供了一种自动且一致的方式来处理资源的生命周期。

5.RAII原则在C++中具体是如何实现的，能否给出一个简单的示例？

RAII原则在C++中是通过对象的生命周期来管理资源的。当一个对象被创建时，它的构造函数会执行资源的获取（如分配内存、打开文件、获取锁等），当对象的生命周期结束时，它的析构函数会执行资源的释放操作。这样，即使在发生异常的情况下，资源也能得到正确的释放。

下面是一个简单的RAII示例，展示了如何使用RAII原则来管理文件资源：

#include 
#include 

// 文件类，使用RAII管理文件打开和关闭
class File {
public:
    // 构造函数打开文件
    explicit File(const char* filename) {
        file_.open(filename, std::ios::in);
        if (!file_.is_open()) {
            throw std::runtime_error("Could not open file.");
        }
    }

    // 析构函数关闭文件
    ~File() {
        if (file_.is_open()) {
            file_.close();
        }
    }

    // 禁止复制构造函数和赋值运算符
    File(const File&) = delete;
    File& operator=(const File&) = delete;

    // 允许移动构造函数和赋值运算符
    File(File&& other) noexcept : file_(std::move(other.file_)) {
        other.file_.clear(); // 清除原对象的状态
    }
    File& operator=(File&& other) noexcept {
        if (this != &other) {
            file_ = std::move(other.file_);
            other.file_.clear();
        }
        return *this;
    }

    // 读取文件内容
    std::string getContents() {
        std::string content;
        if (file_.is_open()) {
            std::string line;
            while (std::getline(file_, line)) {
                content += line + "\n";
            }
        }
        return content;
    }

private:
    std::ifstream file_;
};

int main() {
    try {
        File myFile("example.txt");
        std::cout << "File contents:\n" << myFile.getContents();
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

在这个示例中，File 类封装了文件的打开和关闭操作。构造函数尝试打开一个文件，如果文件打开失败，则抛出异常。析构函数确保文件在对象生命周期结束时被关闭，无论是因为程序正常结束还是因为异常。

此外，我们还禁用了复制构造函数和赋值运算符，以防止文件对象被复制，因为复制文件句柄是没有意义的。同时，我们提供了移动构造函数和移动赋值运算符，以支持资源的安全转移。

使用RAII原则的好处是，即使在 main 函数中发生异常，File 对象 myFile 的析构函数也会被调用，从而确保文件被正确关闭。这减少了资源泄漏的风险，并使代码更加安全和可靠。

6.在C++中，除了使用类来管理资源，还有其他方法可以应用RAII原则吗？

在C++中，除了使用类来管理资源外，还可以通过使用智能指针和标准库中的其他RAII类来应用RAII原则。以下是一些常见的方法：

  1. 智能指针：std::unique_ptr、std::shared_ptr、std::weak_ptr 等智能指针类在对象生命周期结束时自动释放动态分配的内存。

    #include 

void function() {
    std::unique_ptr<int> ptr(new int(10));
    // 不需要手动delete，ptr在离开作用域时自动释放内存
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

  2. 标准库中的RAII类：例如 std::lock_guard、std::unique_lock、std::thread、std::ifstream 等。

    #include 
#include 

std::mutex mtx;
void function() {
    std::lock_guard<std::mutex> lock(mtx);
    // lock在离开作用域时自动释放互斥锁

    std::ifstream file("example.txt");
    // file在离开作用域时自动关闭文件
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

  3. 自定义RAII类：可以创建自定义的RAII类来管理任何类型的资源，如数据库连接、网络连接、文件描述符等。

    class Resource {
public:
    Resource() { acquire(); }
    ~Resource() { release(); }
    void acquire() { /* 资源获取逻辑 */ }
    void release() { /* 资源释放逻辑 */ }
};

void function() {
    Resource res;
    // res在离开作用域时自动调用~Resource()释放资源
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

  4. 函数对象：可以创建一个函数对象（也称为仿函数或functor），它在构造时获取资源，在析构时释放资源。

    struct ResourceHolder {
    ResourceHolder() { acquire(); }
    ~ResourceHolder() { release(); }
    void acquire() { /* 资源获取逻辑 */ }
    void release() { /* 资源释放逻辑 */ }
};

void function() {
    ResourceHolder resHolder;
    // resHolder在离开作用域时自动调用~ResourceHolder()释放资源
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

  5. lambda表达式：在C++11及更高版本中，可以在lambda表达式中捕获对象，并利用它们的作用域来管理资源。

    auto myLambda = []() {
    std::lock_guard<std::mutex> lock(mtx);
    // 执行需要互斥锁保护的操作
};
myLambda(); // lock在myLambda执行完毕后自动释放
    • 1
    • 2
    • 3
    • 4
    • 5

  6. 结构化绑定：在C++17中，可以使用结构化绑定来创建RAII对象。

    auto [lock] = std::make_tuple(std::lock_guard<std::mutex>(mtx));
// lock在离开作用域时自动释放互斥锁
    • 1
    • 2

RAII原则的核心思想是将资源的生命周期与对象的生命周期绑定，这样资源的释放就变得自动和异常安全。通过这种方式，可以减少资源泄漏和其他错误的风险。

7.如何确保在C++中使用RAII原则时，资源释放的顺序是正确的？

在C++中使用RAII原则时，确保资源释放顺序的正确性是非常重要的，因为错误的释放顺序可能会导致资源泄漏、程序崩溃或其他不可预知的行为。以下是一些确保资源释放顺序正确的方法：

  1. 局部作用域：确保每个资源的获取和释放都在同一个局部作用域内。当作用域结束时，对象的析构函数会被调用，资源会被自动释放。

    void function() {
    {
        Lock lock(mutex); // Lock是一个RAII类
        // 临界区代码
    } // Lock对象离开作用域，自动释放互斥锁

    {
        File file("example.txt"); // File是一个RAII类
        // 使用文件
    } // File对象离开作用域，自动关闭文件
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

  2. 对象的声明顺序：在同一个作用域内，先声明的资源应该后释放，后声明的资源应该先释放。这样可以避免在释放一个资源时依赖另一个还未释放的资源。

    void function() {
    Lock lock(mutex); // 先获取互斥锁
    File file("example.txt"); // 后打开文件
    // 使用文件
} // 文件先关闭，然后互斥锁释放
    • 1
    • 2
    • 3
    • 4
    • 5

  3. 使用智能指针：智能指针如 std::unique_ptr 和 std::shared_ptr 管理动态分配的内存。它们在对象离开作用域时自动释放内存。

    void function() {
    std::unique_ptr<Resource> resource(new Resource());
    // 使用资源
} // resource离开作用域，自动释放资源
    • 1
    • 2
    • 3
    • 4

  4. 避免循环依赖：确保资源之间没有循环依赖，这可能导致无法确定释放顺序。

  5. 使用依赖注入：通过将资源作为参数传递给需要它们的函数，可以避免在函数内部创建资源，从而更容易控制资源的释放顺序。

    void function(Lock& lock, File& file) {
    // 使用互斥锁和文件
} // 释放顺序由外部控制
    • 1
    • 2
    • 3

  6. 使用RAII包装器：对于不是通过RAII管理的资源，可以创建RAII包装器来管理它们的生命周期。

    class Handle {
public:
    Handle(HANDLE handle) : handle_(handle) {}
    ~Handle() {
        if (handle_ != INVALID_HANDLE_VALUE) {
            CloseHandle(handle_);
        }
    }
private:
    HANDLE handle_;
};

void function() {
    Handle handle(CreateFile(...));
    // 使用文件句柄
} // Handle对象离开作用域，自动关闭句柄
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

  7. 避免在析构函数中抛出异常：析构函数中不应该抛出异常，因为这可能会导致资源释放的顺序被打乱。如果必须在析构函数中执行可能抛出异常的操作，应该使用异常捕获来确保资源仍然被释放。

    ~Resource() {
    try {
        release();
    } catch (...) {
        // 处理异常，但不抛出
    }
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

  8. 使用std::tuple或std::pair：当需要同时管理多个资源时，可以使用 std::tuple 或 std::pair 来存储多个RAII对象，它们会按照声明的相反顺序释放资源。

    void function() {
    std::tuple<Lock, File> resources(mutex, "example.txt");
    // 使用互斥锁和文件
} // File先关闭，然后Lock释放互斥锁
    • 1
    • 2
    • 3
    • 4

通过遵循这些准则，可以确保在C++中使用RAII原则时资源释放的顺序是正确的。

8.如何使用RAII原则来避免C++中的内存泄漏问题？

RAII原则是C++中避免内存泄漏的一种非常有效的方法。它通过将资源管理与对象生命周期绑定，确保资源在不再需要时自动释放。以下是一些使用RAII原则来避免内存泄漏的策略：

  1. 使用智能指针：智能指针如 std::unique_ptr、std::shared_ptr 和 std::weak_ptr 可以自动管理动态分配的内存。当智能指针超出作用域时，它们会自动释放所管理的内存。

    #include 

void function() {
    std::unique_ptr<int> ptr(new int(10));
    // 不需要手动delete，ptr在离开作用域时自动释放内存
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

  2. 封装资源管理：创建类来封装资源管理，如文件、数据库连接、网络套接字等。在类的构造函数中获取资源，在析构函数中释放资源。

    class File {
public:
    explicit File(const std::string& filename) {
        file_.open(filename, std::ios::in);
        if (!file_.is_open()) {
            throw std::runtime_error("Could not open file.");
        }
    }

    ~File() {
        if (file_.is_open()) {
            file_.close();
        }
    }

    // 禁止复制和赋值
    File(const File&) = delete;
    File& operator=(const File&) = delete;

    // 允许移动
    File(File&& other) noexcept : file_(std::move(other.file_)) {
        other.file_.clear();
    }
    File& operator=(File&& other) noexcept {
        if (this != &other) {
            file_ = std::move(other.file_);
            other.file_.clear();
        }
        return *this;
    }

private:
    std::ifstream file_;
};

void processFile(const std::string& filename) {
    File file(filename);
    // 使用文件
} // 文件在离开作用域时自动关闭
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

  3. 使用RAII类管理其他资源：除了内存和文件，还可以使用RAII类来管理其他资源，如互斥锁、线程、网络连接等。

    #include 

class Lock {
public:
    explicit Lock(std::mutex& m) : mutex_(m) { mutex_.lock(); }
    ~Lock() { mutex_.unlock(); }
private:
    std::mutex& mutex_;
};

void criticalSection() {
    std::mutex mtx;
    Lock lock(mtx);
    // 临界区代码
} // Lock对象离开作用域，自动释放互斥锁
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

  4. 避免裸指针：尽可能避免使用裸指针进行动态内存管理。如果必须使用裸指针，确保手动管理内存的分配和释放，并考虑使用智能指针作为替代。

  5. 使用容器管理对象：标准库容器如 std::vector、std::map 等会自动管理它们所包含对象的内存。当容器超出作用域时，它们会自动释放所有元素的内存。

    void processElements() {
    std::vector<std::unique_ptr<Element>> elements;
    // 添加元素到容器
} // 容器离开作用域，所有元素的内存自动释放
    • 1
    • 2
    • 3
    • 4

  6. 使用智能指针作为函数参数和返回值：在函数参数和返回值中使用智能指针，可以避免在函数调用中传递裸指针，从而减少内存泄漏的风险。

    std::unique_ptr<Element> createElement() {
    return std::make_unique<Element>();
}

void processElement(std::unique_ptr<Element> element) {
    // 使用元素
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

  7. 使用工具检测内存泄漏：使用如 Valgrind、AddressSanitizer 等内存检查工具来检测程序中的内存泄漏。

通过这些方法，可以有效地使用RAII原则来避免C++中的内存泄漏问题，提高程序的稳定性和可靠性。

关于作者

WeSiGJ
微信公众号
共同分享，共同交流， 共同学习!
注：本文转载自blog.csdn.net的WeSiGJ的文章"https://wesigj.blog.csdn.net/article/details/143417876"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！