C++ 进程间通信（管道）

已于 2022-03-16 16:52:51 修改
阅读量2.4k 收藏 7
点赞数 5
于 2022-03-11 16:49:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/future_dreams/article/details/123428904
版权

c++ visual studio mfc

进程间通信（封装级别）、可拿入项目中直接使用！！！！！

**

PipeCS.h文件

**

#pragma once
#include <Windows.h>
#include <string>
#include <thread>
#include <iostream>
#include <atomic>
#include <iostream>

class CPipeBase
{
public:
    CPipeBase() = default;
    virtual ~CPipeBase() = default;

    typedef std::function<void(const std::string &szMsg)> TMessageHandler;

protected:
    bool ReadPipe(HANDLE hNamedPipe, std::string &szMsg);
    bool WritePipe(HANDLE hNamedPipe, const std::string &szMsg);
};

class CPipeServer : public CPipeBase
{
public:
    CPipeServer(const std::string &szPipeName, TMessageHandler fnMsgHandler);
    CPipeServer(const CPipeServer &Other) = delete;
    CPipeServer(CPipeServer &&Other) = delete;
    ~CPipeServer();

    CPipeServer& operator=(const CPipeServer &Other) = delete;
    CPipeServer& operator=(CPipeServer &&Other) = delete;

    void Run();
    void Stop();
    bool SendMsg(const std::string &szMsg);

private:
    bool ConnectClient();
    void DisconnectClient();
    bool CreatePipeInstance(const std::string &szPipeName, HANDLE &hPipeInstance);
    void Close();

private:
    std::string m_szPipeName;
    TMessageHandler m_fnMsgHandler;
    HANDLE m_hNamedPipeR;
    HANDLE m_hNamedPipeW;
};

class CPipeClient : public CPipeBase
{
public:
    CPipeClient(const std::string &szPipeName, TMessageHandler fnMsgHandler);
    CPipeClient(const CPipeClient &Other) = delete;
    CPipeClient(CPipeClient &&Other) = delete;
    ~CPipeClient();

    CPipeClient& operator=(const CPipeClient &Other) = delete;
    CPipeClient& operator=(CPipeClient &&Other) = delete;

    bool IsConnected() const;
    bool Connect(unsigned int nTimeoutSeconds);
    void Disconnect();

    bool SendMsg(const std::string &szMsg);

protected:
    bool SetMessageMode(HANDLE hNamedPipe);
    void ReadThreadProc();

private:
    std::string m_szPipeName;
    HANDLE m_hNamedPipeW;
    HANDLE m_hNamedPipeR;
    // 消息读取线程
    std::atomic_bool m_bThreadRun = false;
    std::thread m_ReadThread;
    TMessageHandler m_fnMsgHandler;
};

**

PipeCS.cpp文件

**

#include "PipeCS.h"

#define PIPE_BUF_SIZE 1024


bool CPipeBase::WritePipe(HANDLE hNamedPipe, const std::string &szMsg)
{
    if (hNamedPipe == INVALID_HANDLE_VALUE)
    {
        std::cout << "the pipe is invalid." << std::endl;
        return false;
    }

    DWORD dwWritedBytes = 0;
    DWORD dwTotalBytes = szMsg.size();
    DWORD dwSentBytes = 0;
    BOOL bResult = FALSE;

    do
    {
        bResult = ::WriteFile(hNamedPipe, &szMsg[dwSentBytes], dwTotalBytes - dwSentBytes, &dwWritedBytes, NULL);
        if (!bResult || dwWritedBytes == 0)
        {
            std::cout << "write message to pipe error: " << ::GetLastError() << std::endl;
            return false;
        }
        dwSentBytes += dwWritedBytes;
    } while (dwSentBytes < dwTotalBytes);

    return true;
}

bool CPipeBase::ReadPipe(HANDLE hNamedPipe, std::string &szMsg)
{
    szMsg.clear();

    if (hNamedPipe == INVALID_HANDLE_VALUE)
    {
        std::cout << "the pipe is invalid." << std::endl;
        return false;
    }

    bool bResult = false;
    DWORD dwError = ERROR_SUCCESS;
    DWORD dwReadBytes = 0;
    CHAR ReadBuf[PIPE_BUF_SIZE] = { 0 };
    bool bReadMore = false;

    do
    {
        if (::ReadFile(hNamedPipe, ReadBuf, PIPE_BUF_SIZE, &dwReadBytes, NULL))
        {
            // 读成功，跳出
            szMsg.append(ReadBuf, dwReadBytes);
            bResult = true;
            break;
        }

        dwError = ::GetLastError();
        if (dwError == ERROR_MORE_DATA)
        {
            // 没有读完，继续读
            szMsg.append(ReadBuf, dwReadBytes);
            bReadMore = true;
            continue;
        }

        // 其它错误，不再继续读
        bReadMore = false;
        if (dwError == ERROR_BROKEN_PIPE)
        {
            std::cout << "the pipe has disconnected." << std::endl;
        }
        else
        {
            std::cout << "read message from pipe error: " << dwError << std::endl;
        }
    } while (bReadMore);

    return bResult;
}

CPipeServer::CPipeServer(const std::string &szPipeName, TMessageHandler fnMsgHandler) :
    m_szPipeName(szPipeName), m_fnMsgHandler(fnMsgHandler)
{
    m_hNamedPipeR = INVALID_HANDLE_VALUE;
    m_hNamedPipeW = INVALID_HANDLE_VALUE;
}

CPipeServer::~CPipeServer()
{
    Close();
}

void CPipeServer::Run()
{
    std::cout << "pipe server will start." << std::endl;

    std::string szMsg;
    while (ConnectClient())
    {
        while (ReadPipe(m_hNamedPipeR, szMsg))
        {
            std::cout << "recv message success: " << szMsg;
            if (m_fnMsgHandler)
            {
                m_fnMsgHandler(szMsg);
            }
        }

        DisconnectClient();
    }

    Close();
    std::cout << "pipe server will exit." << std::endl;
}

void CPipeServer::Stop()
{
    Close();
}

bool CPipeServer::SendMsg(const std::string &szMsg)
{
    std::cout << "send message: " << szMsg << std::endl;
    bool bSuccess = WritePipe(m_hNamedPipeW, szMsg);
    std::cout << "send message " << (bSuccess ? "success." : "failed.") << std::endl;
    return bSuccess;
}

bool CPipeServer::ConnectClient()
{
    if (m_szPipeName.empty())
    {
        std::cout << "the pipe name is empty." << std::endl;
        return false;
    }

    std::string szFullName("\\\\.\\pipe\\");
    szFullName += m_szPipeName;

    std::cout << "create pipe server: " << m_szPipeName << std::endl;

    if (m_hNamedPipeR == INVALID_HANDLE_VALUE)
    {
        if (!CreatePipeInstance(szFullName, m_hNamedPipeR))
        {
            std::cout << "create pipe server for read failed." << std::endl;
            return false;
        }
        std::cout << "create pipe server for read ok." << std::endl;
    }
    std::cout << "wait for the client to connect read ..." << std::endl;
    if (!::ConnectNamedPipe(m_hNamedPipeR, NULL))
    {
        DWORD dwError = ::GetLastError();
        if (dwError != ERROR_PIPE_CONNECTED)
        {
            std::cout << "wait for the client to connect read error: " << dwError << std::endl;
            return false;
        }
    }

    std::cout << "client is connected." << std::endl;
    if (m_hNamedPipeW == INVALID_HANDLE_VALUE)
    {
        if (!CreatePipeInstance(szFullName, m_hNamedPipeW))
        {
            std::cout << "create pipe server for write failed." << std::endl;
            return false;
        }
        std::cout << "create pipe server for write ok." << std::endl;
    }
    std::cout << "wait for the client to connect write ..." << std::endl;
    if (!::ConnectNamedPipe(m_hNamedPipeW, NULL))
    {
        DWORD dwError = ::GetLastError();
        if (dwError != ERROR_PIPE_CONNECTED)
        {
            std::cout << "wait for the client to connect write error: " << dwError << std::endl;
            return false;
        }
    }

    std::cout << "connect pipe client success." << std::endl;
    return true;
}

void CPipeServer::DisconnectClient()
{
    if (m_hNamedPipeR != INVALID_HANDLE_VALUE)
    {
        ::DisconnectNamedPipe(m_hNamedPipeR);
    }

    if (m_hNamedPipeW != INVALID_HANDLE_VALUE)
    {
        ::DisconnectNamedPipe(m_hNamedPipeW);
    }
}

bool CPipeServer::CreatePipeInstance(const std::string &szPipeName, HANDLE &hPipeInstance)
{
    hPipeInstance = ::CreateNamedPipeA(szPipeName.c_str(),
        PIPE_ACCESS_DUPLEX,
        PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
        2,
        PIPE_BUF_SIZE,
        PIPE_BUF_SIZE,
        0,
        NULL);
    if (hPipeInstance == INVALID_HANDLE_VALUE)
    {
        std::cout << "create pipe server error: " << ::GetLastError() << std::endl;
        return false;
    }

    return true;
}

void CPipeServer::Close()
{
    if (m_hNamedPipeR != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_hNamedPipeR);
        m_hNamedPipeR = INVALID_HANDLE_VALUE;
    }

    if (m_hNamedPipeW != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_hNamedPipeW);
        m_hNamedPipeW = INVALID_HANDLE_VALUE;
    }
}

//
//

CPipeClient::CPipeClient(const std::string &szPipeName, TMessageHandler fnMsgHandler) :
    m_szPipeName(szPipeName), m_fnMsgHandler(fnMsgHandler)
{
    m_hNamedPipeW = INVALID_HANDLE_VALUE;
    m_hNamedPipeR = INVALID_HANDLE_VALUE;
}

CPipeClient::~CPipeClient()
{
    Disconnect();
}

bool CPipeClient::IsConnected() const
{
    return (m_hNamedPipeW != INVALID_HANDLE_VALUE && m_hNamedPipeR != INVALID_HANDLE_VALUE);
}

bool CPipeClient::Connect(unsigned int nTimeoutSeconds)
{
    if (IsConnected())
    {
        std::cout << "the pipe server is connected." << std::endl;
        return true;
    }

    if (m_szPipeName.empty())
    {
        std::cout << "the pipe server name is empty." << std::endl;
        return false;
    }

    std::string szFullName("\\\\.\\pipe\\");
    szFullName += m_szPipeName;

    std::cout << "connect to pipe server: " << m_szPipeName << " in " << nTimeoutSeconds << "s." << std::endl;

    int64_t nTimeoutMs = nTimeoutSeconds * 1000;
    DWORD dwError = ERROR_SUCCESS;

    do
    {
        // 先连接写管道，再连接读管道
        if (m_hNamedPipeW == INVALID_HANDLE_VALUE)
        {
            m_hNamedPipeW = ::CreateFileA(szFullName.c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
            if (m_hNamedPipeW == INVALID_HANDLE_VALUE)
            {
                dwError = ::GetLastError();
            }
            else
            {
                SetMessageMode(m_hNamedPipeW);
            }
        }
        else if (m_hNamedPipeR == INVALID_HANDLE_VALUE)
        {
            m_hNamedPipeR = ::CreateFileA(szFullName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
            if (m_hNamedPipeR == INVALID_HANDLE_VALUE)
            {
                dwError = ::GetLastError();
            }
            else
            {
                SetMessageMode(m_hNamedPipeR);
                std::cout << "connect to pipe server ok." << std::endl;
                m_bThreadRun = true;
                m_ReadThread = std::thread(&CPipeClient::ReadThreadProc, this);
                return true;
            }
        }

        if (nTimeoutSeconds == 0)
        {
            std::cout << "connect to pipe server error: " << dwError << std::endl;
            break;
        }
        if (nTimeoutMs <= 0)
        {
            std::cout << "connect to pipe server timeout: " << dwError << std::endl;
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        nTimeoutMs -= 100;
    } while (true);

    return false;
}

void CPipeClient::Disconnect()
{
    if (m_hNamedPipeW != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_hNamedPipeW);
        m_hNamedPipeW = INVALID_HANDLE_VALUE;
    }

    if (m_hNamedPipeR != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_hNamedPipeR);
        m_hNamedPipeR = INVALID_HANDLE_VALUE;
    }

    m_bThreadRun = false;
    if (m_ReadThread.joinable())
    {
        m_ReadThread.join();
    }
}

bool CPipeClient::SendMsg(const std::string &szMsg)
{
    bool bSuccess = false;
    std::cout << "send message: " << szMsg << std::endl;
    if (m_bThreadRun)
    {
        bSuccess = WritePipe(m_hNamedPipeW, szMsg);
    }
    std::cout << "send message " << (bSuccess ? "success." : "failed.") << std::endl;
    return bSuccess;
}

bool CPipeClient::SetMessageMode(HANDLE hNamedPipe)
{
    // 检查是否为消息模式
    DWORD dwMode = 0;
    if (!::GetNamedPipeHandleStateA(hNamedPipe, &dwMode, NULL, NULL, NULL, NULL, 0))
    {
        std::cout << "query the state of server error: " << ::GetLastError() << std::endl;
        return false;
    }

    if (dwMode != PIPE_READMODE_MESSAGE)
    {
        dwMode = PIPE_READMODE_MESSAGE;
        if (!::SetNamedPipeHandleState(hNamedPipe, &dwMode, NULL, NULL))
        {
            std::cout << "change to message-read mode error: " << ::GetLastError() << std::endl;
            return false;
        }
    }

    std::cout << "change to message-read mode ok." << std::endl;
    return true;
}

void CPipeClient::ReadThreadProc()
{
    std::cout << "read message thread begin." << std::endl;  

    while (m_bThreadRun)
    {
        std::string szMsg;
        if (!ReadPipe(m_hNamedPipeR, szMsg))
        {
            m_bThreadRun = false;
            break;
        }

        if (szMsg.empty())
        {
            continue;
        }

        if (m_fnMsgHandler)
        {
            m_fnMsgHandler(szMsg);
        }
    }

    std::cout << "read message thread end." << std::endl;
}
I love LiLi
关注
【并发编程三】C++进程通信——管道（pipe)
junxuezheng的博客
11-09 7880
匿名管道只能用于父子进程间通信 ，不能跨网络通信，并且通信是单向。另外，管道传输的数据是⽆格式的流且⼤⼩受限。正常情况下，控制台进程的输输入出是在控制台窗口的，但是如果我们在创建子进程的时候指定了其输入输出，那么子进程就会从我们的管道读数据，把输出数据写到我们指定的管道。这就是我们代码中重定向标准输入的原因，否则system(“pause”）会无效。命名管道，顾名思义，这个管道肯定是有名字的。通过管道的名字来确保多个进程访问同一个管道。
C++管道通信，PipeCommunication.zip
10-08
C++Pipe两个应用程序之间使用管道进行通信，一个程序发送数据，一个程序接收数据。该教程使用C++语言命令行模式运行。
c++ 进程间通信之管道
weixin_44197671的博客
03-28 620
进程间通信的方式有很多：匿名管道，有名管道，win32 WM_COPYDATA, 共享内存，消息队列，本地起socket ，或者本地起websockt。等等。问题背景：windows c++程序和 QT已支持跨平台的项目，做进程间通信传输数据。QT项目接洽了electron，electron不支持管道通信，所以管道排除，因为跨平台，win32的WM_COPYDATA也排除。
C++多进程之间通讯
最新发布
xutaoshuaiqi的博客
08-08 1000
是操作系统分配资源的基本单位，包括代码、数据和系统资源。每个进程都有自己独立的地址空间，因此进程之间不能直接访问彼此的内存。：是操作系统能够进行运算调度的最小单位。线程是进程的一个实体，是进程中的实际运行单位，线程拥有自己的堆栈和局部变量。线程之间可以直接访问彼此的内存。在 C++ 中，用于创建和管理线程，而不是进程。如果你需要创建进程，你可以使用std::async或者操作系统提供的 API，例如在 Unix 系统上使用fork()函数，或者在 Windows 系统上使用函数。
C/C++ 进程间通信 管道
weixin_30682127的博客
08-22 151
使用匿名管道 一、什么是管道 如果你使用过Linux的命令，那么对于管道这个名词你一定不会感觉到陌生，因为我们通常通过符号“|"来使用管道，但是管理的真正定义是什么呢？管道是一个进程连接数据流到另一个进程的通道，它通常是用作把一个进程的输出通过管道连接到另一个进程的输入。 举个例子，在shell中输入命令：ls -l | grep string，我们知道ls命令（其实也是一个进程）会把...
C++管道通信.zip
04-12
C++管道通信项目，包括服务端和客户端两部分，运行时先运行服务端项目，然后再运行客户端，服务端运行时会等待管道连接，客户端运行时可建立管道，从而实现管道通信（亲测可用）。
C++管道通信类封装
MusicMan
01-11 1942
简单的介绍一下，管道通信类 指的是 IPC通信中的一种，即两个不同的进程之间的通信 现在实现一下管道通信类，方便以后调用使用 头文件（引用相关的库） // stdafx.h : 标准系统包含文件的包含文件， // 或是经常使用但不常更改的 // 特定于项目的包含文件 // #pragma once #include "targetver.h" #include <stdio.h&g...
C#与C++进程间通信
09-14
本示例以“C#与C++进程间通信”为主题，利用命名管道（Named Pipe）作为通信媒介，实现了不同类型数据结构的高效传输。 命名管道是一种在操作系统中提供半双工或全双工通信的机制，适用于在同一台计算机上的进程间...
C++进程间通信源码.zip
04-03
这里的"C++进程间通信源码.zip"包含了一些示例代码，帮助开发者理解和实践C++中的IPC技术。下面将详细阐述C++进程间通信的相关知识点。 1. **管道(Pipes)** 管道是最简单的IPC形式之一，分为无名管道和命名管道。...
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信
进程间通信管道篇（匿名管道，命名管道）
Odfogy的博客
10-25 461
目录一、匿名管道1.管道的概念2、管道与进程通信的关系3、建立管道4、单个进程使用管道读写5、实现两个进程间的匿名管道通信二、命名管道1.引入库2.读入数据总结 一、匿名管道 1.管道的概念 管道就是内存中由操作系统维护的一块缓冲区。 2、管道与进程通信的关系 进程之间通信时通过管道作为中转站，一个输入一个读取，减少接口的复杂度。 3、建立管道 int pipe(int pipefd[2]); 参数:整型数组，数组中保存是是文件描述符，分别是可读和可写。数组内的两个文件描述符都是是直接由pipe函数进行
C++ MFC之进程间通信（匿名管道）
09-07
本实例利用匿名管道技术实现多进程之间的通信，实现了进程之间的发送数据和接收数据。
Visual C++实现命名管道的通信
05-18
Visual C++实现命名管道的通信 简单可行
使用C++管道实现进程间的通信，ui是基于qt开发的。
05-17
使用c++中的管道实现两个进程间的通信，文件中有服务器端和客户端两个部分，全部是基于qt写的。
进程通信——管道通信
11-28
进程间通信，命名管道通信，MFC实现，从原项目拷贝出来
C++ 进程通信 管道
大地缸的专栏
01-13 509
// OpenPipe.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include using namespace std; HANDLE hPipe; void OpenPipe() { hPipe = CreateFileA("\\\\.\\Pipe\\pipe_xg", GENERIC_READ |
【C++服务器入门基础------4.IPC进程间通信--管道】
qq_39583373的博客
02-22 1678
c++服务器入门系列 大学生寒假在家里过于无聊，整理一下以前学过的知识，顺便复习一下，水平较低，专业性不强，仅供参考。
C++有名管道通信简单示例
MusicMan
01-03 1635
有名管道，简单的理解可以理解成，一个通过命名不同来实现通信的一种方式。 简单的有名管道实现逻辑如下： * 1. CreateNamedPipe 创建一个有名管道，在系统中 * 2。::ConnectNamedPipe 监听客户端的连接，获取数据 作为客户端而言 1.::WaitNamedPipe(PIPE_CLIENT_NAME, NMPWAIT_WAIT_FOREVER)// 连接到有名管...
2024年C C++最新进程间通信 之 管道_进程管道通信，2024年最新面试学习
2401_84978673的博客
05-13 333
通常情况下，每个进程都会拥有一个独立的地址空间和资源，这会导致进程的创建和销毁需要耗费大量的时间和资源。当有任务需要执行时，只需要将任务交给其中一个空闲的子进程即可，不需要重复地创建和销毁进程。**进程池（Process Pool）**是一种并发编程的技术，它允许创建一组预先分配的子进程，这些子进程可以被重复地使用来执行任务。进程池通常由一个主进程（也称为管理进程）和一组子进程组成。主进程负责管理子进程的创建、销毁和任务分配，而子进程则负责执行实际的任务。下面这段代码创建了一个简单的单向通信的管道。
mfc 进程间通信 管道 双向
09-28
在MFC中，使用管道进行进程间通信可以分为两个步骤：创建管道和使用管道进行通信。 首先，需要创建一个管道。可以使用CreatePipe函数来创建匿名管道，它接受两个参数，第一个参数是用于接收管道句柄的指针，第二个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

I love LiLi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值