精华内容
下载资源
问答
  • 2021-09-25 16:50:18

    c++管道的建立和使用

    pipe函数建立的管道是半双工(只能一个方向上进行数据传输)的,socketpair函数建立的管道直接就可以实现全双工(数据可以在两个方向上进行数据传输)。
    socketpair对两个文件描述符中的任何一个都可读出和写入管道,所以实现父子进程之间数据传输只需要一个管道。而pipe是一个文件描述符pipefd[1]写入管道,一个文件描述符pipefd[0]读出管道,父子进程必须有一个关闭pipefd[0],另一个关闭pipefd[1],如果要实现父子进程之间的双向数据传输就要用两个管道。
    注意:管道中的数据只能被读取一次,也就是管道中的数据被读取之后就不再存在在管道中了。

    更多相关内容
  • C++管道通信.zip

    2020-04-12 20:55:25
    C++管道通信项目,包括服务端和客户端两部分,运行时先运行服务端项目,然后再运行客户端,服务端运行时会等待管道连接,客户端运行时可建立管道,从而实现管道通信(亲测可用)。
  • C++管道

    2022-05-11 17:15:49
    c++的命名管道和匿名管道

            管道是一种单向通信的方式,一般用于进程间通信,在零拷贝时也会用到管道。管道本质上是一个文件,一个进程读,一个进程写。但是管道本身不占用磁盘或者其他外部存储的空间。在Linux上它占用内存空间。所以管道就是一个操作方式为文件的内存缓冲区。也正是因为管道是内存中的,所以它比使用文件作通信更快。

    1.命名管道:

            命名管道需要包含头文件:#include <sys/types.h>   #include <sys/stat.h>

            命名管道相当于创建了一个有命的文件,那么任何进程只要知道它的文件名就可以使用该管道,因此它不受亲缘进程的影响。命名管道创建和使用方式与文件差距不大,它使用mkfifo创建并使用open,write和read来打开,写和读。但是一个进程对命名管道只可以读和写选一个,不可以即读又写。例:

    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <cstring>
    #include <cstdio>
    #include <iostream>
    
    const char buf[] = "hello";
    const int32_t bufSize = sizeof(buf);
    const char str[] = "/root/namePipe";
    
    int main()
    {
        //创建命名管道
        int32_t ret = mkfifo(str, S_IFIFO | 0666);
        if (ret == -1)
        {
            std::cout << "Make fifo error\n";
            return -1;
        }
        
        pid_t pid;
        pid = fork();
        if (pid > 0) {
            int32_t fd = open(str, O_WRONLY);
            if (write(fd, buf, bufSize) < 0) {
                std::cout << "write error\n";
            }
            close(fd);
            return 0;
        }
    
        sleep(1);
        char readBuf[bufSize];
        int32_t fd = open(str, O_RDONLY);
        if (read(fd, readBuf, bufSize) < 0) {
            std::cout << "read error\n";
        }
        else {
            std::cout << buf << '\n';
        }
        close(fd);
        return 0;
    }

             删除命名管道可以用linux的unlink命令

    unlink 管道名

    2.匿名管道:

            匿名管道使用pipe创建,需要包含头文件:#include <unistd.h>

            pipe会初始化一个int[2],其中一个只读,另一个只写。由于它没有文件名,只有int变量存储的文件描述符,因此只有有血缘关系的进程才能使用它通信。匿名管道用法如下:

    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <fcntl.h>
    #include <cstring>
    #include <cstdio>
    #include <iostream>
    
    int main()
    {
        int32_t pipeFd[2];
        if (pipe(pipeFd) == -1) {
            perror("Pipe failed:");
            return 0;
        }
    
        pid_t pid;
        pid = fork();
        if (pid > 0) {
            close(pipeFd[0]); //父进程只写,所以关闭读描述符
            char buf[] = "hello";
            if (write(pipeFd[1], buf, sizeof(buf)) < 0) {
                perror("Write error:");
            }
            close(pipeFd[1]);
            wait(nullptr); //防僵尸进程
            return 0;
        }
    
        close(pipeFd[1]); //子进程只读,关闭写描述符
        char buf[32];
        memset(buf, 0, 32);
        if (read(pipeFd[0], buf, 32) < 0) {
            perror("Read error:");
        }
        else {
            std::cout << buf << '\n';
        }
        close(pipeFd[0]);
    
        return 0;
    }

            需要注意的是如果所有管道的读描述符被关闭,那么写将阻塞。如果所有的写描述符已关闭,那么读将无法读到返回0。

    展开全文
  • C++Pipe两个应用程序之间管道通信,一个程序发送数据,一个程序接收数据。
  • 使用c++中的管道实现两个进程间的通信,文件中有服务器端和客户端两个部分,全部是基于qt写的。
  • linux c++ 管道操作

    2021-05-15 17:38:44
    } 管道,是一种半双工通信方式,也就是说,通信的两方一个只能读,一个只能写,而这是无名管道,所以使用方式只能是在父子进程之间, 管道的一般使用方式是进程在使用fork函数创建子进程先创建一个管道,该管道用于...

    /*

    * main.cpp

    *

    * Created on: Jul 16, 2014

    * Author: john

    */

    #include

    #include

    #include

    #include

    #include

    //read pipe

    void read_from_pipe(int fd)

    {

    char message[100]={0};

    read(fd,message,100);

    //for(int i=0;i<100;i++)

    printf("the pipe content is %s\n",message);

    }

    //write pipe

    void write_to_pipe(int fd)

    {

    char* msg="the pipe msg";

    write(fd,msg,strlen(msg));

    }

    int main()

    {

    int now;

    int fd[2];

    pid_t pid;

    if(pipe(fd))

    {

    printf("create pipe failed\n");

    exit(1);

    }

    pid=fork();

    switch(pid)

    {

    case -1:

    printf("fork error\n");

    exit(1);

    case 0:

    close(fd[1]);

    read_from_pipe(fd[0]);

    exit(0);

    default:

    close(fd[0]);

    write_to_pipe(fd[1]);

    wait(now);

    exit(0);

    }

    exit(0);

    }

    管道,是一种半双工通信方式,也就是说,通信的两方一个只能读,一个只能写,而这是无名管道,所以使用方式只能是在父子进程之间,

    管道的一般使用方式是进程在使用fork函数创建子进程先创建一个管道,该管道用于在父子进程之间通信,然后创建子进程,之后父进程,关闭管道的读端,子进程关闭管道的

    写端,或者反其道行之

    fd[0]是读端  fd[1]是写端

    如果某进程要读取管道中的信息那么应该先关闭fd[1],如果要写管道数据则关闭fd[0]

    展开全文
  • 如何实现简单的通信,在一台主机上,可以通过管道实现进程间的通信。 一、进程间的通信 我们通过有名管道即可实现简单的聊天,实现的思想如下,但是这样的会导致,一次只能发送一个,所以我们再添加了父子进程...


    前言

    如何实现简单的通信,在一台主机上,可以通过管道实现进程间的通信。
    在这里插入图片描述
    在这里插入图片描述


    一、进程间的通信

    在这里插入图片描述

    我们通过有名管道即可实现简单的聊天,实现的思想如下,但是这样的会导致,一次只能发送一个,所以我们再添加了父子进程,一个接受,一个发送。

    在这里插入图片描述

    二、实现的代码

    chatA.c

    #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<string.h>
    
    
    int main()
    {
        
    
            //判断有名管道文件是否存在
            int ret = access("fifo1",F_OK);
            if(ret==-1)
            {//文件不存在
                printf("管道不存在,创建对应的有名管道\n");
    
                ret = mkfifo("fifo1",0664);
    
                if(ret==-1)
                {
                    perror("mkfifo");
                    exit(0);
                }
            }
    
            ret = access("fifo2",F_OK);
            if(ret==-1)
            {//文件不存在
                printf("管道不存在,创建对应的有名管道\n");
    
                ret = mkfifo("fifo2",0664);
    
                if(ret==-1)
                {
                    perror("mkfifo");
                    exit(0);
                }
            }
    
            //以只写的方式打开管道fifo1
            int fdw = open("fifo1",O_WRONLY);
            if(fdw==-1)
            {
                perror("open");
                exit(0);
            }
            printf("打开管道fifo1成功,等待写入...\n");
    
            //以只读的方式打开管道fifo2
            int fdr = open("fifo2",O_RDONLY);
            if(fdr==-1)
            {
                perror("open");
                exit(0);
            }
            printf("打开管道fifo2成功,等待读取...\n");
    
            //创建子进程
        pid_t pid=fork();
    
        if(pid>0)
        {//父进程
            char bufw[128];
            while(1)
            {
                memset(bufw,0,128);
                //获取标准输入的数据
                fgets(bufw,128,stdin);
                //写数据
                int ret2= write(fdw,bufw,strlen(bufw));
                if(ret2==-1)
                {
                    perror("write");
                    exit(0);
                }
            }
    
            
        }
        else if(pid ==0)
        {//子进程
    
            char bufr[128];
            while(1)
            {
            memset(bufr,0,128);
            int ret3 = read(fdr,bufr,128);
            if(ret3<=0)
            {
                perror("read");
                break;
            }
            printf("buf:%s\n",bufr);
            }
    
            
        }
    
        close(fdw);
        close(fdr);
    
        return 0;
    
    }
    

    chatB.c

    #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<string.h>
    
    int main()
    {
        
    
            //判断有名管道文件是否存在
            int ret = access("fifo1",F_OK);
            if(ret==-1)
            {//文件不存在
                printf("管道不存在,创建对应的有名管道\n");
    
                ret = mkfifo("fifo1",0664);
    
                if(ret==-1)
                {
                    perror("mkfifo");
                    exit(0);
                }
            }
    
            ret = access("fifo2",F_OK);
            if(ret==-1)
            {//文件不存在
                printf("管道不存在,创建对应的有名管道\n");
    
                ret = mkfifo("fifo2",0664);
    
                if(ret==-1)
                {
                    perror("mkfifo");
                    exit(0);
                }
            }
    
             //以只读的方式打开管道fifo1
            int fdr = open("fifo1",O_RDONLY);
            if(fdr==-1)
            {
                perror("open");
                exit(0);
            }
            printf("打开管道fifo1成功,等待读取...\n");
    
             //以只写的方式打开管道fifo2
            int fdw = open("fifo2",O_WRONLY);
            if(fdw==-1)
            {
                perror("open");
                exit(0);
            }
            printf("打开管道fifo2成功,等待写入...\n");
    
        //创建子进程
        pid_t pid=fork();
    
        if(pid>0)
        {//父进程
            char bufr[128];
            while(1)
            {
                //读管道数据
                memset(bufr,0,128);
                int ret3 = read(fdr,bufr,128);
                if(ret3<=0)
                {
                    perror("read");
                    break;
                }
                printf("buf:%s\n",bufr);
            }
    
           
    
        }else if(pid==0)
        {//子进程       
            char bufw[128];
            while(1)
            {
                memset(bufw,0,128);
                fgets(bufw,128,stdin);
    
                int ret2 = write(fdw,bufw,strlen(bufw));
                if(ret2==-1)
                {
                    perror("write");
                    exit(0);
                }
            }
            
        }
    
    
         close(fdr);
         close(fdw);
    
         return 0;
    
    }
    

    总结

    这篇文章注意阐述了如何用有名管道实现简单的聊天。
    管道的特点:
    1.管道中数据的传递方向的单向的,一端用于写入,一端用于读取,管道是半双工的。
    2.从管道读取数据是一次性操作,数据一旦被读走,它就从管道中被抛弃,释放空间
    便写更多的数据,在管道中无法使用lseek()来随机的访问数据。
    3.匿名管道只能在具有关系的进程之间使用。
    
    展开全文
  • C++管道编程

    千次阅读 2019-04-05 08:39:48
    pipe:建立管道。 表头文件 #include<unistd.h> 定义函数 int pipe(int filedes[2]); 函数说明 pipe()会建立管道,并将文件描述词由参数filedes数组返回。 filedes[0]为管道里的读取端,filedes[1]则...
  • C++ 管道

    2015-08-01 12:33:00
    服务端: // PipeServer.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <windows.h> using namespace std; int _tmain(int argc, _TCHAR* argv... H...
  • C++管道通信类封装

    千次阅读 2020-01-11 14:24:23
    简单的介绍一下,管道通信类 指的是 IPC通信中的一种,即两个不同的进程之间的通信 现在实现一下管道通信类,方便以后调用使用 头文件(引用相关的库) // stdafx.h : 标准系统包含文件的包含文件, // 或是经常...
  • 匿名管道双向通讯,可用于替代windows cmd 接管adb输入输出。匿名管道双向通讯,可用于替代windows cmd 接管adb输入输出。
  • 1. 服务端用CreateNamedPipe创建一个命名管道并使用ConnectNamedPipe等待客户端的连接。 2. 客户端使用WaitNamedPipe连接成功后,用CreateFile打开管道并使用WriteFile向管道中写入一段数据(即向服务端发送消息)...
  • 最近写本地判题程序,有一步需要实现重定向子进程控制台程序的输入输出来与子进程交互,即让程序A向子进程B的stdin写入数据,并从子进程的stdout读出数据。 本以为只要用点>> 和<之类重定向符号就能解决,...
  • 仿照 Java8 Stream 实现的C++版本,使用时只需要包含一个头文件。 #include "stream.h" using namespace cpp::stream; 同时提供了 -> 和 >> 两种类型的操作符调用: ST3 arr[20] = { 0, 1, 2, 3, 4, 5, 6, ...
  • c/c++ 管道编程

    2016-07-05 15:51:02
    c/c++ 管道编程  (2011-05-28 11:38:02) 转载▼ 标签:  管道   句柄   进程   创建   函数   it 分类: programming 概述  管道(Pipe)实际是用于进程间通信的一段共享内存,创建...
  • c/c++管道、消息队列

    千次阅读 2017-03-29 17:26:18
    1.匿名管道和有名管道 匿名管道 匿名管道是一种进程之间进行单向通信的方式,由于其通信只是单方向的,所以起有以下缺点: 1.通信只是单方向的,通信太局限 2.其缓冲区大小是一定的,缓冲区满了之后就无法继续再...
  • C++实现进程通信(管道pipe)

    千次阅读 2021-12-03 16:54:44
    本节内容1、功能简介1.1 匿名管道1.2 命名管道2、匿名管道3、命名管道3.1 注意事项3.2 服务器3.2 客户端后记 1、功能简介 管道用于进程间共享数据,其实质是共享内存,常用IPC之一。管道不仅可以用于本机进程间通信...
  • 进程间通信,命名管道通信,MFC实现,从原项目拷贝出来
  • C++windows环境管道通信

    千次阅读 2020-08-19 17:07:28
    匿名管道主要用于本地父进程和子进程之间的通信,在父进程中的话,首先是要创建一个匿名管道,在创建匿名管道成功后,可以获取到对这个匿名管道的读写句柄,然后父进程就可以向这个匿名管道中写入数据和读取数据
  • c++与c#命名管道

    2019-04-13 21:53:24
    实现了c++与c#之间的命名管道通信,其中c++作为服务器端,c#作为客户端
  • C++ 进程间通信(管道

    千次阅读 2022-03-11 16:47:27
    干货,慢慢啃!!!!! ** PipeCS.h文件 ** #pragma once #include <Windows.h> #include <string> #include <thread> #include <iostream> #include <atomic>... virtu
  • C++命名管道详解及简单案例(基于VS2013),包括服务器端和客户端
  • 本实例利用命名管道实现进程间通信,实现了不同进程间的发送数据和接收数据功能。
  • linux C++ 有名管道_dasgk的专栏-CSDN博客 /* * main.cpp * * Created on: Jul 16, 2014 * Author: john */ #include<sys/types.h> #include<sys/stat.h> #include<string.h> #include...
  • MFC命名管道通信demo,由于只是简单的demo没有使用多线程. vs2005编译通过.
  • C++与Python通过命名管道进行通信 最近写项目用到了C++与Python,两个之间需要通信,所以就记录一下自己的学习过程防止自己忘记,代码主要参考这篇博主的博客,上链接: 参考博客 我主要需要的是C++发送,Python来...
  • 一、管道概述 1.1、管道概念 管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流(文件IO流)称为一个“管道”。 1.2、管道特点 管道是半双工的,数据只能向一个方向流动...
  • 这里给出一个写的比较清晰的管道通信的文章: https://www.cnblogs.com/boyxiao/archive/2011/01/02/1924188.html 项目场景: 场景: Windows下,进程间使用FIFO通信,用于传输视频帧。 问题描述: 1. 客户端第一...
  • c++服务器入门系列 大学生寒假在家里过于无聊,整理一下以前学过的知识,顺便复习一下,水平较低,专业性不强,仅供参考。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,230
精华内容 19,692
关键字:

c++ 管道

c++ 订阅
友情链接: OS_experiment.rar