解码C++基础——从C到C++

C++ 概述

C++ 是多范式编程语言，支持过程化编程、面向对象编程（OOP）和泛型编程，兼容 C 语言且增强了类型检查与功能特性。核心优势包括封装 / 继承 / 多态、模板与泛型编程、异常处理、标准模板库（STL）。

最简 C++ 程序与结构

#include <iostream>  // 包含C++标准输入输出头文件
using namespace std; // 导入std命名空间，简化符号使用

int main() {
    cout << "Hello World!" << endl; // 标准输出流输出字符串
    return 0; // 程序正常结束返回0
}

程序核心结构：

  • 头文件：提供函数 / 类的声明，C++ 标准头文件无.h后缀（如<iostream>），兼容 C 头文件（如<stdio.h>可写为<cstdio>）。
  • 命名空间：解决符号命名冲突，std是 C++ 标准库的命名空间。
  • main 函数：程序入口，返回int类型表示运行状态（0 为正常）。

名字空间（Namespace）

基本概念

名字空间是 C++ 中用于划分自定义作用域的机制，核心目的是解决大型程序开发中全局符号命名冲突问题（如不同库、模块间的变量、函数重名）。不同名字空间内的同名符号相互独立，互不干扰，能有效管理代码模块的边界。

定义与使用

定义名字空间

名字空间通过namespace关键字定义，内部可包含变量、函数、类、甚至嵌套名字空间等元素：

// 定义名字空间：数学工具模块
namespace mathUtils {
    int baseValue = 1;          // 基础数值（语义化命名）
    float calculateHalf(int inputNum) { // 计算输入值的一半
        return inputNum / 2.0f;
    }
}

访问名字空间符号

需通过 ** 作用域解析符::** 指定符号所属的名字空间，格式为名字空间名::符号名：

#include <iostream>// 头文件中声明名字空间符号（遵循声明-定义分离原则）
namespace mathUtils {
    extern int baseValue;
    extern float calculateHalf(int inputNum);
}

int main() {
    std::cout << mathUtils::baseValue << std::endl;        // 输出1
    std::cout << mathUtils::calculateHalf(8) << std::endl; // 输出4
    return 0;
}

using 语句（简化访问）

频繁使用名字空间名::符号名会增加代码冗余，可通过using语句简化访问：

导入整个名字空间

using namespace mathUtils; // 导入mathUtils中所有符号
int main() {
    std::cout << baseValue << std::endl;        // 直接访问baseValue
    std::cout << calculateHalf(8) << std::endl; // 直接访问calculateHalf
    return 0;
}

导入指定符号

避免导入全部符号导致的 “名字空间污染”（未使用的符号成为潜在冲突源）：

using mathUtils::baseValue;    // 仅导入baseValue
using mathUtils::calculateHalf;// 仅导入calculateHalf
int main() {
    std::cout << baseValue << std::endl;        // 合法
    std::cout << calculateHalf(8) << std::endl; // 合法
    return 0;
}

进阶语法

内嵌名字空间

名字空间支持嵌套定义，形成层级化的作用域结构，访问时需逐层指定：

namespace project { // 项目根名字空间
    int globalConfig = 1; // 全局配置值
    namespace calculateModule { // 计算模块子空间
        int localConfig = 2;  // 局部配置值
        int resultCode = 100; // 结果状态码
    }
}

int main() {
    std::cout << project::globalConfig << std::endl;                  // 输出1
    std::cout << project::calculateModule::localConfig << std::endl;  // 输出2
    std::cout << project::calculateModule::resultCode << std::endl;   // 输出100
    return 0;
}

名字空间的扩展性

同一名字空间可在不同位置补充定义，最终会合并为一个完整的作用域：

// 初始定义
namespace mathUtils {
    int baseValue = 1;
}
// 扩展定义（新增符号）
namespace mathUtils {
    int maxLimit = 666; // 新增最大值限制
}

int main() {
    std::cout << mathUtils::baseValue << std::endl; // 输出1（原有符号）
    std::cout << mathUtils::maxLimit << std::endl;  // 输出666（新增符号）
    return 0;
}

全局作用域

全局作用域是匿名的，若局部符号与全局符号重名，可通过::符号名访问全局符号：

int globalCounter = 100; // 全局计数器
int main() {
    int globalCounter = 200; // 局部计数器（覆盖全局）
    std::cout << globalCounter << std::endl;   // 输出200（局部）
    std::cout << ::globalCounter << std::endl; // 输出100（全局）
    return 0;
}

实战问题：名字冲突解决

问题场景：自定义函数与标准库函数重名（如max）。解决方案：将自定义函数放入独立名字空间，避免冲突：

#include <iostream>
namespace customMath { // 自定义数学工具空间
    int maxValue; // 存储最大值
    void findMax(float firstNum, float secondNum) { // 寻找两数最大值
        maxValue = firstNum > secondNum ? firstNum : secondNum;
    }
}

int main() {
    customMath::findMax(3.0f, 4.0f); // 明确调用自定义函数
    std::cout << customMath::maxValue << std::endl; // 输出4
    return 0;
}

输入输出流（cin/cout）

C++ 通过标准流对象实现输入输出，比 C 的scanf/printf更安全、易用。

核心流对象

  • cout：标准输出流，输出数据到控制台，支持自动类型推导。
  • cin：标准输入流，从控制台读取数据，自动匹配变量类型。
  • cerr：标准错误流，无缓冲区，直接输出错误信息（用法同cout）。

示例

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

int main() {
    int a;
    double b;
    string s;

    cout << "输入整数、浮点数、字符串：" << endl;
    cin >> a >> b >> s; // 一次性读取多种类型

    cout << "整数：" << a << endl;
    cout << "浮点数：" << b << endl;
    cout << "字符串：" << s << endl;

    cerr << "错误信息示例" << endl; // 错误输出
    return 0;
}

对比 C 输入输出

  • 类型安全：cin/cout自动匹配类型，scanf/printf需手动指定格式（易出错）。
  • 扩展性：cin/cout支持运算符重载（自定义类型可直接输出），scanf/printf需手动格式化。

数据类型与字符串

基础数据类型

C++ 兼容 C 的所有基础类型（char/short/int/long/float/double），新增bool类型（取值true/false）。

字符串类型（string）

C 语言用char[]/char*管理字符串（需手动处理内存），C++ 提供std::string（自动管理内存，支持动态扩容）。

#include <iostream>
#include <string> // 需包含string头文件
using std::cin;
using std::cout;
using std::string;
using std::endl;

int main() {
    string s1 = "Hello";
    string s2 = "World";
    string s3 = s1 + " " + s2; // 字符串拼接（运算符重载）

    cout << "拼接结果：" << s3 << endl; // 输出：Hello World
    cout << "长度：" << s3.size() << endl; // 输出：11
    cout << "子串：" << s3.substr(0, 5) << endl; // 输出：Hello

    // 比较字符串
    if (s1 == "Hello") {
        cout << "s1等于Hello" << endl;
    }
    return 0;
}

优势

  • 自动内存管理，避免缓冲区溢出（如 C 的strcpy风险）。
  • 支持运算符重载（+拼接、=赋值、==比较等）。

引用机制

概念

引用是已存在变量的别名，与原变量共享内存地址，操作引用等价于操作原变量。

语法与特性

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int& ref = a; // 定义引用，必须初始化（ref是a的别名）

    ref = 20; // 等价于a=20，a的值变为20
    cout << "a = " << a << endl; // 输出：a = 20
    cout << "ref = " << ref << endl; // 输出：ref = 20
    cout << "a的地址：" << &a << endl;
    cout << "ref的地址：" << &ref << endl; // 与a的地址相同

    // 引用不可重新绑定
    int b = 30;
    ref = b; // 这是赋值，不是重新绑定！a的值变为30，ref仍指向a
    cout << "a = " << a << endl; // 输出：a = 30
    return 0;
}

核心规则

  • 必须初始化：定义引用时必须绑定有效变量（int& ref;非法）。
  • 不可重新绑定：初始化后无法切换指向的变量。
  • 无独立内存：引用是别名，不占用额外内存（编译器优化为指针常量int* const）。
  • 无空引用：必须绑定有效对象（int& ref = NULL;非法）。

引用的应用

函数传参（避免拷贝，提升效率）

/**
 * 交换两个整数的函数
 * @brief 通过引用传参直接操作原变量，避免拷贝
 * @param a 第一个整数的引用
 * @param b 第二个整数的引用
 * @return void 无返回值
 */
void swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 5, y = 10;
    swap(x, y);
    cout << "x = " << x << ", y = " << y << endl; // 输出：x=10,y=5
    return 0;
}

函数返回值（返回全局 / 静态变量的引用）

/**
 * 返回静态变量的引用
 * @brief 静态变量生命周期与程序一致，返回引用安全
 * @return int& 静态变量A的引用
 */
int& getStaticVar() {
    static int A = 10; // 静态变量，存储在全局区
    return A;
}

int main() {
    int& ref = getStaticVar();
    ref = 20; // 修改静态变量的值
    cout << getStaticVar() << endl; // 输出：20
    return 0;
}

注意：避免返回局部变量的引用（局部变量在函数结束后销毁，引用变为 “悬空引用”）。

常量引用（只读访问，兼容临时对象）

/**
 * 打印字符串的函数
 * @brief 常量引用避免拷贝，且可绑定临时对象（如字面量）
 * @param s 字符串的常量引用（只读，不可修改）
 * @return void 无返回值
 */
void print(const string& s) {
    cout << s << endl;
}

int main() {
    print("Hello World"); // 常量引用可绑定临时字符串（合法）
    string str = "Test";
    print(str); // 也可绑定普通字符串
    return 0;
}

引用与指针对比

特性 引用 指针
初始化 必须初始化 可空或后续赋值
语法 无需*/-> 需*解引用、->访问成员
内存占用 无额外内存 占用内存（32 位 4B，64 位 8B）
安全性 无空引用风险 需检查空指针
多级访问 仅支持一级引用 支持多级指针（如int**）

类型转换

C++ 兼容 C 的旧式转换（如(int)f），新增新式类型转换（更安全、可读性更高）。

const_cast（去除 const/volatile 属性）

用途：仅用于指针或引用，去除其const/volatile限定。

#include <iostream>using namespace std;

int main() {
    const int a = 10;
    const int* p = &a;

    // 错误：p是常目标指针，无法修改指向的内容
    // *p = 20;

    // 使用const_cast去除const属性
    int* q = const_cast<int*>(p);
    *q = 20; // 现在可修改（注意：若a是真正的常量，可能触发未定义行为）
    cout << "a = " << a << endl; // 输出：a=20（a为普通const变量时生效）

    // 处理引用
    const int& ref = a;
    // ref = 30; // 错误
    const_cast<int&>(ref) = 30; // 合法
    cout << "a = " << a << endl; // 输出：a=30
    return 0;
}

注意：不能去除变量本身的const（如const int a=10;的a本质是常量，强制修改可能崩溃），仅能去除指针 / 引用的const属性。

static_cast（静态类型转换）

用途：用于兼容类型的转换（如数值类型、父类子类指针），编译期检查类型安全性。

#include <iostream>
using namespace std;

int main() {
    float f = 3.14;
    int i = static_cast<int>(f); // 浮点转整型（截断小数）
    cout << "i = " << i << endl; // 输出：i=3

    // 错误：不兼容类型转换，static_cast会报错（比旧式转换安全）
    // int* p = static_cast<int*>(&f);

    // 父类子类转换（上行转换安全）
    class Base {};
    class Derived : public Base {};
    Derived d;
    Base* b = static_cast<Base*>(&d); // 子类转父类（合法）
    return 0;
}

优势：比旧式转换更易识别，且能阻止不兼容类型的转换（如float*转int*）。

dynamic_cast（动态类型转换）

用途：仅用于类的继承体系，运行期检查类型（需类有虚函数），实现安全的下行转换（父类转子类）。

reinterpret_cast（重解释转换）

用途：强制转换任意类型的指针 / 引用（风险高，如int*转char*），仅用于底层操作。

关键字 auto

auto让编译器自动推导变量类型，简化代码（尤其适用于复杂类型）。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    auto a = 10; // 推导为int
    auto b = 3.14; // 推导为double
    auto c = "Hello"; // 推导为const char*

    vector<int> vec = {1,2,3};
    for (auto it = vec.begin(); it != vec.end(); ++it) { // it推导为vector<int>::iterator
        cout << *it << " ";
    }
    return 0;
}

注意：auto变量必须初始化（编译器需通过初始值推导类型）。

命名规范

C++ 无强制命名规范，但通用规则可提升代码可读性：

  • 类名 / 结构体名：大驼峰式（首字母大写），如AppleTree、Student。
  • 变量 / 函数名：小驼峰式（首字母小写），如studentName、calculateSum。
  • 常量名：全大写 + 下划线，如MAX_SIZE、PI。
  • 命名空间名：小写，如my_space。

函数特性

默认参数

函数参数可指定默认值，调用时若未传参则使用默认值。

/**
 * 计算圆锥体体积
 * @brief 高度默认值为1，半径必须传参
 * @param r 圆锥底部半径（无默认值）
 * @param h 圆锥高度（默认值1）
 * @return double 圆锥体积（公式：1/3 * π * r² * h）
 */
double coneVolume(double r, double h = 1.0) {
    const double PI = 3.1415926;
    return (1.0 / 3) * PI * r * r * h;
}

int main() {
    cout << "体积（h=默认）：" << coneVolume(2) << endl; // h=1，输出≈4.1888
    cout << "体积（h=3）：" << coneVolume(2, 3) << endl; // h=3，输出≈12.5664
    return 0;
}

规则：

  • 默认参数必须从右到左连续定义（int func(int a=1, int b);非法）。
  • 声明和定义中默认参数不可重复（声明写默认值，定义不写）。

占位参数

函数参数仅声明类型，无参数名，用于预留接口或兼容旧代码。

/**
 * 占位参数示例
 * @brief 第二个参数为占位符，调用时需传值但函数内无法使用
 * @param a 第一个参数（可用）
 * @param int 第二个参数（占位，无名称）
 * @return void 无返回值
 */
void func(int a, int) {
    cout << "a = " << a << endl;
}

int main() {
    func(10, 20); // 必须传第二个参数（20），但函数内无法访问
    return 0;
}

函数重载

同一作用域内，同名函数的参数类型 / 个数 / 顺序不同，可形成重载（编译器根据参数区分调用）。

合法重载情形

#include <iostream>using namespace std;

// 参数个数不同
void print(int a) {
    cout << "整数：" << a << endl;
}
void print(int a, int b) {
    cout << "两个整数：" << a << "," << b << endl;
}

// 参数类型不同
void print(double a) {
    cout << "浮点数：" << a << endl;
}

// 类方法const属性不同
class MyClass {
public:
    void show() { // 普通方法
        cout << "普通show()" << endl;
    }
    void show() const { // const方法（this指针为const）
        cout << "const show()" << endl;
    }
};

// 普通指针与常目标指针不同
void func(char* p) {
    cout << "普通指针：" << p << endl;
}
void func(const char* p) {
    cout << "常目标指针：" << p << endl;
}

int main() {
    print(10); // 调用print(int)
    print(3.14); // 调用print(double)
    print(10, 20); // 调用print(int,int)

    MyClass obj;
    const MyClass constObj;
    obj.show(); // 调用普通show()
    constObj.show(); // 调用const show()

    char* s = "test";
    const char* cs = "const test";
    func(s); // 调用func(char*)
    func(cs); // 调用func(const char*)
    return 0;
}

非法重载情形

  • 返回值不同：int func();与double func();无法重载。
  • static 修饰不同：static int func();与int func();无法重载。
  • 参数 const 修饰不同（非指针 / 引用）：void func(int a);与void func(const int a);无法重载（参数本质相同）。
  • 引用与值的歧义：void func(int a);与void func(int& a);调用func(10)时会二义性（10 是常量，无法绑定普通引用）。

堆内存管理

C 语言用malloc/free管理堆内存，C++ 提供new/delete（更安全，支持对象构造 / 析构）。

单个对象的 new/delete

#include <iostream>
using namespace std;

int main() {
    // 动态分配int类型内存，初始化为10
    int* p = new int(10); 
    cout << *p << endl; // 输出：10

    delete p; // 释放内存（必须配对，否则内存泄漏）
    p = nullptr; // 避免悬空指针

    // 动态分配对象
    class Test {
    public:
        Test() { cout << "Test构造" << endl; }
        ~Test() { cout << "Test析构" << endl; }
    };
    Test* t = new Test(); // 调用构造函数
    delete t; // 调用析构函数+释放内存
    return 0;
}

数组的 new []/delete []

int main() {
    // 动态分配int数组（5个元素）
    int* arr = new int[5]{1,2,3,4,5}; // C++11支持初始化
    for (int i=0; i<5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr; // 释放数组（必须用delete[]，否则仅释放第一个元素）
    arr = nullptr;
    return 0;
}

对比 malloc/free

  • new/delete是运算符，malloc/free是函数。
  • new自动调用构造函数，delete自动调用析构函数（malloc/free不支持）。
  • new返回对应类型指针（无需强制转换），malloc返回void*（需转换）。

枚举与范围 for 循环

枚举（enum/enum class）

普通枚举

enum Color {
    Red, // 默认0
    Green, // 1
    Blue // 2
};

int main() {
    Color c = Red;
    cout << c << endl; // 输出：0
    return 0;
}

强类型枚举（enum class）

C++11 新增，避免枚举值冲突，类型安全。

enum class Direction {
    Left,
    Right
};

int main() {
    Direction d = Direction::Left;
    // cout << d << endl; // 错误：强类型枚举不能直接输出
    cout << static_cast<int>(d) << endl; // 输出：0
    return 0;
}

范围 for 循环（C++11）

遍历数组、容器等可迭代对象，简化循环代码。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int arr[] = {1,2,3,4,5};
    // 遍历数组
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    vector<string> vec = {"a", "b", "c"};
    // 遍历vector（引用避免拷贝）
    for (auto& s : vec) {
        cout << s << " ";
    }
    cout << endl;
    return 0;
}

extern "C" 机制

C++ 支持调用 C 语言代码，需用extern "C"禁用 C++ 的名称修饰（Name Mangling），确保 C++ 编译器按 C 规则处理函数名。

// C语言头文件（c_func.h）
#ifdef __cplusplus
extern "C" { // 仅在C++编译器中生效
#endif

void c_function(int x); // C语言函数声明

#ifdef __cplusplus
}
#endif

// C语言实现（c_func.c）
#include "c_func.h"
#include <stdio.h>

void c_function(int x) {
    printf("C函数：x=%d\n", x);
}

// C++调用（main.cpp）
#include "c_func.h"
using namespace std;

int main() {
    c_function(10); // 调用C语言函数
    return 0;
}

原理：C++ 为支持函数重载，会修改函数名（如add(int)变为_Z3addi），而 C 语言不修饰函数名。extern "C"让 C++ 编译器按 C 规则生成函数名，保证链接成功。

内存分区

C++ 程序运行时内存分为 5 个区域：

内存分区 存储内容 生命周期 管理方式
栈区 局部变量、函数参数、返回地址 函数结束自动释放 编译器自动分配释放
堆区 new/malloc 分配的对象 手动 delete/free 释放 程序员手动管理
全局 / 静态区 全局变量、static 变量 程序启动分配，结束释放 编译器静态分配
常量区 字符串常量、const 全局常量 程序运行期间 只读，不可修改
代码区 二进制指令、函数体代码 程序运行期间 只读，共享内存

异常处理（Exception）

基本概念

异常是程序运行过程中出现的非正常情况（如除零错误、空指针访问、参数非法等）。C++ 通过 “抛出 - 捕获” 机制处理异常：throw抛出异常，try-catch捕获并处理，避免程序直接崩溃，提升鲁棒性。

异常的抛出与捕获

抛出异常（throw）

使用throw关键字抛出异常，可抛出任意类型（字面量、对象、标准异常类）：

/**
 * 除法函数：计算两数相除
 * @param dividend 被除数
 * @param divisor 除数
 * @return float 除法结果
 * @throw const char* 除数为0时抛出异常信息
 */
float divideNumbers(float dividend, float divisor) {
    if (divisor == 0) {
        throw "除数不能为零"; // 抛出字符串类型异常
    }
    return dividend / divisor;
}

捕获异常（try-catch）

  • try块：包裹可能抛出异常的代码；
  • catch块：按类型捕获异常并处理，可设置多个catch匹配不同类型；
  • catch(...)：捕获所有未匹配的异常（兜底处理）。
#include <iostream>
using namespace std;

int main() {
    float inputDividend, inputDivisor, calculateResult;
    while (true) {
        cin >> inputDividend >> inputDivisor;
        try {
            calculateResult = divideNumbers(inputDividend, inputDivisor);
            cout << calculateResult << endl;
        } catch (const char* errorMsg) { // 捕获字符串类型异常
            cout << "错误：" << errorMsg << endl;
            break;
        } catch (...) { // 捕获所有其他类型异常
            cout << "未知错误" << endl;
        }
    }
    return 0;
}

异常的类型

可通过不同类型区分异常场景，catch块按类型匹配执行：

#include <iostream>
#include <stdexcept> // 标准异常类头文件
using namespace std;

void checkInput(int inputNum) { // 检查输入值合法性
    if (inputNum == 1) throw 666;                // 整数错误码
    if (inputNum == 2) throw 3.14f;              // 浮点错误码
    if (inputNum == 3) throw runtime_error("参数超出合法范围"); // 标准异常类
}

int main() {
    int userInput;
    cin >> userInput;
    try {
        checkInput(userInput);
    } catch (int intErrorCode) { // 匹配整数类型异常
        cout << "整数错误：" << intErrorCode << endl;
    } catch (float floatErrorCode) { // 匹配浮点类型异常
        cout << "浮点错误：" << floatErrorCode << endl;
    } catch (runtime_error& standardError) { // 匹配标准异常类
        cout << "标准异常：" << standardError.what() << endl; // what()返回异常描述
    }
    return 0;
}

标准异常类

C++ 标准库提供了一系列异常类（继承自exception），常用的有：

  • invalid_argument：参数非法；
  • out_of_range：越界访问；
  • runtime_error：运行时错误；
  • logic_error：逻辑错误（如前置条件不满足）。

示例：使用标准异常类抛出异常

#include <iostream>
#include <stdexcept>
using namespace std;

float divideNumbers(float dividend, float divisor) {
    if (divisor == 0) {
        throw invalid_argument("除数不能为零（标准异常）"); // 抛出标准异常对象
    }
    return dividend / divisor;
}

int main() {
    try {
        divideNumbers(10, 0);
    } catch (invalid_argument& e) {
        cout << e.what() << endl; // 输出：除数不能为零（标准异常）
    }
    return 0;
}

异常与返回错误值的区别

特性 返回错误值 异常处理
传播性 需手动传递错误码（如返回值层层传递） 自动向上传播（直到被捕获）
强制性 易忽略（如未检查返回值） 必须处理（否则程序终止）
信息承载 仅支持基础类型（如 int 错误码） 支持类对象，可携带详细信息
代码可读性 错误处理与业务逻辑混杂 错误处理与业务逻辑分离

析构函数中的异常

析构函数抛出异常可能导致程序崩溃（如栈展开时触发双重异常），因此析构函数内需捕获所有异常：

#include <iostream>
using namespace std;

bool dbConnectionStatus = false; // 数据库连接状态
void closeDbConnection() { // 模拟关闭数据库连接
    if (!dbConnectionStatus) throw 100; // 连接未启用时抛异常
    else cout << "数据库连接正常关闭" << endl;
}

class DbConnector { // 管理数据库连接的类
    bool isClosed = false; // 是否已关闭
public:
    ~DbConnector() { // 析构函数自动关闭连接
        if (!isClosed) {
            try {
                closeDbConnection(); // 尝试关闭
            } catch (...) { // 捕获所有异常，避免崩溃
                cout << "析构时关闭数据库失败" << endl;
            }
        }
    }
    void manualCloseDb() { // 手动关闭（用户可处理异常）
        closeDbConnection();
        isClosed = true;
    }
};

int main() {
    DbConnector dbInstance;
    try {
        dbInstance.manualCloseDb(); // 手动关闭，主动处理异常
    } catch (...) {
        cout << "手动关闭失败，修复连接状态" << endl;
        dbConnectionStatus = true; // 修复状态
    }
    return 0;
}

Lambda 函数（匿名函数）

基本概念

Lambda 函数（匿名函数）是 C++11 引入的函数对象，可直接定义在代码中，无需显式命名，支持捕获外部变量、作为参数传递、作为返回值等特性。常用于简化代码（如一次性函数）、实现函数式编程。

语法结构

[capture list](parameter list) mutable -> return type { function body }
  • capture list（捕获列表）：指定捕获外部变量的方式（值捕获 / 引用捕获）；
  • parameter list（参数列表）：函数参数（同普通函数）；
  • mutable：允许修改值捕获的变量（默认值捕获为只读）；
  • return type（返回类型）：可省略，编译器自动推导；
  • function body（函数体）：业务逻辑代码。

捕获列表的用法

值捕获（[变量名]）

捕获外部变量的副本，Lambda 内部修改不影响外部变量：

#include <iostream>
using namespace std;

int main() {
    int firstNum = 1, secondNum = 2;
    // 值捕获firstNum和secondNum，计算两数之和
    auto sumTwoNumbers = [firstNum, secondNum]() {
        return firstNum + secondNum;
    };
    cout << sumTwoNumbers() << endl; // 输出3
    return 0;
}

引用捕获（[& 变量名]）

捕获外部变量的引用，Lambda 内部修改会影响外部变量：

int main() {
    int num = 10;
    // 引用捕获num，修改其值
    auto modifyNum = [&num]() {
        num *= 2;
    };
    modifyNum();
    cout << num << endl; // 输出20
    return 0;
}

捕获所有外部变量

  • [=]：值捕获所有外部变量；
  • [&]：引用捕获所有外部变量。
int main() {
    int a = 1, b = 2;
    // 值捕获所有外部变量
    auto printAll = [=]() {
        cout << "a=" << a << ", b=" << b << endl;
    };
    printAll(); // 输出：a=1, b=2

    // 引用捕获所有外部变量
    auto modifyAll = [&]() {
        a += b;
        b *= 2;
    };
    modifyAll();
    cout << "a=" << a << ", b=" << b << endl; // 输出：a=3, b=4
    return 0;
}

Lambda 函数的使用场景

作为函数参数

常用于 STL 算法（如sort、count_if），简化谓词逻辑：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> numVector = {3, 1, 4, 1, 5, 9};
    // 统计偶数个数：Lambda作为count_if的谓词参数
    int evenCount = count_if(numVector.begin(), numVector.end(),
        [](int currentNum) { // 参数由count_if自动传递
            return currentNum % 2 == 0;
        });
    cout << "偶数个数：" << evenCount << endl; // 输出2
    return 0;
}

作为函数返回值

Lambda 可作为函数返回值（需用auto推导类型）：

/**
 * 创建加法器：返回Lambda函数
 * @param fixedAddend 固定加数
 * @return auto 加法器（接收一个int参数，返回两数之和）
 */
auto createAdder(int fixedAddend) {
    return [fixedAddend](int variableAddend) {
        return fixedAddend + variableAddend;
    };
}

int main() {
    auto addFive = createAdder(5); // 生成“加5”的加法器
    cout << addFive(3) << endl;    // 输出8（5+3）
    cout << addFive(10) << endl;   // 输出15（5+10）
    return 0;
}

高阶函数调用

Lambda 作为参数传递给自定义高阶函数：

/**
 * 检查数字是否满足条件
 * @param targetNum 目标数字
 * @param checkCondition 检查条件（Lambda函数）
 */
void checkNumber(int targetNum, auto checkCondition) {
    if (checkCondition(targetNum)) {
        cout << targetNum << "满足条件" << endl;
    } else {
        cout << targetNum << "不满足条件" << endl;
    }
}

int main() {
    // 检查是否为奇数
    checkNumber(5, [](int num) {
        return num % 2 != 0;
    });
    // 检查是否大于10
    checkNumber(8, [](int num) {
        return num > 10;
    });
    return 0;
}

函数式编程简介

Lambda 是函数式编程的基础，函数式编程强调数据映射而非 “步骤指令”，核心特点：

  • 函数是一等公民（可作为参数、返回值）；
  • 避免可变状态，推崇纯函数（输入确定则输出确定）；

示例：函数式实现字符串翻转

#include <string>
using namespace std;

// 函数式：通过递归映射实现字符串翻转
string reverseString(const string& inputStr) {
    return inputStr.empty() ? inputStr : 
        reverseString(inputStr.substr(1)) + inputStr[0];
}

int main() {
    string str = "abcdef";
    cout << reverseString(str) << endl; // 输出：fedcba
    return 0;
}

Lambda 的注意事项

  • 捕获列表为空时，需写[]（不可省略）；
  • 值捕获的变量默认只读，需mutable才能修改；
  • Lambda 的生命周期与普通变量一致，捕获的外部变量若销毁，Lambda 访问会导致未定义行为。
posted @ 2025-12-01 20:45  YouEmbedded  阅读(0)  评论(0)    收藏  举报