day33（前面几天在做项目）

管道和消息队列都是进程间通信的方式，但它们有一些不同之处。下面是管道和消息队列的对比

1. 缓冲区大小：管道的默认缓冲区大小较小，只有4K，而消息队列没有固定的缓冲区大小限制

2. 通信方式：管道是一种单向通信方式，适合父子进程间的通信，如果要实现双向通信，需要建立两个管道。而消息队列可以实现多对多的通信，多个进程可以同时发送和接收消息

3. 数据边界：管道使用流式的发送接收机制，数据本身没有边界，需要应用程序自己解释。而消息队列中的每个数据块被认为含有一个类型，接收进程可以独立地接收含有不同类型值的数据块。

4. 适用范围：管道适合于父子进程间的通信，但不适合多个子进程，因为消息可能会乱。而消息队列独立于发送和接收进程而存在，可以解决多个进程之间的通信问题。

综上所述，管道适合于父子进程间的单向通信，而消息队列适合于多个进程之间的多对多通信，并且可以发送含有不同类型值的数据块。

1.函数:
    1.函数的定义
    2.函数的调用
    3.函数的声明

2.函数传参:
    1.赋值传递（复制传递）
        函数体内部想要使用函数体外部变量值的时候使用复制传递

    2.全局变量传递

    3.地址传递
        函数体内部想要修改函数体外部变量值的时候使用地址传递
        函数体内想修改函数体外指针变量值的时候传指针变量的地址即二级指针
    
    4.整形数组传递
        int a[5] = {1, 2, 3, 4, 5};

        int Fun(int parray[5]);
        int Fun(int parray[], int len);
        int Fun(int *parray, int len);
    
    5.字符型数组和字符串的传递
        char str[32] = {"hello world"};

        int Fun(char *pstr);

    6.整形二维数组传递
        int a[2][3] = {1, 2, 3, 4, 5, 6};

        int Fun(int (*parray)[3], int len);

    7.字符型二维数组传递
        char str[5][32] = {"hello", "world", "how", "are", "you"}; 

        int Fun(char (*pstr)[32], int len);
    
    8.指针数组传递
        char *pstr[5] = {NULL};

        int Fun(char **ppstr, int len);

    9.结构体变量传递
        struct student s;

        int Fun(struct student tmp);

    10.结构体指针传递
        struct student s;

        int Fun(struct student *ps);

    11.结构体数组传递 
        struct student stu[3];

        int Fun(struct student *pstu, int len);

=========================================================================
消息队列、共享内存、信号灯:
1.IPC对象:
    内存文件

    1.ipcs 
      查看系统重的消息队列、共享内存、信号灯的信息
    2.ipcrm
      删除消息队列、共享内存、信号灯
      ipcrm -Q/-M/-S key
      ipcrm -q/-m/-s 消息队列ID/共享内存ID/信号灯ID
      
    3.操作流程:
        创建消息队列 -> 发送消息 -> 接收消息

    4.函数接口:
        1.ftok
          key_t ftok(const char *pathname, int proj_id);
          功能:
            根据pathname和proj_id生成一个key_t类型的key值,将来可以用来创建消息队列、共享内存、信号灯
          参数:
            pathname:文件路径
            proj_id:8位非0值
          返回值:
            成功返回key_t类型的IPC对象的key值
            失败返回-1 

        2.msgget 
          int msgget(key_t key, int msgflg);
          功能:
            根据key值对象的IPC对象创建一个消息队列
          参数:
            key:IPC对象名字 
            msgflg:IPC_CREAT    对象不存在就创建
                   IPC_EXCL     对象存在报错
                   IPC_CREAT | 0664 
          返回值:
            成功返回消息队列ID
            失败返回-1 

        3.msgsnd 
          int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
          功能:
            向消息队列中发送消息
          参数:
            msqid:消息队列的ID号
            msgp:发送消息空间的首地址
                struct msgbuf {
                    long mtype;       /* message type, must be > 0 */
                    char mtext[1];    /* message data */
                };
            msgz:发送消息内容的大小(不包含发送消息类型)
            msgflg:属性,默认为0
          返回值:
            成功返回0 
            失败返回-1 

        4.msgrcv 
          ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
          功能:
            从消息队列中接收消息
          参数:
            msqid:消息队列的ID号 
            msgp:存放接收到消息空间的首地址
            msgsz:最多接收消息的空间的大小
            msgtyp:想要接收消息的类型
            msgflg:属性，默认为0 
          返回值:
            成功返回实际接收的字节数
            失败返回-1 

        5.msgctl 
          int msgctl(int msqid, int cmd, struct msqid_ds *buf);
          功能:
            向消息队列发送一条cmd命令
          参数:
            msqid:消息队列的ID号
            cmd:IPC_RMID    删除消息队列 
            buf:默认传NULL
          返回值:
            成功返回0 
            失败返回-1 

练习:编写2个进程任务(recv.c send.c),send.c从终端接收一个字符串利用消息队列发送给recv.c
                                   recv.c从消息队列中接收消息并打印在终端

2.共享内存:
    进程间通信最高效的形式

    1.操作方式:
        创建共享内存 -> 映射到共享内存中 -> 共享内存操作 -> 解除映射 -> 删除共享内存 

    2.函数接口:
        1.ftok 
        
        2.shmget 
          int shmget(key_t key, size_t size, int shmflg);
          功能:
            创建一个共享内存
          参数:
            key:IPC对象名称
            size:共享内存的大小
            shmflg:
                IPC_CREAT 
                IPC_EXCL 
          返回值:  
            成功返回共享内存ID
            失败返回-1 
        
        3.shmat
          void *shmat(int shmid, const void *shmaddr, int shmflg);
          功能:
            将一个地址映射到共享内存中
          参数:
            shmid:共享内存ID号
            shmaddr:NULL     让系统选择一个合适的地址映射
                    不为NULL shmflg 设定为SHM_RND 选择离给定地址最近的能够映射的地址进行映射
                             否则传递地址为4k的整数倍
          返回值:
            成功返回映射到共享内存空间中的地址
            失败返回NULL

        4.shmdt 
          int shmdt(const void *shmaddr);
          功能:
            解除映射 
          参数:
            shmaddr:映射的地址
          返回值:
            成功返回0 
            失败返回-1 

        5.shmctl
          int shmctl(int shmid, int cmd, struct shmid_ds *buf);
          功能:
            向共享内存发送命令
          参数:
            shmid:共享内存ID号
            cmd:IPC_RMID    删除共享内存
            buf:NULL 
          返回值:
            成功返回0 
            失败返回-1