Linux: 进程间通信机制

news2024/12/25 9:17:27

文章目录

  • 1. 前言
  • 2. 进程间通信机制
    • 2.1 管道
      • 2.1.1 匿名管道
      • 2.1.2 popen() 和 pclose()
      • 2.1.3 命名管道 FIFO
    • 2.2 消息队列
    • 2.3 共享内存
    • 2.4 信号量
    • 2.5 网络套接字
    • 2.6 UNIX套接字
    • 2.7 信号
  • 3. 参考资料

1. 前言

限于作者能力水平，本文可能存在谬误，因此而给读者带来的损失，作者不做任何承诺。

2. 进程间通信机制

进程间通信机制，简称 IPC(InterProcess Communication)。

2.1 管道

管道特性：

1. 半双工，数据是单向流动。
2. 只能在有共同祖先的进程间使用。
3. 数据一旦被读走，便不在管道中存在，不可反复读取。

在这里插入图片描述

2.1.1 匿名管道

可通过系统调用 pipe() 创建匿名管道：
在这里插入图片描述
pipe() 调用返回两个文件句柄：filedes[0] 用于读，filedes[1] 用于写。用于读的句柄在所有数据被读取后，继续读返回0指示达到数据末尾；如果管道读端的 filedes[0] 关闭了，再向管道写端的 filedes[1] 写入，会产生 SIGPIPE 信号。
例子代码：

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

int main(void)
{
	int n, fd[2];
	pid_t pid;
	char buf[4096];
	
	if (pipe(fd)) {
		perror("pipe");
		exit(EXIT_FAILURE);
	}

	pid = fork();
	if (pid < 0) {
		perror("fork");
		exit(EXIT_FAILURE);
	}

	if (pid > 0) { /* 父进程 */
		close(fd[0]); /* 父进程关闭读端 */
		write(fd[1], "hello, child, i'm your father.\n", 31);
	} else if (pid == 0) { /* 子进程 */
		close(fd[1]); /* 子进程关闭写端 */
		n = read(fd[0], buf, sizeof(buf));
		write(STDOUT_FILENO, buf, n);
	}

	return 0;
}

例子中，管道数据流向是 父进程 -> 子进程，我们也完全可以通过关闭父进程的写端和子进程的读端，创建数据流向完全相反的管道。

2.1.2 popen() 和 pclose()

前述匿名管道方式使用起来不是很方便，这时候可以使用 popen() ：
在这里插入图片描述
函数 popen() 先执行 fork() ，然后调用 exec() 执行 cmdstring 参数指向的程序，最后返回一个标准 I/O 的文件对象指针。
如果 type 参数是 "r" ，则文件对象指针连接到 cmdstring 参数指向程序的标准输出：
在这里插入图片描述
也就是 cmdstring 参数指向程序所在子进程，通过管道将其标准输出数据传递给父进程。
如果 type 参数是 "w" ，则文件对象指针连接到 cmdstring 参数指向程序的标准输入：
在这里插入图片描述
也就是 cmdstring 参数指向程序所在子进程的标准输入，通过管道从父进程读取。
说白了，本质上 popen() 就是对 pipe() 的封装，提高了使用的便利性。
看一个 popen() 使用的例子：

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

int main(int argc, char *argv[])
{
	FILE *fp;
	char buf[4096] = {0};
	int n;

	fp = popen("/bin/ls -l", "r");
	if (!fp) {
		perror("popen");
		exit(EXIT_FAILURE);
	}

	n = fread(buf, 1, sizeof(buf), fp);
	printf("%d bytes\n%s\n", n, buf);

	pclose(fp);
	
	return 0;
}

2.1.3 命名管道 FIFO

前述的管道方式，只能用于有亲缘关系的进程，不相关的进程之间，可以使用命名管道(FIFO)进行数据传输。通过函数 mkfifo() 创建命名管道(FIFO)：
在这里插入图片描述
一旦创建了命名管道(FIFO)文件，就可以通过 open() 打开它，然后进行 read(), write(), close()，unlink() 等操作。
类似于匿名管道，在没有读端进程打开命名管道文件时，如果写端进程对命名管道(FIFO)进行写操作，则会产生 SIGPIPE 信号。
多个进程写同一个命名管道(FIFO)，这是很常见的情形，如果不想各进程写入的数据相互穿插，就需要考虑同步问题。
命名管道(FIFO)常见用途如下：

1. shell命令间相互传递数据。
2. 客户/服务端程序，以便客户进程和服务端进程之间传递数据。

看一个例子：

/* FIFO 写端程序：fifo_wend.c */

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include "fifo_test.h"

int main(void)
{
    int fd;
	char s[] = "hello!\n";

	fd = open(FIFO_FILE, O_WRONLY);
	write(fd, s, sizeof(s));
	close(fd);

	return 0;
}

/* FIFO 读端程序：fifo_rend.c */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

#include "fifo_test.h"

int main(void)
{
	char buf[4096];
    int fd;

	fd = open(FIFO_FILE, O_RDONLY);
	read(fd, buf, sizeof(buf));
	close(fd);

	printf("%s", buf);

	return 0;
}

公共头文件 fifo_test.h ：

#define FIFO_FILE "fifo"

编译和运行：

$ make fifo_rend fifo_wend
$ mkfifo fifo  创建 FIFO 命名管道文件 fifo
$ ./fifo_rend 先启动读端程序
$ ./fifo_wend 后启动写端程序
$ rm fifo 测试完成后删除 fifo 文件

读端程序 fifo_rend 会输出 hello! 字串。

2.2 消息队列

管道的方式虽然简单，但是比较低效，不适合进程间频繁的数据交流，并且管道只能传输无格式字节流。对于进程间频繁的数据交流，如果要求高效、带有格式，使能消息队列将是更好的选择。消息队列的数据在进程间的流动如下图(图片取自参考资料中知乎博文)：
在这里插入图片描述
创建消息队列函数 msgget() ：
在这里插入图片描述
更多细节参考 https://man7.org/linux/man-pages/man2/msgget.2.html 。
配置消息队列函数 msgctl() ：
在这里插入图片描述
更多细节参考 https://man7.org/linux/man-pages/man2/msgctl.2.html 。
发送数据到消息队列函数 msgsnd() ：
在这里插入图片描述
更多细节参考 https://man7.org/linux/man-pages/man2/msgsnd.2.html 。
从消息队列获取数据函数 ：
在这里插入图片描述
更多细节参考 https://man7.org/linux/man-pages/man2/msgrcv.2.html 。
看一个例子，包含消息发送和接收两个程序。程序公共头文件 msg_test.h ：

#define MSGQ_ID 1234
#define MSG_END "<END>"

#define MAX_TEXT 4096

struct msg_data {
	long int msg_type;
	char text[MAX_TEXT];
};

消息发送程序代码 msg_snd.c ：

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/msg.h>
#include <errno.h>

#include "msg_test.h"


int main(int argc, char **argv)
{
	struct msg_data data;
	int msgid = -1;
	static const char *msg_text[] = {
		"message 001", 
		"message 002",
		"message 003",
		MSG_END
	};
	int i;

	/* create */
	msgid = msgget((key_t)MSGQ_ID, 0666 | IPC_CREAT);
	if (msgid == -1) {
		perror("msgget");
		exit(EXIT_FAILURE);
	}

	for (i = 0; i < sizeof(msg_text)/sizeof(msg_text[0]); i++) {
		data.msg_type = 1;
		strcpy(data.text, msg_text[i]);
		
		if (msgsnd(msgid, (void *)&data, MAX_TEXT, 0) == -1) { /* send text message */
			perror("msgsnd");
			exit(EXIT_FAILURE);
		}
	}

	return 0;
}

消息接收程序代码 msg_rcv.c ：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <errno.h>

#include "msg_test.h"

int main(int argc, char **argv)
{
	int msgid = -1;
	struct msg_data data;
	long int msgtype = 0;

	msgid = msgget((key_t)MSGQ_ID, 0666 | IPC_CREAT);
	if (msgid == -1) {
		perror("msgget");
		exit(EXIT_FAILURE);
	}

	for (;;) {
		if (msgrcv(msgid, (void *)&data, MAX_TEXT, msgtype, 0) == -1) {
			perror("msgrcv");
			exit(EXIT_FAILURE);
		}

		printf("<MESSAGE>: %s\n", data.text);
		
		if (strcmp(data.text, MSG_END) == 0)
			break;
	}

	/* remove */
	if (msgctl(msgid, IPC_RMID, 0) == -1) {
		perror("msgget");
		exit(EXIT_FAILURE);
	}

	return 0;
}

编译和运行：

$ make msg_snd msg_rcv
$ ./msg_rcv
$ ./msg_snd

当然，消息队列也可用于父子进程间的通信，感兴趣的读者可以自行实践。

2.3 共享内存

为了避免消息队列那样频繁的数据拷贝，以及系统调用开销，引入了共享内存 IPC 机制。
共享内存 允许两个或更多进程共享一块物理内存区域，因为数据不需要在进程间来回拷贝，所以这是本文所有 IPC 机制中最快的一种。共享内存的各进程页表结构如下图(图片取自参考资料中知乎博文)：
在这里插入图片描述
上图告诉我们，共享内存的物理区域是相同的，进程使用各自页表项映射到相同的物理内存块。也可以从另一个视角来理解(图片取自参考资料中CSDN博文)：
在这里插入图片描述
这里更清晰的看到，共享内存的物理内存区，在进程中对应的虚拟地址可能是不同的。再看下共享内存在进程虚拟地址空间布局中的位置：
在这里插入图片描述
看共享内存相关函数：

#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg); /* 创建 或 获取 共享内存 */
int shmctl(int shmid, int cmd, struct shmid_ds *buf); /* 配置共享内存 */
void *shmat(int shmid, const void *shmaddr, int shmflg); /* 建立到共享内存的映射 */
int shmdt(const void *shmaddr); /* 移除到共享内存的映射 */

看一个例子，仍然是一个写程序和一个读程序。两个程序的共同头文件 shm_common.h ：

#ifndef SHM_COMMON_H
#define SHM_COMMON_H

#define MY_SHM_KEY 1234
#define TEXT_SZ 2048
#define MSG_END "<END>"

struct shared_data {
    int data_avail;
    char text[TEXT_SZ];
};

#endif /* SHM_COMMON_H */

写程序 shm_write.c ：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_common.h"

int main (void)
{
    int running = 1;
	int shmid;
    void *shared_vaddr = NULL;
    struct shared_data *shared;
    char buffer[BUFSIZ];
	static const char *msg_text[] = {
		"message 001", 
		"message 002",
		"message 003",
		MSG_END
	};
	int i;

    shmid = shmget((key_t)MY_SHM_KEY, sizeof(struct shared_data), 0666 | IPC_CREAT);
    if (shmid == -1) {
		perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_vaddr = shmat(shmid, NULL, 0);
    if (shared_vaddr == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %p\n", shared_vaddr);
	
    shared = (struct shared_data *)shared_vaddr;
	
    for (i = 0; i < sizeof(msg_text)/sizeof(msg_text[0]); i++) {
        while (shared->data_avail)
			asm("nop");
		
        strcpy(shared->text, msg_text[i]);
        shared->data_avail = 1;
    }

    if (shmdt(shared_vaddr) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    return 0;
}

读程序 shm_read.c ：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <error.h>

#include "shm_common.h"

int main (void)
{
	int shmid;
    void *shared_vaddr = NULL;
    struct shared_data *shared;

	shmid = shmget((key_t)MY_SHM_KEY, sizeof(struct shared_data), 0666 | IPC_CREAT);
    if (shmid == -1) {
		perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_vaddr = shmat(shmid, NULL, 0);
    if (shared_vaddr == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %p\n", shared_vaddr);
	
    shared = (struct shared_data *)shared_vaddr;
    shared->data_avail = 0;

    for (;;) {
        if (shared->data_avail) {
            printf("%s\n", shared->text);

			if (strcmp(shared->text, MSG_END) == 0)
				break;

			shared->data_avail = 0;
      	}
    }

    if (shmdt(shared_vaddr) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    return 0;
}

编译和运行：

在这里插入代码片

同样，共享内存也可用于父子进程间的通信，感兴趣的读者可以自行实践。

2.4 信号量

先看信号量函数集：

#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg); /* 创建 或 获取 一个已有信号量 */
int semctl(int semid, int semnum, int cmd, ...); /* 配置信号量 */
int semop(int semid, struct sembuf *sops, size_t nsops); /* 改变信号量的值 */
int semtimedop(int semid, struct sembuf *sops, size_t nsops,
				const struct timespec *timeout);

看一个例子，代码来自此处：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h>
#include <errno.h>

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *arry;
};

static int init_semaphore(int sem_id);
static int fini_semaphore(int sem_id);

static int semaphore_p(int sem_id);
static int semaphore_v(int sem_id);


int main(int argc, char *argv[])
{
    char message = 'X';
    int sem_id, i = 0;
 
    sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);
	if (sem_id == -1) {
		perror("semget");
		exit(EXIT_FAILURE);
	}
 
    if (argc > 1) { /* first time to init */
        if (!init_semaphore(sem_id))
            exit(EXIT_FAILURE);
 
        message = argv[1][0];
        sleep(2);
    }
 
    for (i = 0; i < 10; ++i) {
        if (!semaphore_p(sem_id))
            exit(EXIT_FAILURE);

        printf("%c", message);
 
        fflush(stdout);
        sleep(rand() % 3);

        printf("%c\n", message);
        fflush(stdout);
 
        if (!semaphore_v(sem_id))
            exit(EXIT_FAILURE);

        sleep(rand() % 2);
    }
 
    sleep(10);
    printf("\n%d - finished\n", getpid());
 
    if (argc > 1) {
        sleep(3);
        fini_semaphore(sem_id);
    }

    exit(EXIT_SUCCESS);
}

static int init_semaphore(int sem_id)
{
    union semun sem_union;
 
    sem_union.val = 1;
    if (semctl(sem_id, 0, SETVAL, sem_union) == -1) {
		perror("semctl");
        return 0;
	}

    return 1;
}
 
static int fini_semaphore(int sem_id)
{
    union semun sem_union;
 
    if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1) {
        perror("semctl");
		return 0;
	}

	return 1;
}
 
static int semaphore_p(int sem_id)
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        perror("semop");
        return 0;
    }
 
    return 1;
}
 
static int semaphore_v(int sem_id)
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        perror("semop");
        return 0;
    }
 
    return 1;
}

编译和运行：

$ make sem_test
$ ./sem_test 0
$ ./sem_test

2.5 网络套接字

就上张图吧，其它的就不多说了。
在这里插入图片描述
图片来自于 这里 。

2.6 UNIX套接字

有点类似于命名管道(FIFO)，也许我们可以把UNIX套接字说成命名socket。更多细节参考博客 https://blog.csdn.net/inthat/article/details/27371939 。

2.7 信号

#include <signal.h>

int kill(pid_t pid, int sig); /* 发送信号到进程 */
int killpg(int pgrp, int sig); /* 发送信号到进程组 */
int tgkill(pid_t tgid, pid_t tid, int sig); /* 发送信号到线程 */
int syscall(SYS_pidfd_send_signal, int pidfd, int sig, siginfo_t *info,
                             unsigned int flags); /* 发送信号到进程 */

3. 参考资料

《Advanced Programming in the UNIX Envinronment》
https://zhuanlan.zhihu.com/p/556004836
https://blog.csdn.net/fukangwei_lite/article/details/120640540
https://blog.csdn.net/m0_52387305/article/details/124149859
https://blog.csdn.net/inthat/article/details/27371939

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

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

相关文章

基于格密码的LWE问题

基于格密码的LWE问题

LWE LWE问题&#xff0c; Learning With Errors&#xff0c;带有安全性证明的第一个版本是由Oded Regev 在2005年提出&#xff0c;Kawachi等给出了效率的改进&#xff0c;接着一些效率方面非常重要的改进由Peikert等提出。 格理论知识 格密码学&#xff08;Lattice-based Cr…
阅读更多...
PTA L1-093 猜帽子游戏 (15 分)

PTA L1-093 猜帽子游戏 (15 分)

宝宝们在一起玩一个猜帽子游戏。每人头上被扣了一顶帽子&#xff0c;有的是黑色的&#xff0c;有的是黄色的。每个人可以看到别人头上的帽子&#xff0c;但是看不到自己的。游戏开始后&#xff0c;每个人可以猜自己头上的帽子是什么颜色&#xff0c;或者可以弃权不猜。如果没有…
阅读更多...
机器学习算法 决策树

机器学习算法 决策树

文章目录 一、决策树的原理二、决策树的构建2.1 ID3算法构建决策树2.2 C4.5 算法树的构建2.3 CART 树的创建 三、决策树的优缺点 一、决策树的原理 决策树&#xff08;Decision Tree&#xff09;是一种非参数的有监督学习方法&#xff0c;它能够从一系列有特征和标签的数据中总…
阅读更多...
NDK OpenCV人脸定位

NDK OpenCV人脸定位

NDK系列之OpenCV人脸定位技术实战&#xff0c;本节主要是通过OpenCV C库&#xff0c;实现识别人脸定位&#xff0c;并对识别到的人脸画面增加红框显示。 实现效果&#xff1a; 实现逻辑&#xff1a; 1.初始化CameraX&#xff0c;绑定图片分析器ImageAnalysis&#xff0c;监听…
阅读更多...
7.队列算法

7.队列算法

算法&#xff1a;队列算法 队列是一种抽象的数据结构&#xff0c;有点类似于Stacks。与堆栈不同&#xff0c;队列的两端都是开放的。一端始终用于插入数据(入队)&#xff0c;另一端用于删除数据(出队)。队列遵循先进先出方法&#xff0c;即首先访问先存储的数据项。 一个真实的…
阅读更多...
【C++初阶】类与对象（上）

【C++初阶】类与对象（上）

一.什么是类&#xff0c;什么是对象 我们可以形象的把类比作是一个房子的设计图纸&#xff0c;而对象就是根据设计图纸设计出来的房子。 由设计图纸到房子的过程&#xff0c;我们称之为类的实例化。 C兼容C的&#xff0c;所以C中的结构体在C中也能用&#xff0c;但是C把结构体升…
阅读更多...
rust教程 第一章 —— 初识rust

rust教程 第一章 —— 初识rust

文章目录 前言一、Rust简介二、安装Rust编译器三、第一个Rust程序四、 IDE环境五、初识包管理六、总结 前言 本系列教程目录可查看这里&#xff1a;Rust教程目录 近些年来不断有新的语言崛起&#xff0c;比如当下非常火的go语言&#xff0c;不过相比于C&#xff0c;go语言确实…
阅读更多...
C++类和对象 （3）

C++类和对象 （3）

类和对象 1. 类的6个默认成员函数2. 构造函数2.1. 概念&#xff08;问题提出&#xff09;2.2. 特性 3.析构函数3.1. 概念3.2.特性 1. 类的6个默认成员函数 如果一个类中什么成员都没有&#xff0c;简称为空类。 空类中真的什么都没有吗&#xff1f;并不是&#xff0c;任何类在…
阅读更多...
使用OpenFeign实现接口访问

使用OpenFeign实现接口访问

1. 引言 在微服务横行的年代&#xff0c;后端根据业务的不一样分成了很多单独运行的服务&#xff0c;比如在物联网中&#xff0c;根据业务拆分为定时服务、设备控制等服务。当前端想控制设备时&#xff0c;其请求首先到其对应的后端服务&#xff0c;后端服务再调用设备控制服务…
阅读更多...
Vue+Vant封装通用模态框单选框组件

Vue+Vant封装通用模态框单选框组件

前言 我们知道&#xff0c;在vant组件中提供的组件往往是比较基础的&#xff0c;能够满足基本需求。但是我们想实现ui设计的一些比较丰富效果的组件&#xff0c;需要自己去实现&#xff0c;且当项目中多次用到的时候&#xff0c;我们将以组件化的思想将其封装起来&#xff0c;…
阅读更多...
Node.js -- 使用Express写接口

Node.js -- 使用Express写接口

1.创建基本的服务器 //导入express const express require(express) //创建服务器实例 const app express() //调用app.listen方法&#xff0c;指定端口号并启动web服务器 app.listen(80,function(){console.log(Express server running at http://127.0.0.1) })2. 创建API路…
阅读更多...
路由交换综合实验

路由交换综合实验

拓扑结构&#xff1a; 要求 1、R6为网络运营商&#xff08;ISP&#xff09;&#xff0c;接口IP地址均为公有地址&#xff1b;该设备只能配置IP地址&#xff0c;之后不能在对其进行任何配置&#xff1b; 2、R1~R5为局域网&#xff0c;私有IP地址192.168.1.0/24&#xff0c;请合…
阅读更多...
真题详解(UML图)-软件设计（五十五)

真题详解(UML图)-软件设计（五十五)

真题详解&#xff08;计算机知识&#xff09;-软件设计&#xff08;五十四)https://blog.csdn.net/ke1ying/article/details/130278265 组织域名&#xff1a; com商业组织 edu教育组织 gov政府组织 net主要网络支持中心 mil军事部门 Int国际组织 2、时间复杂度 O&#…
阅读更多...
写一个自己的命令行解释器

写一个自己的命令行解释器

写一个自己的命令行解释器 当我点开xshell运行服务器的时候bash就被加载到了内存中&#xff0c;此后我在bash上执行的所有程序都是作为bash的子进程。在bash这个进程内创建子进程&#xff0c;并让子进程去执行全新的代码&#xff0c;这不就是程序替换吗&#xff1f; 所以我们…
阅读更多...
腾讯云4核8g服务器支持多少人在线使用？

腾讯云4核8g服务器支持多少人在线使用？

腾讯云轻量4核8G12M轻量应用服务器支持多少人同时在线&#xff1f;通用型-4核8G-180G-2000G&#xff0c;2000GB月流量&#xff0c;系统盘为180GB SSD盘&#xff0c;12M公网带宽&#xff0c;下载速度峰值为1536KB/s&#xff0c;即1.5M/秒&#xff0c;假设网站内页平均大小为60KB…
阅读更多...
【Unity入门】17.脚本访问父子结点

【Unity入门】17.脚本访问父子结点

【Unity入门】脚本访问父子结点 大家好&#xff0c;我是Lampard~~ 欢迎来到Unity入门系列博客&#xff0c;所学知识来自B站阿发老师~感谢 &#xff08;一&#xff09;父级节点 &#xff08;1&#xff09;访问父级节点 父子关系我们并不陌生&#xff0c;在cocos中常用node:get…
阅读更多...
单链表的实现

单链表的实现

链表的概念与结构 链表与我们通讯录中的顺序表是不同的&#xff0c;顺序表的空间是连续的&#xff0c;像数组一样可以通过下标访问。而链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。即&#xff1a;链表…
阅读更多...
数据结构笔记：二叉树的遍历与技巧

数据结构笔记：二叉树的遍历与技巧

引言 本篇是最近有遇到过的一个题目&#xff0c;关于二叉树的遍历&#xff0c;正好有一些经验与技巧&#xff0c;所以开一篇帖子记录一下。 二叉树遍历介绍 遍历是数据结构中常见的操作&#xff0c;主要是将所有元素都访问一遍。对于线性结构来说&#xff0c;遍历分为两种&a…
阅读更多...
RecyclerView 静态布局实现过程解析：如何构建高性能的列表

RecyclerView 静态布局实现过程解析：如何构建高性能的列表

作者&#xff1a;maxcion Recyclerview在日常开发中所使用的控件中绝对是顶流一般的存在&#xff0c;想嚼它这个想法一次两次了。在网上也看了很多关于Recyclerview源码解析的文章&#xff0c;大佬们写的都很深刻&#xff0c;但是对于像我们这种储备知识不足的小白读者来说&…
阅读更多...
前端实现端到端测试(代码版)

前端实现端到端测试(代码版)

端到端测试框架选取 playwright 、 cypress 、 selenium 对比 cypress使用 下载 cypress npm install cypress --save-dev package.json npm run cypress:open {"scripts": {"cypress:open": "cypress open"} }使用流程 入门官方文档 npm ru…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023