C++11 异常

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量898 收藏 26
点赞数 11
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxk2227814847/article/details/140959923
版权

目录

0.前言

1.C语言传统错误处理方式

1.1使用返回值

1.2使用全局变量

1.3使用断言

1.4优缺点

2.C++异常的概念

3.异常的使用

3.1异常的抛出和捕获

3.1.1异常的抛出和匹配原则

3.1.2在函数调用链中异常栈展开匹配原则

3.2异常的重新抛出

3.3异常安全

3.4异常规范

4.自定义异常体系

5.C++标准库的异常体系

5.1标准库异常类的层次结构

5.2使用标准库异常类的优点

6.异常的优缺点

6.1C++异常的优点

6.2C++异常的缺点

7.结语

（图像由AI生成） 

0.前言

在软件开发过程中，错误处理是不可避免的。有效的错误处理机制不仅能提高程序的健壮性，还能使代码更易于维护。C++11引入了强大的异常处理机制，使得程序员可以更优雅地处理异常情况。本文将详细介绍C++11中的异常处理机制，帮助读者更好地理解和应用这一特性。

1.C语言传统错误处理方式

在C语言中，错误处理主要通过返回值和错误码来实现。C语言没有内置的异常处理机制，因此程序员需要手动检查和处理每个可能出现的错误。以下是一些常见的错误处理方式：

1.1使用返回值

函数可以通过返回值来指示操作是否成功。如果操作失败，函数通常返回一个特定的错误码。调用者需要检查返回值并采取相应的措施。

#include <stdio.h>

int divide(int a, int b, int *result) {
    if (b == 0) {
        return -1; // 返回错误码
    }
    *result = a / b;
    return 0; // 成功
}

int main() {
    int res;
    if (divide(10, 2, &res) == 0) {
        printf("Result: %d\n", res);
    } else {
        printf("Error: Division by zero\n");
    }
    return 0;
}

在上面的例子中，divide函数返回一个错误码，如果除数为零，则返回-1表示错误。调用者通过检查返回值来确定是否发生了错误。

1.2使用全局变量

另一种方法是使用全局变量来存储错误码，例如errno。这是C标准库提供的一个全局变量，用于表示最近一次函数调用中的错误代码。

#include <stdio.h>
#include <errno.h>

int divide(int a, int b, int *result) {
    if (b == 0) {
        errno = EINVAL; // 设置错误码
        return -1;
    }
    *result = a / b;
    return 0;
}

int main() {
    int res;
    if (divide(10, 0, &res) == 0) {
        printf("Result: %d\n", res);
    } else {
        perror("Error"); // 打印错误信息
    }
    return 0;
}

在这个例子中，当除数为零时，divide函数设置全局变量errno并返回错误。调用者使用perror函数打印错误信息，该函数会根据errno的值输出相应的错误描述。

1.3使用断言

对于某些情况下的错误处理，可以使用assert宏来检查程序中的假设。如果条件为假，程序会打印错误信息并中止执行。这种方法通常用于开发和调试阶段。

#include <assert.h>

int divide(int a, int b) {
    assert(b != 0); // 检查条件
    return a / b;
}

int main() {
    int result = divide(10, 2);
    printf("Result: %d\n", result);
    return 0;
}

1.4优缺点

使用返回值和错误码进行错误处理有以下优缺点：

优点：

  • 简单直观，易于理解和实现。
  • 无需额外的语言支持，可以在任何C编译器上使用。

缺点：

  • 错误码难以统一，容易引起混淆。
  • 需要额外的代码来检查错误码，增加了代码的复杂度。
  • 忽略错误检查可能导致程序运行错误。
  • 错误处理分散在各个函数调用处，不利于维护和调试。

2.C++异常的概念

异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

  • throw: 当问题出现时，程序会抛出一个异常。这是通过使用throw关键字来完成的。
  • catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch关键字用于捕获异常，可以有多个catch进行捕获。
  • try: try块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个catch块。

如果有一个块抛出一个异常，捕获异常的方法会使用try和catch关键字。try块中放置可能抛出异常的代码，try块中的代码被称为保护代码。使用try/catch语句的语法如下所示：

try {
    // 保护的标识代码
} catch (ExceptionName e1) {
    // catch 块
} catch (ExceptionName e2) {
    // catch 块
} catch (ExceptionName eN) {
    // catch 块
}

在C++中，异常处理机制使得错误处理更加结构化和集中化。throw语句可以抛出任何类型的对象，通常是异常类的实例。标准库提供了多种异常类，可以直接使用，如std::exception, std::runtime_error, std::logic_error等。用户还可以自定义异常类，以适应特定需求。

以下是一个简单的例子：

#include <iostream>
#include <stdexcept>

void divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero");
    }
    std::cout << "Result: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0);
    } catch (const std::runtime_error &e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

在上面的例子中，如果除数为零，divide函数会抛出一个std::runtime_error异常。main函数中的try块捕获该异常，并输出错误信息。

3.异常的使用

3.1异常的抛出和捕获

3.1.1异常的抛出和匹配原则

  1. 抛出异常: 异常是通过抛出对象而引发的，该对象的类型决定了应激活哪个catch的处理代码。
  2. 选择处理代码: 被选中的处理代码是调用栈中与该对象类型匹配且位置最接近抛出异常位置的那一个。
  3. 异常对象的生成和销毁: 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
  4. catch(...): 可以捕获任意类型的异常，问题是不知道异常错误是什么。
  5. 基类捕获: 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出其派生类对象，使用基类捕获，这个在实际中非常实用。

3.1.2在函数调用链中异常栈展开匹配原则

  1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调用catch的地方进行处理。
  2. 如果没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch，不断重复上述过程。若到达main函数的栈，依旧没有匹配的，则终止程序。
  3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。
  4. 找到匹配的catch子句并处理以后，会继续沿catch子句后面继续执行。

在下面的示例中，有三个函数func1(), func2(), func3()。在func2()中调用func1(), func3()中调用func2(), main()中调用func3()。如果在func1()中抛出一个异常，在main()中用catch语句捕获。

void func1() {
    throw std::runtime_error("Error occurred");
}

void func2() {
    func1();
}

void func3() {
    func2();
}

int main() {
    try {
        func3();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught: " << e.what() << std::endl;
    }
    return 0;
}

栈展开过程如下：

  1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则处理。
  2. 如果没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch，不断重复上述过程。若到达main函数的栈，依旧没有匹配的，则终止程序。
  3. 找到匹配的catch子句并处理以后，会继续沿catch子句后面继续执行。

通过这个过程，我们可以看到异常处理如何在调用链中展开，并最终被捕获和处理。

3.2异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

重新抛出异常可以使用throw关键字，这样可以将捕获的异常再抛出，以便在更高层次的catch块中处理。这种方法对于需要在多个层次上处理异常的情况非常有用。

以下是一个例子，展示了如何重新抛出异常：

#include <iostream>
#include <stdexcept>

// 第一级处理
void level1() {
    try {
        throw std::runtime_error("Error occurred at level 1");
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught in level1: " << e.what() << std::endl;
        // 重新抛出异常
        throw;
    }
}

// 第二级处理
void level2() {
    try {
        level1();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught in level2: " << e.what() << std::endl;
        // 再次重新抛出异常
        throw;
    }
}

// 第三级处理（最高层次）
int main() {
    try {
        level2();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught in main: " << e.what() << std::endl;
    }
    return 0;
}

输出：

Caught in level1: Error occurred at level 1
Caught in level2: Error occurred at level 1
Caught in main: Error occurred at level 1 

在这个例子中，异常首先在level1函数中被抛出并捕获。level1函数中的catch块捕获异常后，输出错误信息并重新抛出异常。接着，level2函数中的catch块捕获重新抛出的异常，输出错误信息后再次重新抛出。最后，main函数中的catch块捕获到来自level2的异常，并输出最终的错误信息。

这种方法确保了异常在不同的层次上得到处理，允许每个层次的代码对异常进行适当的处理和记录。

3.3异常安全

在编写C++代码时，异常安全性是一个非常重要的概念。它涉及确保程序在抛出异常时仍然保持一致的状态。实现异常安全性的方法主要包括以下几点：

  • 构造函数完成对象的构造和初始化: 最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化。

  • 析构函数主要完成资源的清理: 最好不要在析构函数内抛出异常，否则可能导致资源泄漏（例如内存泄漏、句柄未关闭等）。

C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏。在lock和unlock之间抛出了异常导致死锁。C++经常使用RAII（Resource Acquisition Is Initialization）来解决以上问题。RAII通过在对象的生命周期内绑定资源管理，以确保资源在对象销毁时被正确释放，从而避免资源泄漏和其他异常处理问题。

class Resource {
public:
    Resource() {
        // 构造函数中完成资源的分配和初始化
        resource_ = new int[100];
    }
    ~Resource() {
        // 析构函数中完成资源的释放
        delete[] resource_;
    }
private:
    int* resource_;
};

在这个示例中，Resource类的构造函数分配了资源，而析构函数负责释放资源，确保无论发生什么情况，资源都能得到正确的管理。

3.4异常规范

异常规范的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。在C++98中，可以在函数的后面加上throw(类型)，列出这个函数可能抛出的所有异常类型。C++11引入了noexcept来表示函数不抛出异常。

// 这里表示这个函数会抛出A, B, C, D中的某种类型的异常
void fun() throw(A, B, C, D);

// 这里表示这个函数会抛出bad_alloc的异常
void* operator new(std::size_t size) throw(std::bad_alloc);

// 这里表示这个函数不会抛出异常
void operator delete(void* ptr) throw();

// C++11中新增的noexcept，表示不会抛出异常
void thread() noexcept;
void thread(thread&&) noexcept;

在这个示例中，fun函数可能抛出多种类型的异常，而operator new函数可能抛出std::bad_alloc异常。operator delete函数和thread函数则明确表示它们不会抛出任何异常。

4.自定义异常体系

在实际应用中，很多公司都会自定义自己的异常体系进行规范的异常管理。这是因为在一个项目中，如果每个人都随意抛出异常，那么外层的调用者就基本无法处理这些异常，程序的健壮性和可维护性会大大降低。因此，实际中通常会定义一套继承的规范体系，这样大家抛出的都是继承的派生类对象，捕获时只需要捕获一个基类即可。

自定义异常类示例

通常，自定义异常体系的做法是创建一个基类，并从这个基类派生出不同类型的异常类。这样可以在一个统一的框架内处理不同类型的异常。

#include <iostream>
#include <exception>

// 自定义基类异常
class MyException : public std::exception {
public:
    virtual const char* what() const noexcept override {
        return "MyException occurred";
    }
};

// 派生类异常类型1
class MyExceptionType1 : public MyException {
public:
    const char* what() const noexcept override {
        return "MyExceptionType1 occurred";
    }
};

// 派生类异常类型2
class MyExceptionType2 : public MyException {
public:
    const char* what() const noexcept override {
        return "MyExceptionType2 occurred";
    }
};

// 使用自定义异常体系
void functionThatThrows() {
    throw MyExceptionType1();
}

int main() {
    try {
        functionThatThrows();
    } catch (const MyException& e) {
        std::cerr << "Caught: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，MyException是基类异常，MyExceptionType1和MyExceptionType2是从基类继承的派生类异常。通过这种方式，当发生异常时，调用者可以捕获基类MyException，从而处理所有类型的派生类异常。

这种异常体系的优点是结构清晰，扩展性强，便于管理和维护。在实际应用中，自定义异常体系有助于规范异常处理流程，提高代码的可读性和可靠性。 

5.C++标准库的异常体系

C++标准库提供了一套丰富的异常类体系，用于处理各种常见的错误情况。这些异常类大多数继承自std::exception基类，并根据不同的错误类型派生出多个子类。了解和使用这些标准异常类，可以使代码更具可读性和一致性。

5.1标准库异常类的层次结构

C++标准库的异常类层次结构如下：

  1. std::exception: 所有标准库异常的基类。它定义了一个虚函数what()，用于返回异常的描述信息。

  2. std::logic_error: 继承自std::exception，表示程序逻辑错误。常见的派生类包括：

    • std::invalid_argument: 表示无效参数。
    • std::domain_error: 表示参数超出定义域。
    • std::length_error: 表示长度错误。
    • std::out_of_range: 表示超出范围。

  3. std::runtime_error: 继承自std::exception，表示程序运行时错误。常见的派生类包括：

    • std::range_error: 表示范围错误。
    • std::overflow_error: 表示算术溢出错误。
    • std::underflow_error: 表示算术下溢错误。

以下是使用标准库异常类的示例：

#include <iostream>
#include <stdexcept>

void functionThatThrows() {
    throw std::invalid_argument("Invalid argument provided");
}

int main() {
    try {
        functionThatThrows();
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught std::invalid_argument: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught std::exception: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，functionThatThrows函数抛出了一个std::invalid_argument异常。在main函数中，使用try-catch块捕获该异常并输出相应的错误信息。

5.2使用标准库异常类的优点

  1. 一致性: 使用标准库异常类，可以使代码在处理异常时保持一致性，减少混乱和错误。
  2. 可读性: 标准库异常类名称直观，能够明确表达异常的含义，提高代码的可读性。
  3. 复用性: 标准库异常类经过充分测试和验证，具有高可靠性，减少了自定义异常类的工作量。

6.异常的优缺点

6.1C++异常的优点

  1. 精确定位错误: 异常处理机制可以清晰准确地展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样有助于更好地定位程序的bug。

  2. 简化错误处理流程: 使用返回值来传递错误信息在深层的函数调用链中会变得非常复杂。相比之下，异常处理机制可以直接将异常传递到最顶层的捕获块，无需逐层检查错误返回值。

    示例代码：

    int ConnectSql() {
    // 用户名密码错误
    if (...) 
        return 1;

    // 权限不足
    if (...) 
        return 2;
}

int ServerStart() {
    int ret = ConnectSql();
    if (ret < 0)
        return ret;

    int fd = socket();
    if (fd < 0)
        return errno;

    return 0;
}

int main() {
    int result = ServerStart();
    if (result < 0) {
        std::cerr << "Error: " << result << std::endl;
        return result;
    }
    // 其他逻辑
    return 0;
}

    使用异常处理机制后的代码：

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

void ConnectSql() {
    throw MyException();
}

void ServerStart() {
    ConnectSql();
}

int main() {
    try {
        ServerStart();
    } catch (const MyException& e) {
        std::cerr << "Caught: " << e.what() << std::endl;
    }
    // 其他逻辑
    return 0;
}

  3. 支持第三方库的异常处理: 很多第三方库（如Boost, GTest, GMock等）都使用异常来报告错误。使用这些库时，异常处理可以无缝衔接。

  4. 适合部分函数的错误处理: 一些函数（例如构造函数）没有返回值，因此无法使用错误码方式处理错误。使用异常可以解决这个问题。

6.2C++异常的缺点

  1. 执行流混乱: 异常会导致程序的执行流突然跳转，使代码的控制流变得复杂。这在调试和分析程序时会增加难度。

  2. 性能开销: 虽然在现代硬件上这个影响可以忽略不计，但异常处理机制确实会带来一定的性能开销。

  3. 资源管理复杂: C++没有垃圾回收机制，资源需要手动管理。如果异常处理不当，可能会导致资源泄漏和死锁等问题。这需要使用RAII（资源获取即初始化）模式来管理资源，但学习成本较高。

  4. 异常体系复杂: C++标准库的异常体系定义复杂且难以掌握，导致很多开发者选择自己定义异常体系，增加了代码的混乱度。

  5. 滥用异常: 不当的异常使用会导致代码难以维护和理解。因此，使用异常时需要遵循一定的规范：抛出异常类应继承自一个基类；尽量明确函数会抛出哪些异常。

总的来说，异常处理机制的优点远大于其缺点，因此在工程实践中我们鼓励使用异常处理。另外，面向对象的编程语言基本都支持异常处理，这也表明异常处理是一个发展趋势。通过正确使用异常处理机制，可以大大提高代码的健壮性和可维护性。

7.结语

C++11的异常处理机制为程序员提供了一种强大的工具，用于处理程序中的错误和异常。通过使用异常，我们可以实现更加清晰、结构化和易于维护的代码，显著提升程序的健壮性和可读性。尽管异常处理机制有其复杂性和潜在的性能开销，但其优势远远超过了这些缺点。掌握并合理使用C++11的异常处理机制，将使我们的开发工作更加高效和可靠。希望本文能帮助读者更好地理解和应用C++11的异常处理特性，从而编写出更优秀的程序。

康熙38bdc
关注
专栏目录
C++软件调试与异常排查从入门到精通系列文章汇总
dvlinker的技术专栏
06-29 17万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
引发C++软件异常的常见原因分析与总结（实战经验分享）
热门推荐
dvlinker的技术专栏
05-30 5万+
本文根据近几年排查C++软件异常的实践经历与实战经验，详细地总结出引发C++软件异常的常见原因，给大家提供一些借鉴和参考，以帮助大家快速地定位问题。
C++11异常处理 noexcept
zkreats的博客
01-20 1万+
1.简介在C语言中，当程序的运行出现异常、错误时，如果我们想为这些异常、错误提供解决方案时，我们面临许多问题，如： （1）C语言没有提供统一（标准）的方式来处理错误； （2）无法保证错误会被正确的处理； （3）错误的传播也无法控制，特别是在函数的嵌套调用时； … …当程序在运行时发生错误，使得程序的继续运行变得没有意义时，C++中的异常机制给我们提供了一个解决方法。2.C++03 异常处
C++11-＞异常
qq_55439426的博客
10-04 1676
无
异常规范 C++11
xkdlzy的专栏
04-23 9366
异常规范 C++11 noexcept throw
C++学习笔记10 异常
qq_35290457的博客
12-02 404
C++学习笔记10 1.异常处理 异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。 异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw。 throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。 catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。 try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 ca
C++异常
小白的逆袭
07-18 318
程序的错误大致可以分为三种，分别是语法错误、逻辑错误和运行时错误： 语法错误在编译和链接阶段就能发现，只有 100% 符合语法规则的代码才能生成可执行程序。语法错误是最容易发现、最容易定位、最容易排除的错误，程序员最不需要担心的就是这种错误。 逻辑错误是说我们编写的代码思路有问题，不能够达到最终的目标，这种错误可以通过调试来解决。 运行时错误是指程序在运行期间发生的错误，例如除数为 0、内存...
分析C++软件异常需要掌握的汇编知识汇总
dvlinker的技术专栏
05-14 2万+
本文详细地讲述排查C++软件异常时所要了解和掌握的一些汇编方面的基本知识与要点。
C++中异常处理的基本思想及throw语句抛出异常的使用
09-02
C++的异常处理机制是一种强大的错误处理方式，它允许程序在遇到异常情况时中断正常流程，转而执行特定的异常处理代码。这种机制的核心思想是将错误处理与正常逻辑分离，使得底层函数可以专注于功能实现，而将异常...
两例典型的C++软件异常排查实例分享
dvlinker的技术专栏
10-24 9117
两例典型的C++软件异常崩溃问题详细分析
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 128
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 479
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1068
💫往期文章👇：
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 887
set、map仿STL模拟实现
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 447
继续学习头文件的数学函数。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 741
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 260
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1038
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 441
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++异常处理深度解析
"一本关于C++异常处理的书籍，作者为Robert Schmidt，译者为无情。本书涵盖了C和C++中的异常处理机制，包括标准C++异常处理的基本语法和语义，异常安全，模板安全等内容，并探讨了如何混合使用C++异常和Visual C++的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值