C++中的引用和解引用，及在Lambda中的简单使用

沉夢志昂丶

已于 2024-05-31 10:42:58 修改

阅读量1.1k

点赞数 30

分类专栏： C++的自我救赎学习分享文章标签：算法 c++ 数据结构

于 2024-05-31 10:41:13 首次发布

本文链接：https://blog.csdn.net/GOLOJO/article/details/139345491

版权

分享同时被 3 个专栏收录

61 篇文章 0 订阅

订阅专栏

学习

59 篇文章 0 订阅

订阅专栏

C++的自我救赎

52 篇文章 2 订阅

订阅专栏

摘要

在C++中，引用（Reference）和解引用（Dereference）是两个非常重要的概念。结合lambda表达式使用，可以提高代码整体的灵活性和简洁性。

下面我将简单介绍引用和解引用的定义、用法、以及它们与lambda表达式的结合使用。

引用（Reference）

定义

引用是一个变量的别名。通过引用，可以直接操作原变量。引用在声明时使用符号 `&`。

int a = 10;
int &ref = a;  // ref 是 a 的引用

引用在初始化后不能更改其绑定对象，并且必须在声明时进行初始化。

用法

1. 函数参数：
使用引用作为函数参数可以避免复制大对象，提升效率。

void increment(int &x) {
    x++;
}

int main() {
    int a = 10;
    increment(a);  // 传递 a 的引用
    std::cout << a << std::endl;  // 输出 11
    return 0;
}

2. 返回引用：
函数可以返回引用，以便允许修改返回的对象。

int& getElement(int *arr, int index) {
    return arr[index];
}

int main() {
    int arr[3] = {1, 2, 3};
    getElement(arr, 1) = 10;  // 修改数组第二个元素
    std::cout << arr[1] << std::endl;  // 输出 10
    return 0;
}

3. 常量引用：
使用 `const` 修饰符声明常量引用，防止函数内部修改传入参数。

void printValue(const int &x) {
    std::cout << x << std::endl;
}

int main() {
    int a = 10;
    printValue(a);  // 传递 a 的常量引用
    return 0;
}

解引用（Dereference）

定义

解引用是通过指针访问指针所指向的对象。解引用使用符号 `*`。

int a = 10;
int *p = &a;  // p 是指向 a 的指针
int b = *p;  // 解引用 p，得到 a 的值

用法

1. 访问指针指向的值：
解引用指针，访问或修改指针所指向的变量。

int main() {
    int a = 10;
    int *p = &a;
    std::cout << *p << std::endl;  // 输出 10
    *p = 20;
    std::cout << a << std::endl;  // 输出 20
    return 0;
}

2. 指针和数组：
数组名是指向数组首元素的指针，解引用指针可以访问数组元素。

int main() {
    int arr[3] = {1, 2, 3};
    int *p = arr;
    std::cout << *(p + 1) << std::endl;  // 输出 2
    return 0;
}

3. 动态内存分配：
通过解引用指针访问动态分配的内存。

int main() {
    int *p = new int(10);  // 动态分配内存并初始化为 10
    std::cout << *p << std::endl;  // 输出 10
    delete p;  // 释放内存
    return 0;
}

Lambda表达式结合引用和解引用

Lambda表达式是C++11时期引入的匿名函数，可以用作捕获外部作用域的变量。引用和解引用在lambda表达式中有广泛的应用，我们来简单看一下。

引用结合Lambda表达式

通过引用捕获外部变量，可以在lambda内部修改外部变量。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    int x = 10;
    
    // 通过引用捕获 x
    auto lambdaRef = [&x]() {
        x *= 2;
    };
    
    lambdaRef();
    std::cout << "Value of x: " << x << std::endl;  // 输出 20
    
    return 0;
}

解引用结合Lambda表达式

通过解引用指针，可以在lambda表达式中操作指针指向的变量。

#include <iostream>

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

    // Lambda 表达式捕获指针并解引用
    auto lambdaDereference = [p]() {
        *p *= 2;
    };
    
    lambdaDereference();
    std::cout << "Value of a: " << a << std::endl;  // 输出 20

    return 0;
}

较为复杂的使用

下面将展示如何使用引用和解引用结合lambda表达式操作一个复杂的数据结构，例如一个二维数组（也可称为：矩阵）。

// 操作二维数组
#include <iostream>
#include <vector>

// 定义一个二维数组的类型
using Matrix = std::vector<std::vector<int>>;

// 打印矩阵
void printMatrix(const Matrix &matrix) {
    for (const auto &row : matrix) {
        for (const auto &elem : row) {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
}

// 使用引用和lambda表达式操作矩阵元素
void modifyMatrix(Matrix &matrix) {
    int multiplier = 2;
    
    // 遍历矩阵元素并修改
    for (auto &row : matrix) {
        for (auto &elem : row) {
            auto lambdaModify = [&elem, multiplier]() {
                elem *= multiplier;
            };
            lambdaModify();
        }
    }
}

int main() {
    Matrix matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    
    std::cout << "Original Matrix:" << std::endl;
    printMatrix(matrix);

    modifyMatrix(matrix);
    
    std::cout << "Modified Matrix:" << std::endl;
    printMatrix(matrix);

    return 0;
}