C语言零碎知识点之数据结构中的 *&

原创 已于 2023-04-09 22:06:46 修改 · 1w 阅读 · 245 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
C

当前文章被收录于：

C
7 篇文章 6 人学习
订阅专栏 查看详情
于 2022-02-21 22:28:17 首次发布
本文解析了C++中使用*&在函数参数中的作用，重点讲解了如何通过引用修改链表元素影响全局，以及不同指针传递方式的对比。学习了引用在数据结构操作中的实际运用和注意事项。

在数据结构中我们经常能够看到 *& 在函数的形参中，但却有些难以明白它的含义。因为那些代码都是伪代码，不是某一类编程语言的代码，通常是 C 和 C++ 的混用。

而 *& 是 C++ 中才能使用的，被称之为”引用“。如果使用的是纯 C 编译器，那么很可能无法通过编译。

由于我并不会 C++ 语言，所以下面只是说一下对它使用的理解，并且在数据结构的解题中尽量避免去使用到它。

注：下面代码经过 Dev-C++ 5.11 版本验证。

举例说明，我最开始想创建一个链表，代码如下：

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用头插法创建单链表
 * @param list 单链表
 * @param nums 待插入的数据数组
 * @param n 数组长度
 */
void createByHead(LNode *list, int nums[], int n) {
    // 创建链表的头节点
    list = (LNode *) malloc(sizeof(LNode));
    list->next = NULL;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的头部，但是在头结点的后面
        LNode *temp = list->next;
        newNode->next = temp;
        list->next = newNode;
    }
}

/**
 * 打印单链表中的所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode *list;
    int nums[] = {111, 222, 333, 444, 555};
    int n = 5;

    createByHead(list, nums, n);
    print(*list);
}

但运行不会打印任何结果，尽管我传递了一个指针变量。事实上我对指针的理解还是不够深刻。

上面的代码可能有些多了，看看简化后的情况，即我想要在函数 fun 内修改传入的形参 a 的值，并且在函数外也能访问到：

#include <stdio.h>
#include <malloc.h>

void fun(int *a) {
    a = (int *) malloc(sizeof(int));
    int b = 3;
    a = &b;
    printf("fun->a: %d\n", *a);
}

int main() {
    int *a;
    fun(a);
    printf("main->a: %d\n", *a);
}

代码指向结果如下：

fun->a: 3

--------------------------------
Process exited after 3.191 seconds with return value 3221225477
请按任意键继续. . .

即在函数 fun 外并不能访问到在函数 fun 内被修改的 a，即使它是一个指针变量。

事实上再次证明了我对 C 语言指针的认知浅薄。

如果我们把形参 int *a 变成 int *&a 呢？那么代码如下：

#include <stdio.h>
#include <malloc.h>

void fun(int *&a) {
    a = (int *) malloc(sizeof(int));
    int b = 3;
    a = &b;
    printf("fun->a: %d\n", *a);
}

int main() {
    int *a;
    fun(a);
    printf("main->a: %d\n", *a);
}

代码执行结果如下：

fun->a: 3
main->a: 3

--------------------------------
Process exited after 1.911 seconds with return value 0
请按任意键继续. . .

我们仅仅在为形参的指针变量添加一个 & 符号就发生了改变。

其实在函数内形参int* a和int a区别不大，不过是整型指针类型的变量int*和普通整型类型的变量int的区别，都传递的是值。在函数内对它们的值做修改，都无法影响到函数外。

而 int *&a 传递的是整型指针类型变量 a 的地址值，在函数内直接对地址所表示的变量进行修改，那么无论是函数内还是函数外都会被影响到。

如果仅仅是使用 C 语言，那么也可以在形参和实参中传递指针变量的地址，但修改有点多：

#include <stdio.h>
#include <malloc.h>

void fun(int **a) {
    *a = (int *) malloc(sizeof(int));
    int b = 3;
    *a = &b;
    printf("fun->a: %d\n", **a);
}

int main() {
    int *a;
    fun(&a);
    printf("main->a: %d\n", *a);
}

即在函数 fun 内 **a 接收的是就是 main 函数内实参指针变量 *a 的地址，通过 & 操作符取得指针变量的地址；而在函数 fun 内 *a 就表示一个指针变量，对这个指针变量的修改无论是函数内还是函数外都会被影响到。

将函数的实参改为普通变量，而形参继续是指针变量也可以实现同样的效果，但注意在函数内指针变量修改值的方式（这样 a = &b; 赋值是行不通的）。

#include <stdio.h>

void fun(int *a) {
    // 这里就不需要再为它动态分配内存空间了
    // a = (int *) malloc(sizeof(int));
    int b = 3;
    *a = b;// 修改指针变量的值
    printf("fun->a: %d\n", *a);
}

int main() {
    // 声明一个普通变量，而非指针变量
    int a;
    fun(&a);// 因为函数的形参还是指针变量，所以这里要传递普通变量的地址，使用&取址符
    printf("main->a: %d\n", a);
}

那么同样的道理，要想在函数内修改单链表成功，并且在其他函数也可以访问，就可以使用 *&。仅仅只需要改动形参，而不需要改动其他任何地方的代码。但注意这是 C++ 的语法，一般的 C 编译器是不支持的，但在解数据结构题目时为了省事可以考虑使用。

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用头插法创建单链表
 * @param list 单链表
 * @param nums 待插入的数据数组
 * @param n 数组长度
 */
void createByHead(LNode *&list, int nums[], int n) {
    // 创建链表的头节点
    list = (LNode *) malloc(sizeof(LNode));
    list->next = NULL;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的头部，但是在头结点的后面
        LNode *temp = list->next;
        newNode->next = temp;
        list->next = newNode;
    }
}

/**
 * 打印单链表中的所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode *list;
    int nums[] = {111, 222, 333, 444, 555};
    int n = 5;

    createByHead(list, nums, n);
    print(*list);
}

还能使用指向指针的指针，但修改涉及的代码就比较多了。实参、形参及在函数中使用了形参的代码都需要改变：

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用头插法创建单链表
 * @param list 单链表
 * @param nums 待插入的数据数组
 * @param n 数组长度
 */
void createByHead(LNode **list, int nums[], int n) {
    // 创建链表的头节点
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的头部，但是在头结点的后面
        LNode *temp = (*list)->next;
        newNode->next = temp;
        (*list)->next = newNode;
    }
}

/**
 * 打印单链表中的所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode *list;
    int nums[] = {111, 222, 333, 444, 555};
    int n = 5;

    createByHead(&list, nums, n);
    print(*list);
}

如果只是返回一个单链表，我们可以将创建成功的链表作为函数返回值返回，然后在主函数接收就可以，避免了它作为实参和形参的变化：

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用头插法创建单链表
 * @param list 单链表
 * @param nums 待插入的数据数组
 * @param n 数组长度
 */
LNode *createByHead(int nums[], int n) {
    // 创建链表的头节点
    LNode *list = (LNode *) malloc(sizeof(LNode));
    list->next = NULL;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的头部，但是在头结点的后面
        LNode *temp = list->next;
        newNode->next = temp;
        list->next = newNode;
    }
    // 将链表返回
    return list;
}

/**
 * 打印单链表中的所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode *list;
    int nums[] = {111, 222, 333, 444, 555};
    int n = 5;

    list = createByHead(nums, n);
    print(*list);
}

其实还可以考虑实参用普通变量，形参用指针变量，也能达到同样的效果：

#include <stdio.h>
#include <malloc.h>

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode;

/**
 * 使用头插法创建单链表
 * @param list 单链表
 * @param nums 待插入的数据数组
 * @param n 数组长度
 */
void createByHead(LNode *list, int nums[], int n) {
    // list就是链表的头节点，不需要再分配内存空间了，但需要把next指针指向NULL
    list->next = NULL;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的头部，但是在头结点的后面
        LNode *temp = list->next;
        newNode->next = temp;
        list->next = newNode;
    }
}

/**
 * 打印单链表中的所有节点
 * @param list 单链表
 */
void print(LNode list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list.next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    LNode list;
    int nums[] = {111, 222, 333, 444, 555};
    int n = 5;

    createByHead(&list, nums, n);
    print(list);
}

总结：

  • 所谓 *& 就是传递一个引用进去，让你可以在函数内做的修改影响到函数外。
  • 通常 *& 出现在一些关于数据结构中的书籍中，作为伪代码展示。
  • 通常 *& 用来修改链表、栈、树等数据结构。
  • 除了 *& 之外，还可以考虑使用其他的方式也能实现同样的效果，不必过分纠结。
  • 变量在使用之前，普通变量可以不初始化。但指针变量必须初始化并且普通类型的指针变量可以通过 & 取址符进行赋值，而结构体指针变量则需要通过 malloc 函数动态分配空间然后再赋值。
标签
#数据结构 #c语言 #链表
终极深度学习指南：DeepLearning-500-questions中的CNN卷积网络核心技术详解
gitblog_01406的博客
04-23 626
深度学习500问（DeepLearning-500-questions）是一个以问答形式系统梳理概率知识、线性代数、机器学习及深度学习核心概念的开源项目。本文将聚焦卷积神经网络（CNN）这一计算机视觉领域的基石技术，通过项目中第五章的权威内容，带你全面掌握CNN的架构原理、关键操作和实战应用。 ## 🔍 卷积神经网络的本质：从局部特征到全局理解 卷积神经网络（CNN）通过模拟人类视觉系统的层
2020年2月数据库流行度排行：冬日虽然寒冷，春光必定灿烂
博文视点（北京）官方博客
02-27 1548
导读：根据2020年2月， DB-Engines 数据库流行度排行可以看出，前10名延续了上个月的波澜不惊的格局，波动极小，波动分值都在7分以下。值得注意的是，前十名中，除了DB2、Access 和 SQLite，其他产品同比的增长都非常显著。 具体来看，前三名都出现了环比下降，Oracle 下降1.93分，MySQL下降了7分，Microsoft SQL Server 下降了 4.8分,但是Or...
【十万字拆解】从零开始实现GPT-2（完整版）
Pi_Nick的博客
06-01 769
本文是一篇 14 万字、从零硬核实现 GPT 的保姆级指南。内容全面覆盖四个阶段：①从最基础的 Bigram 语言模型切入，跑通数据处理与训练闭环；②仿照 Transformer 架构，深度研究 Multi-Head Attention、残差网络、LayerNorm 及 Dropout 的底层数学与代码实现；③从零构建BPE 分词器，对齐 GPT-2 规范；④从头搭建 GPT-1/2 工业级预训练流程，包含混合精度、梯度累积等十余项硬件级工程调优，并在 AutoDL 算力平台上从0开始训练！适合所有层次！
Unity PICO4 学习记录8： WebRTC
m0_63485455的博客
06-22 1573
这一篇和PICO本身没什么关系，只是记录一下开发过程我们要做一个“从超声设备采集影像数据，一对多地传给XR眼镜终端以及其他可能的设备”应用。发送端是Jetson，由同事负责；接收端XR眼镜端由我负责。同事说视频采集卡例程里给了两种通信协议：RSTP和WebRTC.一开始我尝试用HoloLens2，因为老师和医生们似乎更喜欢OST而不是VST；但是UWP ARM64 媒体栈对 RTSP 支持弱、MixedReality-WebRTC 停更，所以 HL2 不适合当主验证平台。
PLC的人机界面学习一
winneryanshan的博客
06-22 230
本文介绍了PLC控制器与HMI、PC系统建立通讯连接的方法及注意事项。对于PLC-HMI连接，主要采用DP或以太网协议，重点要正确设置网络参数、接口类型（1F18/以太网）和IP地址，特别注意应用程序访问点需与网卡名称一致。PLC-PC系统连接时，需通过WinCC RT Professional实现，关键要确保PLC、PC和电脑网络的IP地址不冲突（如192.168.0.1/0.2/0.10），TCP/IP接口的访问点设为S7ONLINE，同样需核对网卡参数匹配。两种连接均需在网络视图中完成设备组态和物理连
基于土地管理问题：博弈论与系统动力学的综合学习与应用-第一章 系统动力学的基本思想：系统、反馈与动态演化
Ichliebedich2020的博客
06-17 395
本文系统阐述了从博弈论到系统动力学的学习路径，聚焦土地流转问题。博弈论用于分析农户、经营主体等微观主体的策略选择，而系统动力学则研究这些选择累积形成的宏观系统演化。文章详细解析了系统动力学的三大核心概念：系统（多要素相互联系的整体）、反馈（变量间的循环影响）和动态演化（随时间变化的过程），并以土地流转为例，具体分析了规模收益（正反馈）与租金成本（负反馈）等机制如何共同决定系统的长期发展趋势（持续增长、停滞或波动）。系统动力学通过揭示要素间的反馈结构，为理解土地管理等复杂社会问题提供了有力工具。
【学习笔记】tcpdump+Wireshark抓包（1）
2402_82757055的博客
06-22 801
网络上的通信，本质上是数据被拆成一个个 数据包（Packet），经过网卡发送和接收。抓包 = 在某个网卡上，把经过的数据包 复制一份 保存下来，供后续分析。
Java数据库连接池学习
u011237796的博客
06-18 479
表示并发情况下最大可从连接池中获取的连接数。连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。maxIdle对应的连接，实际上是连接池保持的长连接，这也是连接池发挥优势的部分，理论上讲保持较多的长连接，在应用请求时可以更快的响应，但是过多的连接保持，反而会消耗数据库大量的资源，因此maxIdle也并不是越大越好，同上例我们建议将 maxIdle设置成50-100中靠近50的数字，例如55。
Docker 学习之路-从入门到放弃-Jenkins：4-1
qq_28183291的博客
06-17 510
首先总结一下，Jenkins 运行jar 服务，配置主要包括两部分：jdk 和 maven 以及gitlab或云存储平台（阿里云效）。jdk 如果可以选择自带的jdk版本。这里讲解的是没法选择自带java版本。如果没有找到，说明你这里没有给Jenkins账户配权限，可以切换成root账户查询。如果你的jar 不需要docker 、docker-compose ，则跳过。maven 配置自动安装一个版本即可。这个拉取代码时，需要验证。根据提示的路径，配置全局的配置即可。这里是对Jenkins配置的补充。
Spring AI 学习篇（十六）| AI应用的安全与合规
qq_20236937的博客
06-23 317
Spring AI 学习篇（十六）| AI应用的安全与合规
Spring AI 学习篇（十五）| Spring AI应用的可观测性
qq_20236937的博客
06-23 235
Spring AI 学习篇（十五）| Spring AI应用的可观测性
读书笔记--傅里叶变换学习与感悟
hhue2007的专栏
06-21 245
以通俗易懂的方式介绍了傅里叶变换的核心概念与应用。作者将傅里叶变换比作成分拆解机，通过果汁配方、三棱镜分光等生活化比喻，形象解释了时域与频域的转换原理。文章分析了傅里叶变换的三大作用：频谱分析、系统特性研究和运算简化，并列举了其在语音处理、图像压缩、医学成像等领域的典型应用。重点阐释了时域与频域的对偶关系，包括数学表达上的对称性、运算规则的对应性，以及离散傅里叶变换(DFT)与快速傅里叶变换(FFT)的转换原理。全文生动展现了傅里叶变换作为信号处理基础工具的重要价值。
智能体设计模式：学习与适应 Learning & Adaptation
闵浮龙的博客
06-17 205
学习与适应，是 Agent 从“工具调用器”升级成“长期系统”的关键一步。它的核心不是让模型自由发挥，而是建立反馈闭环。能记录。能评估。能诊断。能更新。能验证。能回滚。做到这些，Agent 才能越用越稳，越跑越准。智能体设计模式：学习与适应 Learning & Adaptation：功能变化与行业影响解析_热闻岛。
【Linux驱动学习PCIE篇】PCIE学习--MSI-X中断的注册
qq_54050349的博客
06-20 216
文章摘要 MSI-X是PCIe规范中的增强型消息信号中断机制，相比传统INTx和MSI具有显著优势： 无需物理引脚，通过PCIe TLP报文发送中断 支持最多2048个独立中断向量，每个向量拥有独立地址和数据域 中断表位于设备BAR空间，支持灵活配置 适用于现代高性能设备如NVMe、网卡和GPU 硬件实现上，MSI-X通过PCIe配置空间的Capability结构管理，包含Message Control、Table Offset和PBA等信息。内核驱动通过特定API完成MSI-X的初始化、中断注册和处理，主
Spring AI 学习篇（五）| 嵌入模型与向量表示的本质
qq_20236937的博客
06-22 227
Spring AI 学习篇（五）| 嵌入模型与向量表示的本质
AI时代，我们该怎么学习？
qq_33525062的博客
06-17 300
AI时代的学习革命：从记忆知识到培养判断力 在AI时代，学习方式正经历根本性转变。传统强调记忆和熟练的学习模式被颠覆，因为AI已成为最强大的信息存储和执行工具。学习重点应转向：1）提问能力而非记忆答案；2）跨界连接而非单科深耕；3）批判性思维而非被动接受。AI擅长执行层任务（信息整合、基础分析等），而人类优势在于判断层（价值评估、情感理解等）。建议采取：AI辅助学习、建立知识框架、即时实践应用、保持人性化特质等策略。最终，快速学习能力和将知识转化为行动的能力，才是AI时代最核心的竞争力。
从硬件中断到信号机制：打通操作系统异步底层的完整学习笔记
2402_89711598的博客
06-17 395
这篇文章系统梳理了操作系统底层异步机制的学习历程，形成完整知识闭环。主要内容包括： 硬件中断机制 中断是操作系统夺回CPU控制权的根基 时钟中断作为系统"心跳"驱动调度 特权级与地址空间实现安全隔离 信号机制 用户态"软中断"完整复刻硬件中断流程 信号处理自动屏蔽防止递归 sigaction精细控制信号行为 异步编程约束 可重入函数是信号处理的硬性要求 volatile保证内存可见性 典型应用如SIGCHLD回收子进程 整个体系从硬件中断到用户态信号形成完美对应，所有
WPF 上位机学习日记（五）— 右侧面板 UI 布局全记录
最新发布
Freedom的博客
06-23 481
日期： 2026-06-23 项目： UpperMachine（四轴运动控制）今天没有写任何 C# 后台代码，一整天全部花在 XAML UI 布局上。完成了 HomePage 主页面右侧操作面板 + 导航面板的设计，以及相关的英文命名校正。 关键设计决策 决策 原因 右侧面板用 跨两行高度，顶部到轴卡平齐，底部也与轴卡平齐 Row 0 用 操作按钮内容高度不定，让内容自己撑开 Row 1 用 分隔线只有 3px 高 Row 2 用 导航区吃掉剩余所有高度，自动填满 内
Redis 缓存学习笔记（一）：缓存基础与底层数据结构
bllovepigpig的博客
06-23 401
key 是快递，slot 是格子，Redis 节点是仓库管理员。一个快递只进一个格子，一个格子只归一个管理员管，但一个管理员要管很多格子。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值