Unix_Linux操作系统-笔记Day8(进程间通信)

最新推荐文章于 2022-09-29 18:16:58 发布
最新推荐文章于 2022-09-29 18:16:58 发布
阅读量243 收藏
点赞数
分类专栏： 笔记 文章标签： UNIX Linux 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WChQGouge/article/details/98069368
版权

Day8 进程间通信

基本概念

进程间的通信(IPC)InterProcess Communication

两个或多个进程之间的交换数据的过程

当多个进程协同工作高效率完成任务时,因为每个进程都是一个独立的个体(资源单位),进程之间就需要通信

进程之间通信方式

  • 简单进程通信:命令行参数,环境变量表,信号,文件
  • 传统进程通信:管道
  • XSI进程间通信:共享内存,消息队列,信号量
  • 网络进程通信:socket

传统的进程间通信-管道

管道是UNIX系统最古老的进程间通信方式(基本不再使用),历史上的管道通常是半双工的(只允许单向的数据流动),现在的大部分系统都可以全双工,数据可以双向流动

  1. 有名管道(创建实体文件)

    • 命令:mkfifo

    • 函数:int mkfifo(const char *pathname, mode_t mode);

      • 创建管道文件
      • pathname 文件路径
      • mode 权限
      • 返回值 0成功 -1失败
      • 编程模型
      进程A进程B
      创建管道mkfifo…
      打开管道open打开管道
      读写数据read/write读写数据
      关闭管道close关闭管道
      删除管道unlink…
a.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/type.h>
#include <fcntl.h>
#include <string.h>

int main(){

    //1.创建管道,一般在/temp目录下创建
    if(mkdifo("/tmp/fifo",0644)){
        perror("mkfifo");
        return -1;
    }
    //2.打开管道
    int fd = open("/tmp/fifo",O_WRONLY);//对方不打开管道就不会返回,程序停在这里
    if(0 > fd){
        perror("open");
        return -1;
    }
    //3.读写数据
    char buf[1024] = {};
    for(;;){
        printf(">");
        gets(buf);
        write(fd,buf,strlen(buf)+1);
        if(0 == strcmp("quit",buf)){
            printf("通信完成!\n");
            break;
        }
    }
    //4.关闭管道
    close(fd);
    //5.删除管道
    unlink("/tmp/fifo");

}

b.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/type.h>
#include <fcntl.h>
#

int main(){

    //1.打开管道
    int fd = open("/tmp/fifo",O_RDONLY);
    if(0 > fd){
        preror("open");
        return -1;
    }
    //2.读写数据
    char buf[1024] = {};
    for(;;){
        read(fd,buf,sizeof(buf));
        printf("read:%s\n",buf);
        if(0 == strcmp(buf,"quit")){
            printf("通信结束\n");
            break;
        }
    }
    //3.关闭管道
    close(fd);
}
  1. 无名管道(用于通过fork创建的父子进程之间的通信)

int pipe(int pipefd[2]);

  • 创建无名管道
  • pipefd 用来存储内核返回的文件描述符
    • pipefd[0] 用于读操作
    • pipefd[1] 用于写操作
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(){
    int pipefd[2] = {};
    //1.打开无名管道
    if(pipe(pipefd)){
        perror("pipe");
        return -1;
    }
    //2.创建进程
    pid_t id = fork();
    //3.父进程写
    if(id){
        //关闭读
        close(pipefd[0]);
        char buf[1024] = {};
        printf("我是父进程%u,我要和子进程%u通信了\n",getpid(),id);
        for(;;){
            printf(">");
            gets(buf);
            write(pipefd[1],buf,strlen(buf)+1);
            if(0 == strcmp("quit",buf)){
                printf("父进程通信结束!");
                close(pipefd[1]);
                return 0;
            }
        }
    }else{//子进程读
        //关闭写
        close(pipefd[1]);
        char buf[1024] = {};
        printf("我是子进程%u,我要和父进程%u通信了\n",getpid(),getppid());
        for(;;){
            read(piprfd[0],buf,sizeof(buf));
            printf("read:%s\n",buf);
            if(0 == strcmp("quit",buf)){
                printf("子进程通信完成!\n");
                close(pipefd[0]);
                return 0;
            }
        }
    }
}

练习1 使用有名管道进程通信,管道创建者读,对方写

homework
homework

练习2 使用无名管道进行通信,父进程读,子进程写

homework

XSI进程间通信

X/open组织为UNIX系统设计的一套进程间通信机制,有共享内存,消息队列,信号量

  1. IPC标识

    • 内核会为每个进程间通信对象维护一个IPC对象(XSI对象)
    • 该对象通过一个非负整数来引用(类似于文件描述符)
    • 与文件描述符不同的是,每用一个IPC对象,标识符持续+1,达到最大时再从零开始
    • IPC标识需要程序员自己创建(类似于创建文件)

  2. IPC键值

    • 创建IPC标识的依据(类似创建文件的文件名),也是一个非负整数
    1. 自定义(不建议,可能会冲突)
    2. 自动生成(项目的路径和项目的编号)
      • 注意 项目路径一定要有效路径
      • key_t ftok(const char *pathname, int proj_id);

  3. IPC对象的创建

    • IPC_PRIVATE 创建IPC对象时永远创建成功
    • IPC_CRETA 对象存在则获取,不存在则创建
    • IPC_EXCL 如果对象已经创建,则创建失败

  4. IPC对象销毁/控制用到的宏

    • IPC_STAT 获取IPC对象的属性
    • IPC_SET 设置IPC对象的属性
    • IPC_RMID 删除IPC对象

共享内存

内核中开辟的一块由IPC对象管理的内存,进程A和进程B都可以用自己的虚拟地址与它进程映射,这样进程A与进程B就共享同一块内核中的内存

特点

  1. 不需要复制信息,是最快的一种进程间通信
  2. 需要考虑同步问题(必须借助其他的机制,如信号)

编程模型

进程A进程B
生成IPC键值ftok生成IPC键值ftok
创建IPC对象(共享内存)shmget创建IPC对象(共享内存)shmget
映射共享内存shmat映射共享内存shmat
使用共享内存*ptr使用共享内存*ptr
取消映射shmdt取消映射shmdt
删除共享内存shmctl…

  • int shmget(key_t key, size_t size, int shmflg);

    • 创建/获取共享内存
    • key IPC键,由ftok函数生成
    • size 共享内存大小,最好是4096的整数倍,获取共享内存时,此值无效
    • shmflg
      • 0 获取共享内存
      • IPC_CREAT 创建
      • IPC_EXCL 如果存在则创建失败
      • 返回值 成功返回共享内存标识(IPC标识),失败 -1

  • void *shmat(int shmid, const void *shmaddr, int shmflg);

    • 映射共享内存
    • shmid 共享内存标识符,shmget函数的返回值
    • shmaddr 进程提供的虚拟地址,与内核中的内存映射用,也可以是NULL(内核会自动选择一个地址映射)
    • shmflg
      • 0 自动分配
      • SHM_RDONLY 只读权限
      • SHM_RND 当shmaddr为空时shmaddr向下取整页
    • 返回值 映射成功后的虚拟地址

  • int shmdt(const void *shmaddr);

    • 取消虚拟地址与共享内存的映射
    • shmaddr倍映射过的虚拟地址

  • int shmctl(int shmid, int cmd, struct shmid_ds *buf);

    • 删除共享内存,获取/设置共享内存的属性
    • shmid 共享内存标识符shmget的返回值
    • cmd
      • IPC_STAT 获取IPC对象的属性
      • IPC_SET 设置IPC对象的属性
      • IPC_RMID 删除IPC对象
struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Last change time */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
    shmatt_t        shm_nattch;  /* No. of current attaches 映射次数*/
    ...
};
struct ipc_perm {
    key_t          __key;    /* Key supplied to shmget(2) */
    uid_t          uid;      /* Effective UID of owner */
    gid_t          gid;      /* Effective GID of owner */
    uid_t          cuid;     /* Effective UID of creator */
    gid_t          cgid;     /* Effective GID of creator */
    unsigned short mode;     /* Permissions + SHM_DEST and
                                           SHM_LOCKED flags */
    unsigned short __seq;    /* Sequence number */
};

a.c
#include <stdio.h>
#include <unistd,h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys.shm.h>
#include <string.h>
#include <signal.h>
int main(){

    //创建IPC键
    key_t key = ftok(".",110);
    //创建共享内存
    int shmid = shmget(key,4096,IPC_CREAT);
    if(0 > shmid){
        perror("shmget");
        retunr -1;
    }
    //映射
    char* str = shmat(shmid,NULL,SHM_RND);
    if((void)*-1 == str){
        perror("shmat");
        return -1;
    }
    pid_t pid = 0;
    printf("请输入要通信的进程号:");
    scanf("%u",&pid);
    //使用
    for(;;){
        printf(">");
        gets(str);
        kill(pid,SIGINT);
        if(0 == strcmp("quit",str)){
            printf("通信结束\n");
            break;
        }
    }
    //取消映射
    if(0 > shmdt(str)){
        perror("shmdt");
        return -1;
    }
    //删除
    if( 0 > shmctl(shmid,IPC_RMID,NULL)){
        perror("shmctl");
        return -1;
    }
}

b.c
#include <stdio.h>
#include <unistd,h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys.shm.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
int main(){
    printf("我是进程%u\n",getpid());
    //创建IPC键
    key_t key = ftok(".",110);
    //获取共享内存
    int shmid = shmget(key,0,0);
    if(0 > shmid){
        perror("shmget");
        return -1;
    }
    //映射
    char* str = shmat(shmid,NULL,SHM_RND);
    if((void*)-1 == str){
        perror("shmat");
        return -1;
    }
    //使用
    void sigint(int sig){
        printf("read:%s\n",str);
        if(0 == strcmp("quit",str)){
            printf("通信结束\n");
            //取消映射
            if(0 > shmdt(str)){
                perror("shmdt");
                exit(0);
            }
        }
    }
    signal(SIGINT,sigint);
    pause();
}

消息队列

由内核管理的管道,可以按顺序发送消息包(消息类型+消息内容),可以全双工工作

  • int msgget(key_t key, int msgflg);

    • 创建/获取消息队列
    • key IPC键值，由ftok函数生成
    • msgflg
      • 0 获取消息队列
      • IPC_CREAT 创建队列
      • IPC_EXCL 如果存在则创建失败
    • 返回值 消息队列标识符

  • int msgsnd(int msqid, const void *msgp, size_t msgs_z, int msgflg);

    • 向消息队列发送消息
    • msqid 消息队列标识符msgget函数的返回值
    • msgp 结构指针
      struct msgbuf {
    long mtype;       /* message type, must be > 0 */
    char mtext[1];    /* message data */
};
    • 消息的长度,不包括消息类型,sizeof(msgbuf)-4
    • msgflg
      • 0 阻塞,当消息队列满时等待
      • IPC_NOWAIT 不阻塞,不等待
    • 成功0 失败-1

  • ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

    • 从消息队列获取消息
    • msqid 消息队列标识符msgget函数的返回值
    • msgp 结构指针
    • msgsz 要接收消息的长度，可以长一些
    • msgtyp 要接收消息的类型
      • 0 接收任意类型的消息(第一个)
      • > 0 只接收msgtyp类型的消息
      • < 0 接收消息队列中小于等于msgtyp绝对值的消息,取最小的哪个
    • msgflg
      • 0 阻塞,消息队列中是否有对应类型的消息,没有则等待
      • 1 不阻塞,消息队列中没有对用类型的消息,则返回
      • 当消息类型正确，而消息的实际长度大于msgsz，则不接收消息且返回-1
      • MSG_NOERROR 把多余的消息截去，成功接收
      • IPC_NOWAIT 如果消息队列没有要接收的数据,则不等待直接返回
      • MSG_EXCEPT 接收消息队列中第一个不是msgtyp的消息,需要编译时加-D_GNU_SUORCE 参数

  • int msgctl(int msqid, int cmd, struct msqid_ds *buf));

    • 删除消息队列,设置或获取消息队列的属性

    • msqid 消息队列标识符msgget函数的返回值

    • cmd

      • IPC_STAT 获取消息队列的属性
      • IPC_SET 设置消息队列的属性
      • IPC_RMID 删除消息队列

    • buf

      struct msqid_ds {
    struct ipc_perm msg_perm;     /* Ownership and permissions */
    time_t          msg_stime;    /* Time of last msgsnd(2) */
    time_t          msg_rtime;    /* Time of last msgrcv(2) */
    time_t          msg_ctime;    /* Time of last change */
    unsigned long   __msg_cbytes; /* Current number of bytes in
                                                queue (nonstandard) */
    msgqnum_t       msg_qnum;     /* Current number of messages
                                                in queue */
    msglen_t        msg_qbytes;   /* Maximum number of bytes
                                                allowed in queue */
    pid_t           msg_lspid;    /* PID of last msgsnd(2) */
    pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
        };

    • 返回值 成功0 失败-1

a.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <sreing.h>
#include <sts/msg.h>
#include "struct.h"
int main(){
    //创建消息队列
    int msgid = msgget(ftok(".",119),IPC_CREAT|IPC_EXCL|0644);
    if(0 > msgid){
        perror(msgget);
        return -1;
    }
    Msg msg = {666};
    for(;;){
        printf(">");
        gets(msg.data);
        msgsnd(msgid,&msg,sizeof(Msg)-sizeof(msg.type),0)
        if(0 == strcmp("quit",msg.data)){
            printf("通信结束\n");
            break;
        } 

    }
    if(0 > msgctl(msgid,IPC_RMID,NULL)){
        perror("msgctl");
        return -1;
    }
    Msg msg = {};
    for(;;){
        msgrcv(msgid,&msg,sizeof(Msg),555,0);
        printf("read:%s\n",msg.data);
        if(0 == strcmp("quit",msg.data)){
            printf("通信结束\n");
            break;
        }
    }
}


b.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <sreing.h>
#include <sts/msg.h>
#include "struct.h"
int main(){
    //获取消息队列
    int msgid = msgget(ftok(".",119),0);
    if(0 > msgid){
        perror("msgget");
        return -1;
    }
    //


}




struct.h
typedef struct Msg{
    long type;
    char data[256];
}Msg;

  • msqid 消息队列标识符msgget函数的返回值

  • cmd

    • IPC_STAT 获取消息队列的属性
    • IPC_SET 设置消息队列的属性
    • IPC_RMID 删除消息队列

  • buf

    struct msqid_ds {
    struct ipc_perm msg_perm;     /* Ownership and permissions */
    time_t          msg_stime;    /* Time of last msgsnd(2) */
    time_t          msg_rtime;    /* Time of last msgrcv(2) */
    time_t          msg_ctime;    /* Time of last change */
    unsigned long   __msg_cbytes; /* Current number of bytes in
                                                queue (nonstandard) */
    msgqnum_t       msg_qnum;     /* Current number of messages
                                                in queue */
    msglen_t        msg_qbytes;   /* Maximum number of bytes
                                                allowed in queue */
    pid_t           msg_lspid;    /* PID of last msgsnd(2) */
    pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
        };

  • 返回值 成功0 失败-1

a.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <sreing.h>
#include <sts/msg.h>
#include "struct.h"
int main(){
    //创建消息队列
    int msgid = msgget(ftok(".",119),IPC_CREAT|IPC_EXCL|0644);
    if(0 > msgid){
        perror(msgget);
        return -1;
    }
    Msg msg = {666};
    for(;;){
        printf(">");
        gets(msg.data);
        msgsnd(msgid,&msg,sizeof(Msg)-sizeof(msg.type),0)
        if(0 == strcmp("quit",msg.data)){
            printf("通信结束\n");
            break;
        } 

    }
    if(0 > msgctl(msgid,IPC_RMID,NULL)){
        perror("msgctl");
        return -1;
    }
    Msg msg = {};
    for(;;){
        msgrcv(msgid,&msg,sizeof(Msg),555,0);
        printf("read:%s\n",msg.data);
        if(0 == strcmp("quit",msg.data)){
            printf("通信结束\n");
            break;
        }
    }
}


b.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <sreing.h>
#include <sts/msg.h>
#include "struct.h"
int main(){
    //获取消息队列
    int msgid = msgget(ftok(".",119),0);
    if(0 > msgid){
        perror("msgget");
        return -1;
    }
    //


}




struct.h
typedef struct Msg{
    long type;
    char data[256];
}Msg;

BroWuG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unix_Linux实验报告-考试.doc
12-14
在这个实验报告中，我们将学习和践行 Unix/Linux 操作系统的基本知识，包括文件权限管理、GCC 编译器的使用、断点调试、进程管理和管道通信等。 一、文件权限管理 在实验中，我们首先在 stu 目录下创建了一个以...
os-examination.rar_操作系统开发_Unix_Linux_
08-12
Linux操作系统在服务器市场占据主导地位，广泛应用于云计算、物联网和嵌入式系统。 试卷中可能涵盖的操作系统开发知识点包括： 1. **进程管理**：包括进程的概念、生命周期、状态转换、调度算法（如FCFS、SJF、...
进程间通信（四）有名管道
Fishfishfishfishcat
08-10 622
有名管道解决了无名管道进程只能是具有情缘关系的问题。 一、有名管道 有名管道或者叫做命名管道(named pipe)，他可以实现没有亲缘关系的进程间通信，方法是使用FIFO文件。 一般而言，Linux中的fifo文件存储在/tmp/my_fifo, shell中可以直接创建fifo: sudo mkfifo abc 然后进行读取和写入： cat < /tmp/abc & #让FIFO立刻打印收到的内容 echo "Hello world" > /tmp/abc #需要root权限，注
linux下的有名管道文件读写操作
热门推荐
tiramisu_L的博客
05-03 1万+
前言说明：宿主主机系统：window 7 旗舰版虚拟机：VMware 10.0.4操作平台：Ubuntu 12.04本文代码在个人电脑可以运行，不确保在其他平台可以正确运行这两天在学进程通信，学到管道通信，弄了有两天，今天才算能弄个明白，赶紧写来保存方便然后查看，如果能帮到大家就更好了。1、介绍：管道文件是linux下的一种特殊缓存文件（linux的文件其实都是对应底层的一种设备，管道文件和普通文...
Linux系统编程——进程间通信
Alliswell_WP
07-01 212
在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 目录：一、学习目标二、进程通信——管道1、管道的概念2、管道通信举例3、父子进程实现ps、grep命令4、ps、grep命令实现问题解决5、管道的读写行为6、管道大小和优劣三、进程通信——FIFO1、fifo实现通信写端2、fifo...
Linux自学笔记------Day01 基本概念
北慕辰的博客，欢迎各位大佬光临！！
04-27 1195
Linux自学笔记-----Day01基本概念  ------------------------------------持续更新中… 应用编程接口(application programming interface，简称API) 应用程序二进制接口(application binary interface，间标ABl) 文件： 文件偏移量（file position）= 文件位置（file offset） 文件的长度（length）: 以字节为度量单位   &
（七）linux操作系统-linux韩顺平2021笔记
sinat_39047902的博客
12-22 9757
linux韩顺平2021 文章目录linux韩顺平2021p1 课程内容基础篇实际操作篇2021高级篇p2 应用领域p3 概述p4 Linux和Unixp5 vmware15.5安装p6 centOS7.6安装p7 网络连接的三种方式p8 虚拟机克隆p9 虚拟机快照p10 虚拟机迁移和删除p11 vmtoolsp12 第4章 linux目录结构p13 第5章 远程登录到Linux服务器p14 远程登录p15 远程文件传输p16 vi和vim编辑器常用三种模式p17 vi和vim快捷键p18 vi vim 内
Linux系统编程【文件IO、进程、进程间通信、信号、线程、互斥】
最新发布
weixin_45045804的博客
09-29 1553
个人通过学习，手打了一份48000字的Linux系统编程的笔记，包含了【文件IO、进程、进程间通信、信号、多线程、互斥】等知识点，并给出了大量的代码案例对每个重要的知识点进行了代码演示，通过理论和实操的结合，更好的透析每个知识点，为后续的unix网络编程打下基础。
linux fifo通信,linux 进程间通信 之fifo
weixin_35637837的博客
05-14 960
上一篇博客已经介绍了一种进程间通信的方式，但是那只是针对于有血缘关系的进程，即父子进程间的通信，那对于没有血缘关系的进程，那要怎么通信呢？这就要创建一个有名管道，来解决无血缘关系的进程通信, fifo:book@ubuntu:~$ mkfifo xwpbook@ubuntu:~$ ls -l myfifoprw-rw-r-- book book Feb myfifomkfifo 既有命...
Linux操作系统学习笔记【入门必备】
weixin_55299624的博客
03-20 2265
Linux操作系统学习笔记【入门必备】
嵌入式学习DAY17 --- IO进程的学习
SpringWJN的博客
03-16 238
嵌入式入门学习笔记，遇到的问题以及心得体会！ DAY14 概述： 什么是IO 什么是标准IO 什么是文件IO 文件IO和标准IO的区别 什么时候使用标准IO和文件IO 标准IO的特点 标准IO的接口 笔记： 什么是IO 凡是操作输入输出的都是IO 操作文件属于IO 在Linux/类Unix系统中，操作设备也是IO 什么是标准IO 标准IO是由ANSI C定义的一组操作IO的接口函数。是由标准C库提供。 只要安装了标准C库，就能够使用标准IO。 什么是文件IO 文件IO是类Unix操作系统提供给
linux_das-http-server.rar_Linux/Unix编程_Unix_Linux_
08-12
在IT领域，Linux和Unix操作系统是服务器环境中的重要组成部分，尤其在互联网服务方面，它们扮演着核心角色。本文将深入探讨“Linux_DAS HTTP Server”的相关知识点，这是一款基于Linux/Unix系统的HTTP服务器软件，...
os.rar_操作系统开发_Unix_Linux_
08-12
在"os.rar"这个压缩包中，我们聚焦于操作系统开发，特别是针对Unix和Linux这两个经典的操作系统环境。这些课件来自于浙江大学的"操作系统原理"课程，为深入理解操作系统的工作原理和设计提供了宝贵的教育资源。 ...
uCOSII.rar_操作系统开发_Unix_Linux_
08-12
《uCOSII操作系统开发在Unix/Linux环境中的应用详解》 在现代嵌入式系统设计中，操作系统（OS）扮演着至关重要的角色。本文将聚焦于一个广泛应用的实时操作系统（RTOS）——uCOSII，它是专为微控制器设计的轻量级、...
C++父类与子类间构造，析构，拷贝的调用关系
BroWuG的博客
08-20 1590
C++父类与子类间构造，析构，拷贝的调用关系 构造 子类的构造在执行它的构造函数前会根据继承表的顺序执行父类的构造函数 默认执行无参构造 #include <iostream> #include <stdio.h> #include <cstring> using namespace std; class Base { char *str; pu...
标准IO和系统IO写入速度比较
BroWuG的博客
07-25 690
标准IO和系统IO写入速度比较 众所周知，标准IO的速度要比系统IO快。 那为什么系统调用要比标准C库调用慢呢？ 测试: #include <fcntl.h> #include <stdio.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> void s...
C++typeid
BroWuG的博客
08-24 483
类型信息 typeid 用于获取数据的类型信息,返回type_info类型临时对象 name成员函数,可以获取类型的名字,内建类型名字使用缩写 同时还支持 == != 运算符,用来比较是否是同一类型 如果用于判断父子类的指针或引用,它不能准确判断出实际的对象类型,但可以判断出具有多态基础的关系的父子类的指针或引用,它的实际类型的对 ...
数据结构和算法-笔记
BroWuG的博客
07-23 453
数据结构和算法 数据结构 + 算法 = 程序 —— 高纳德 数据结构不是一门研究数据计算的学科，而是研究数据与数据之间的关系的 数据结构 术语 数据：能够输入到计算机的描述客观事物的符号 数据项：描述事物的其中一项指标 数据元素：用于描述一个完整的事物 数据结构：由数据元素和元素关系构成的一个整体 算法：数据结构所具备的功能（解决问题的方法） 4种基本类型的数据结构（逻辑结构） ...
UNIX_Linux操作系统内核：程序执行与系统结构解析
“程序的执行-UNIX_Linux操作系统内核结构1-6章。” 这篇内容主要介绍了UNIX_Linux操作系统的内核结构以及程序执行的过程，强调了操作系统的核心特点和教学目标。以下是相关知识点的详细说明： 1. **程序的执行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值