数据结构（二）------单链表

news2024/11/19 17:31:59

制作不易，三连支持一下呗！！！

文章目录

  • 前言
  • 一.什么是链表
  • 二.链表的分类
  • 三.单链表的实现
  • 总结

前言

上一节，我们介绍了顺序表的实现与一些经典算法。

但是顺序表这个数据结构依然有不少缺陷：

1.顺序表指定位置和头部的插入和删除操作的时间复杂度为o（n）。

2.增容需要重新申请新的空间，拷贝旧数据，释放旧空间有不小的损耗。

3.增容是成倍数的扩容，难免还会存在一定的空间浪费。

问题来了：有没有一种数据结构是可以弥补上述顺序表中存在的一些缺点的。答案是肯定的——链表

一.什么是链表

链表的结构就像火车的一节一节的车厢，每节车厢单独用来容纳乘客，但是彼此之间又用链条相互勾连在一起。同时从第一节车厢想要到达第三节车厢必须要经过第二节车厢。

链表依然属于线性表，它在逻辑结构上是连续的，但是物理结构上是不连续的！

链表在逻辑结构上大概是这样的：

 

而这里的每一节“车厢“，我们称之为”节点（结点）“ 。每个节点又是由两个部分组成：一部分用来存储数据，另一部分则是保存下一个节点的地址，以便我们找到下一个节点。链表就是这样通过指针将物理结构上不连续的数据串联在了一起。

二.链表的分类：

链表的分类依据有三点：

1.带头与不带头

2.循环与不循环

3.单向与双向

通过这三种依据的排列组合，链表共可以分为2*2*2=8种。（我们主要学习单链表（不带头单向不循环链表）与双向链表（带头双向不循环链表，下一节介绍））。

下面我们解释一下这三种依据是什么意思：

1.带头与不带头

带头是指带有头节点的链表，所谓头节点是指第一个节点（但是这个节点不保存有效数据，只记录下一个节点的地址，是一个无效的节点），就像放哨的一样，所以也叫“哨兵卫”。

逻辑结构如下：

 

  不带头就是指从第一个节点开始就存储有有效的数据的链表

 

2.循环与不循环 

不循环链表的结尾一定是NULL，以表示链表已结束。

逻辑结构就是这样：

 

而循环链表 则是将不循环链表首尾相连，让它们形成封闭的图形。

逻辑结构如下：

3.单向与双向 

单向链表就是指通过前驱节点可以找到后继节点，但是无法通过后继节点找到前驱节点

逻辑结构如下：

双向链表则是既可以通过前驱节点找到后继节点，也能通过后继节点找回前驱节点

逻辑结构如下：

三.单链表的实现 

我们这一节则是来介绍单链表的实现过程，完成对单链表进行增，删，查，改的接口。

1.单链表节点的定义

根据前面对单链表的介绍，我们知道单链表由两部分组成，一个是保存数据，另一个是保存下一个节点的地址，所以我们可以自然的写出这种结构。

typedef int SLDataType;//重定义方便我们后续存储数据类型发生改变时，一键替换
typedef struct SListNode
{
	SLDataType data;
	struct SListNode *next;
}SLTNode;          //重定义方便我们后续书写

2.单链表的打印 

我们接下来先写一个打印单链表的接口，以方便我们后续调试代码！

由于我们还没有申请节点的接口，所以我们首先先手动申请4个节点，并把它们链在一起。

 

画图的话就是这个样子。

如果我们想打印这串链表，通过分析可知，我们可以通过循环遍历这个链表，判断条件是当前节点是否为NULL。每次打印结束将下个节点作为新的节点来打印。 

代码实现如下：

void SListPrint(SLTNode* node1)
{
	SLTNode* ps = node1;//直接用node1会导致后面找不到头节点
	while (ps)
	{
		printf("%d->", ps->data);
		ps = ps->next;
	}
	printf("NULL\n");
}

 

在VS2022上对上述代码的运行结果如下：

打印结果与我们预期结果相符，没有问题。 

3.创建新节点 

我们后续插入数据时都会创建新的节点，所以我们将这个功能单独拿出来实现一个创建新节点的接口。

SLTNode* SLTBuyNode(SLDataType x)//x是要插入的数据
{
	SLTNode* nownode = (SLTNode*)malloc(sizeof(SLTNode));
    if (newnode == NULL)
    {
	   perror("malloc");
	   exit(1);
    }
	nownode->data = x;
	nownode->next = NULL;
	return nownode;
}

 

4.尾插和头插 

<1>.尾插

 

 当链表不为空时：

假设我们现在要在当前链表后尾插一个节点5。思路就是先创建一个新节点5，通过循环找到当前的尾节点4，将node4->next改为node5。

当链表为空时：

直接将新节点作为头节点即可。

代码实现如下：

void SLTPushBack(SLTNode** pphead, SLDataType x)//注意：这里一定要传址调用，否则链表为空的情况就无法插入成功
{
    assert(pphead);//pphead不能为空，因为我们在函数中需要对pphead解引用
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)//链表为空，将新节点直接作为头节点
	{
		*pphead = newnode;
		return;
	}
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//循环结束后，ptail就是尾节点
	ptail->next = newnode;
}

测试样例：

 

注意： 如果这里我们直接将头节点的地址传进来，而不是传入指向头节点的指针的地址，那么当头节点为空时，形参pphead是头节点地址的临时拷贝，将pphead赋值为nownode并不会改变实参plist，就会导致永远无法插入第一个节点。

 

<2>.头插 

还是要将5插入到链表中，思路就是先创建一个新节点newnode，让newnode->next=*pphead，并将头节点*pphead赋值为newnode(也就是新的头节点)。

代码实现如下：

void SLTPushFront(SLTNode**pphead, SLDataType x)
{
	assert(pphead); //pphead不能为空，因为我们在函数中需要对pphead解引用
	SLTNode* newnode= SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

测试样例：

 

 

5.头删和尾删 

<1>.头删

假设我们要头删掉1这个节点，整体思路就是重新创建一个变量用来保存头节点的后继节点（因为我们接下来要释放掉头节点，不保存一份会导致找不到第二个节点），然后释放掉原来的头节点，并将其置为NULL。 然后将头节点赋值为原来的第二个节点。

代码实现如下：

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不能为空
	//让第二个节点成为新的头节点，并释放掉旧的头节点
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

测试样例如下：

 

 

<2>.尾删

假设我们想要尾删掉4这个节点，我们都思路就是通过while循环找到尾节点和尾节点的前驱节点。将尾节点的前驱节点置为NULL，释放掉尾节点，并将指向尾节点的指针置为空。

注意：这样有一个特殊的情况就是当链表中只有一个节点时，头节点也就同时是尾节点，这样是没有尾节点的前驱节点的。所以这种情况需要单独考虑！！！

代码实现如下：

void SLTPopBack(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	assert(*pphead);//链表不能为空
	SLTNode* prev = NULL;
	SLTNode* pcur = *pphead;
	if (pcur->next == NULL)//只有一个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	while (pcur->next)
	{
		prev = pcur;
		pcur = pcur->next;
	}
	prev->next = NULL;
	//销毁尾节点
	free(pcur);
	pcur = NULL;
}

样例测试如下：

 

 

6.查找

思路很简单：遍历链表，遇到要找的值就返回这个节点的地址，找不到返回NULL。

代码实现如下：

SLTNode* SLTFind(SLTNode** pphead, SLDataType x)//查找数据x，并返回节点的地址
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	//遍历链表
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
   	    }
		pcur = pcur->next;
	}
    //找不到返回NULL
	return NULL;
}

 

测试样例 ：

7.指定位置的插入和删除 

<1>.指定位置之前插入数据

思路：找到目标节点和目标节点的前驱节点，改变目标节点的前驱节点的方向，将新节点串联进来。

pos可以通过查找接口来获取！！！

代码实现如下：

void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);//指定位置肯定不能为空
	assert(*pphead);//如果链表为空，指定位置一定为空，所以链表不能为空
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* prev = *pphead;
	if (pos == *pphead)//特殊情况，特殊处理
	{
		SLTPushFront(pphead, x);
		return;
	}
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}

这里要注意一种特殊的情况：pos是头节点时，while循环将永远无法找到pos。这里我们直接调用之前实现的头插接口即可! ! ! 

 <2>.指定位置之后插入数据

思路就是：先创建新节点newnode，再将newnode的后继节点赋为指定位置pos的后继节点，再将指定位置pos的后继节点置为newnode。

代码实现如下：

void SLTInsertAfter(SLTNode* pos, SLDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

注意： 我们不需要传入头节点，因为只要有pos就可以找到pos之后的所有节点！！！

<3>.删除指定位置的节点

代码实现如下：

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);//链表为空就无法删除，不能为空
	assert(pos);
	SLTNode* prev = *pphead;//
	if (pos == *pphead)//如果pos为头节点，没有前驱节点
	{
		//头删
		SLTPopFront(pphead);
		return;
	}
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

 

<4>.指定位置之后删除数据

思路和指定位置之后插入数据类似，也是先找到pos和pos->next,再改变链表方向，最后释放pos->next节点。

代码实现如下：

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

 

8.销毁链表 

void SLTDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

总结

单链表的所有代码放在这里，以供参考！！！

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;//重定义方便我们后续存储数据类型发生改变时，一键替换
typedef struct SListNode
{
	SLDataType data;
	struct SListNode *next;
}SLTNode;          //重定义方便我们后续书写

void SListPrint(SLTNode* node1)
{
	SLTNode* ps = node1;
	while (ps)
	{
		printf("%d->", ps->data);
		ps = ps->next;
	}
	printf("NULL\n");
}
SLTNode* SLTBuyNode(SLDataType x)//x是要插入的数据
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SLTPushBack(SLTNode** pphead, SLDataType x)//注意：这里一定要传址调用，否则链表为空的情况就无法插入成功
{
	assert(pphead);//pphead不能为空，因为我们在函数中需要对pphead解引用
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)//链表为空，将新节点直接作为头节点
	{
		*pphead = newnode;
		return;
	}
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//循环结束后，ptail就是尾节点
	ptail->next = newnode;
}
void SLTPushFront(SLTNode**pphead, SLDataType x)
{
	assert(pphead); //pphead不能为空，因为我们在函数中需要对pphead解引用
	SLTNode* newnode= SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不能为空
	SLTNode* prev = NULL;
	SLTNode* pcur = *pphead;
	if (pcur->next == NULL)//只有一个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	while (pcur->next)
	{
		prev = pcur;
		pcur = pcur->next;
	}
	prev->next = NULL;
	//销毁尾节点
	free(pcur);
	pcur = NULL;
}
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不能为空
	//让第二个节点成为新的头节点，并释放掉旧的头节点
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
SLTNode* SLTFind(SLTNode** pphead, SLDataType x)//查找数据x，并返回节点的地址
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	//遍历链表
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
   	    }
		pcur = pcur->next;
	}
	//找不到返回NULL
	return NULL;
}
void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);//指定位置肯定不能为空
	assert(*pphead);//如果链表为空，指定位置一定为空，所以链表不能为空
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* prev = *pphead;
	if (pos == *pphead)//特殊情况，特殊处理
	{
		SLTPushFront(pphead, x);
		return;
	}
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}
void SLTInsertAfter(SLTNode* pos, SLDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);//链表为空就无法删除，不能为空
	assert(pos);
	SLTNode* prev = *pphead;//
	if (pos == *pphead)//如果pos为头节点，没有前驱节点
	{
		//头删
		SLTPopFront(pphead);
		return;
	}
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}
void SLTDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
int main()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SListPrint(plist);
	SLTNode* Findret = SLTFind(&plist, 2);
	if (Findret)
	{
		printf("找到了\n");
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1417287.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

深入理解TCP网络协议(1)

深入理解TCP网络协议(1)

目录 1.TCP协议的段格式 2.TCP原理 2.1确认应答 2.2超时重传 3.三次握手(重点) 4.四次挥手 1.TCP协议的段格式 我们先来观察一下TCP协议的段格式图解: 源/目的端口号:标识数据从哪个进程来,到哪个进程去 32位序号/32位确认号:TCP会话的每一端都包含一个32位&#xff08…
阅读更多...
分布式ID（3）：雪花算法生成ID之UidGenerator（百度开源的分布式唯一ID生成器）

分布式ID（3）：雪花算法生成ID之UidGenerator（百度开源的分布式唯一ID生成器）

1 UidGenerator官方地址 UidGenerator源码地址： https://github.com/baidu/uid-generator UidGenerator官方说明文档地址： https://github.com/baidu/uid-generator/blob/master/README.zh_cn.md 这边只做简单介绍，详细说明请看官方说明文档。 2 Snowflake算法 Snowfl…
阅读更多...
「 典型安全漏洞系列 」08.文件上传漏洞详解

「 典型安全漏洞系列 」08.文件上传漏洞详解

文件上传功能可被攻击者用作一系列高严重性攻击的强大载体。本文最后将会展示如何绕过常见的防御机制来上传web shell&#xff0c;使你能够完全控制一个易受攻击的web服务器。 1. 简介 文件上传漏洞是指web服务器允许用户在没有充分验证文件名、类型、内容或大小等信息的情况下…
阅读更多...
OJ_糖果分享游戏

OJ_糖果分享游戏

题干 c实现 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<vector> using namespace std;void ShareCandy(vector<int>& student) {int size student.size();vector<int> share(size); //保存每个同学交换前&#xff0c;糖果数量…
阅读更多...
（java）idel中将对与json的相互转

（java）idel中将对与json的相互转

1、目录结构 2、导入包 在模块下面建立lib目录将包导入模块中 包的百度网盘 链接&#xff1a;https://pan.baidu.com/s/1abNF8cOTeNb00rM7tp04iQ?pwd39wc 提取码&#xff1a;39wc 3、建立两个测试类person和dog类 public class Dog {private String name;private int age…
阅读更多...
TypeScript（四） 运算符

TypeScript（四） 运算符

1. 运算符 1.1. 描述 运算符用于执行程序代码运算。 1.2. 运算符主要包括&#xff1a; &#xff08;1&#xff09;算术运算符 &#xff08;2&#xff09;逻辑运算符 &#xff08;3&#xff09;关系运算符 &#xff08;4&#xff09;按位运算符 &#xff08;5&#xff09;赋值…
阅读更多...
C#算法（11）—求三个点构成圆的圆心坐标和半径

C#算法（11）—求三个点构成圆的圆心坐标和半径

前言 我们在上位机开发领域也经常会碰到根据三个点求出圆的圆心、半径等信息的场景，本文就是详细的介绍如何根据三个点使用C#代码求出三点构成的圆的圆心坐标、圆半径、三点构成的圆弧的角度。 1、3点求圆分析 A、B、C三个点都是圆上的坐标点，过向量AB做中垂线，过向量AC做…
阅读更多...
STP生成树协议实验

STP生成树协议实验

实验大纲 一、什么是生成树协议 二、生成树原理 1.STP工作原理 2.STP主要参数 3.STP根网桥 4.STP协议版本 三、实验 1.构建网络拓扑结构图 2.配置IP地址&#xff08;8台PC机&#xff09;&#xff1a;192.168.7.1~192.168.7.8 3.配置SW1 4.配置SW2 5.配置SW3 6.配置…
阅读更多...
【英语趣味游戏】填字谜（Crossword）第1天

【英语趣味游戏】填字谜（Crossword）第1天

谜题出处 柯林斯字谜大全&#xff08;6&#xff09;&#xff0c;Collins——Big Book of Crosswords&#xff08;Book 6&#xff09; Puzzle Number: 114 本期单词 横向 1、Situation involving danger (4) 包含危险的情境&#xff0c;4个字母 答案&#xff1a;Risk&#xff…
阅读更多...
第十一章 Linux实际操作——进程管理（重点）

第十一章 Linux实际操作——进程管理（重点）

第十一章 Linux实际操作——进程管理&#xff08;重点&#xff09; 11.1 基本介绍11.2 显示系统执行的进程11.2.1 基本介绍11.2.2 ps详解11.2.3 应用实例 11.3 终止进程kill和killall11.3.1 介绍11.3.2 基本语法11.3.3 常用选项11.3.4 最佳实践 11.4查看进程树pstree11.4.1 基本…
阅读更多...
微服务-微服务Spring-cloud-open-feign

微服务-微服务Spring-cloud-open-feign

1. LoadBalancerRestTemplate的缺陷 LoadBalancerRestTemplate进行微服务调用 BeanLoadBalancedpublic RestTemplate restTemplate() {return new RestTemplate();}//调用方式String url "http://mall-order/order/findOrderByUserId/"id;R result restTemplate.…
阅读更多...
路由进阶

路由进阶

文章目录 1.路由的封装抽离2.声明式导航 - 导航链接3.声明式导航-两个类名自定义匹配的类名 4.声明式导航 - 跳转传参查询参数传参动态路传参两种传参方式的区别动态路由参数可选符 5.Vue路由 - 重定向6.Vue路由 - 4047.Vue路由 - 模式设置8.编程式导航 - 两种路由跳转9.编程式…
阅读更多...
Nginx负载均衡下的webshell连接

Nginx负载均衡下的webshell连接

一、WebShell简介 “web”的含义是显然 需要服务器开放web服务&#xff0c;“shell”的含义是 取得对服务器某种程度上操作权限。 webshell&#xff0c;顾名思义&#xff1a;web指的是在web服务器上&#xff0c;而shell是用脚本语言编写的脚本程序&#xff0c;webshell就是就…
阅读更多...
漏洞原理MySQL注入布尔盲注入

漏洞原理MySQL注入布尔盲注入

1 判断MySql注入点是否存在 利用盲注入的方式 http://127.0.0.1/news/show.php?id46 and 11 # 正常显示 http://127.0.0.1/news/show.php?id46 and 12 # 不显示 2 获取数据库的长度 http://127.0.0.1/news/show.php?id46 and length(database())n n的范围是从 1 开始 h…
阅读更多...
Kotlin快速入门4

Kotlin快速入门4

Kotlin的类与对象 类的定义 Kotlin使用关键字class来声明类。后面紧跟类名字&#xff1a; class LearnKotlin { //类名&#xff1a;LearnKotlin//... } Kotlin的类可以包含&#xff1a;构造函数和初始化代码块、函数、属性、内部类、对象声明。当然&#xff0c;也可以定义一…
阅读更多...
BGP：05 BGP自动路由汇总

BGP：05 BGP自动路由汇总

路由汇总&#xff0c;能有效地减少 BGP 路由器通告的路由条目数量&#xff0c;减小设备的路由表规模&#xff0c;并将拓扑变化产生的影响限制在一个相对更小的范围内。 自动路由聚合是在自然边界路由器上自动执行的&#xff0c;在默认情况下&#xff0c;BGP的自动路由聚合功能是…
阅读更多...
go包与依赖管理

go包与依赖管理

包&#xff08;package&#xff09; 包介绍 Go语言中支持模块化的开发理念&#xff0c;在Go语言中使用包&#xff08;package&#xff09;来支持代码模块化和代码复用。一个包是由一个或多个Go源码文件&#xff08;.go结尾的文件&#xff09;组成&#xff0c;是一种高级的代码…
阅读更多...
springboot134英语知识应用网站的设计与实现

springboot134英语知识应用网站的设计与实现

简介 【毕设源码推荐 javaweb 项目】基于springbootvue 的 适用于计算机类毕业设计&#xff0c;课程设计参考与学习用途。仅供学习参考&#xff0c; 不得用于商业或者非法用途&#xff0c;否则&#xff0c;一切后果请用户自负。 看运行截图看 第五章 第四章 获取资料方式 **项…
阅读更多...
深度强化学习（王树森）笔记07

深度强化学习（王树森）笔记07

深度强化学习&#xff08;DRL&#xff09; 本文是学习笔记&#xff0c;如有侵权&#xff0c;请联系删除。本文在ChatGPT辅助下完成。 参考链接 Deep Reinforcement Learning官方链接&#xff1a;https://github.com/wangshusen/DRL 源代码链接&#xff1a;https://github.c…
阅读更多...
C++多线程2（复习向）

C++多线程2（复习向）

lock_guard lock_guard是C中提供的对互斥锁有关操作的高级接口&#xff0c;可对互斥锁进行自动上锁和解锁&#xff0c;多用于作为局部变量。&#xff08;在对象创建时&#xff0c;构造函数中自动为传入的互斥锁对象上锁&#xff0c;局部变量被系统回收时&#xff0c;其析构函数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023