进程间通信的实现（C++，python， 以及C++与python之间的通信）

最新推荐文章于 2024-03-20 20:14:19 发布
最新推荐文章于 2024-03-20 20:14:19 发布
阅读量3k 收藏 34
点赞数 7
分类专栏： C++ 个人总结 Linux学习 文章标签： c++ socket python 网络通信 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15390133/article/details/118277366
版权
个人总结 同时被 3 个专栏收录
83 篇文章 6 订阅
订阅专栏
Linux学习
8 篇文章 0 订阅
订阅专栏
C++
7 篇文章 0 订阅
订阅专栏

进程间的通信可以采用 管道， 消息队列，共享内存，信号量，套接字
本次尝试采用套接字的形式实现不同进程之间的数据交互

python 的socket实现（Tcp形式）
  1. 服务端， 采用tcp的形式完成数据的交互
import socket

send_data = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

send_data.bind(('127.0.0.1',5000))

send_data.listen(5)

conn,address = send_data.accept()

conn.send(bytes('hello',encoding='utf-8'))

send_data.close()
  1. 客户端，采用tcp的形式完成数据的交互
import socket

rece_data = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

rece_data.connect(("127.0.0.1",5000))

ret = rece_data.recv(1024)

print(str(ret))
python 的socket实现（Udp形式）两端绑定的是不同的端口
  1. 服务端， 采用udp的形式完成数据的交互。 与TCP不同的是，不需要listen 与accept
import socket

rece_data = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

rece_data.bind(('127.0.0.1',5500))

data, address = rece_data.recvfrom(1024)

print(str(data))

rece_data.close()
  1. 客户端，采用tcp的形式完成数据的交互
import socket

send_data = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

send_data.bind(('127.0.0.1',5000))

# send_data.recvfrom(1024)
send_data.sendto(bytes('hello',encoding='utf-8'),('127.0.0.1',5500))

send_data.close()
C++版本的socket编程示例：

参考链接：C语言基础-网络编程socket
服务端

/*
 * 程序名：client.cpp，此程序用于演示socket的客户端
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
int main(int argc,char *argv[])
{
  if (argc!=3)
  {
    printf("Using:./client ip port\nExample:./client 127.0.0.1 5005\n\n"); return -1;
  }
 
  // 第1步：创建客户端的socket。
  int sockfd;
  if ( (sockfd = socket(AF_INET,SOCK_STREAM,0))==-1) { perror("socket"); return -1; }
 
  // 第2步：向服务器发起连接请求。
  struct hostent* h;
  if ( (h = gethostbyname(argv[1])) == 0 )   // 指定服务端的ip地址。
  { printf("gethostbyname failed.\n"); close(sockfd); return -1; }
  struct sockaddr_in servaddr;
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(atoi(argv[2])); // 指定服务端的通信端口。
  memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
  if (connect(sockfd, (struct sockaddr *)&servaddr,sizeof(servaddr)) != 0)  // 向服务端发起连接清求。
  { perror("connect"); close(sockfd); return -1; }
 
  char buffer[1024];
 
  // 第3步：与服务端通信，发送一个报文后等待回复，然后再发下一个报文。
  for (int ii=0;ii<3;ii++)
  {
    int iret;
    memset(buffer,0,sizeof(buffer));
    sprintf(buffer,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    if ( (iret=send(sockfd,buffer,strlen(buffer),0))<=0) // 向服务端发送请求报文。
    { perror("send"); break; }
    printf("发送：%s\n",buffer);
 
    memset(buffer,0,sizeof(buffer));
    if ( (iret=recv(sockfd,buffer,sizeof(buffer),0))<=0) // 接收服务端的回应报文。
    {
       printf("iret=%d\n",iret); break;
    }
    printf("接收：%s\n",buffer);
  }
 
  // 第4步：关闭socket，释放资源。
  close(sockfd);
}
C++版本的socket编程 客户端
/*
 * 程序名：server.cpp，此程序用于演示socket通信的服务端
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
int main(int argc,char *argv[])
{
  if (argc!=2)
  {
    printf("Using:./server port\nExample:./server 5005\n\n"); return -1;
  }
 
  // 第1步：创建服务端的socket。
  int listenfd;
  if ( (listenfd = socket(AF_INET,SOCK_STREAM,0))==-1) { perror("socket"); return -1; }
 
  // 第2步：把服务端用于通信的地址和端口绑定到socket上。
  struct sockaddr_in servaddr;    // 服务端地址信息的数据结构。
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;  // 协议族，在socket编程中只能是AF_INET。
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);          // 任意ip地址。
  //servaddr.sin_addr.s_addr = inet_addr("192.168.190.134"); // 指定ip地址。
  servaddr.sin_port = htons(atoi(argv[1]));  // 指定通信端口。
  if (bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { perror("bind"); close(listenfd); return -1; }
 
  // 第3步：把socket设置为监听模式。
  if (listen(listenfd,5) != 0 ) { perror("listen"); close(listenfd); return -1; }
 
  // 第4步：接受客户端的连接。
  int  clientfd;                  // 客户端的socket。
  int  socklen=sizeof(struct sockaddr_in); // struct sockaddr_in的大小
  struct sockaddr_in clientaddr;  // 客户端的地址信息。
  clientfd=accept(listenfd,(struct sockaddr *)&clientaddr,(socklen_t*)&socklen);
  printf("客户端（%s）已连接。\n",inet_ntoa(clientaddr.sin_addr));
 
  // 第5步：与客户端通信，接收客户端发过来的报文后，回复ok。
  char buffer[1024];
  while (1)
  {
    int iret;
    memset(buffer,0,sizeof(buffer));
    if ( (iret=recv(clientfd,buffer,sizeof(buffer),0))<=0) // 接收客户端的请求报文。
    {
       printf("iret=%d\n",iret); break;  
    }
    printf("接收：%s\n",buffer);
 
    strcpy(buffer,"ok");
    if ( (iret=send(clientfd,buffer,strlen(buffer),0))<=0) // 向客户端发送响应结果。
    { perror("send"); break; }
    printf("发送：%s\n",buffer);
  }
 
  // 第6步：关闭socket，释放资源。
  close(listenfd); close(clientfd);
}
C++封装成类的形式（推荐）
服务端（推荐）
/*
 * 程序名：book248.cpp，此程序用于演示用C++的方法封装socket服务端
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
class CTcpServer
{
public:
  int m_listenfd;   // 服务端用于监听的socket
  int m_clientfd;   // 客户端连上来的socket
 
  CTcpServer();
 
  bool InitServer(int port);  // 初始化服务端
 
  bool Accept();  // 等待客户端的连接
 
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpServer();
};
 
int main()
{
  CTcpServer TcpServer;
 
  if (TcpServer.InitServer(5051)==false)
  { printf("TcpServer.InitServer(5051) failed,exit...\n"); return -1; }
 
  if (TcpServer.Accept() == false) { printf("TcpServer.Accept() failed,exit...\n"); return -1; }
 
  printf("客户端已连接。\n");
 
  char strbuffer[1024];
 
  while (1)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpServer.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    printf("接收：%s\n",strbuffer);
 
    strcpy(strbuffer,"ok");
    if (TcpServer.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
  }
 
  printf("客户端已断开连接。\n");
}
 
CTcpServer::CTcpServer()
{
  // 构造函数初始化socket
  m_listenfd=m_clientfd=0;
}
 
CTcpServer::~CTcpServer()
{
  if (m_listenfd!=0) close(m_listenfd);  // 析构函数关闭socket
  if (m_clientfd!=0) close(m_clientfd);  // 析构函数关闭socket
}
 
// 初始化服务端的socket，port为通信端口
bool CTcpServer::InitServer(int port)
{
  m_listenfd = socket(AF_INET,SOCK_STREAM,0);  // 创建服务端的socket
 
  // 把服务端用于通信的地址和端口绑定到socket上
  struct sockaddr_in servaddr;    // 服务端地址信息的数据结构
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;  // 协议族，在socket编程中只能是AF_INET
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 本主机的任意ip地址
  servaddr.sin_port = htons(port);  // 绑定通信端口
  if (bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { close(m_listenfd); m_listenfd=0; return false; }
 
  // 把socket设置为监听模式
  if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }
 
  return true;
}
 
bool CTcpServer::Accept()
{
  if ( (m_clientfd=accept(m_listenfd,0,0)) <= 0) return false;
 
  return true;
}
 
int CTcpServer::Send(const void *buf,const int buflen)
{
  return send(m_clientfd,buf,buflen,0);
}
 
int CTcpServer::Recv(void *buf,const int buflen)
{
  return recv(m_clientfd,buf,buflen,0);
}
客户端（推荐）
/*
 * 程序名：book247.cpp，此程序用于演示用C++的方法封装socket客户端
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
// TCP客户端类
class CTcpClient
{
public:
  int m_sockfd;
 
  CTcpClient();
 
  // 向服务器发起连接，serverip-服务端ip，port通信端口
  bool ConnectToServer(const char *serverip,const int port);
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpClient();
};
 
int main()
{
  CTcpClient TcpClient;
 
  // 向服务器发起连接请求
  if (TcpClient.ConnectToServer("127.0.0.1",5051)==false)
  { printf("TcpClient.ConnectToServer(\"127.0.0.1\",5051) failed,exit...\n"); return -1; }
 
  char strbuffer[1024];
 
  for (int ii=0;ii<5;ii++)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    sprintf(strbuffer,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    if (TcpClient.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
   
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpClient.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    printf("接收：%s\n",strbuffer);
  }
}
 
CTcpClient::CTcpClient()
{
  m_sockfd=0;  // 构造函数初始化m_sockfd
}
 
CTcpClient::~CTcpClient()
{
  if (m_sockfd!=0) close(m_sockfd);  // 析构函数关闭m_sockfd
}
 
// 向服务器发起连接，serverip-服务端ip，port通信端口
bool CTcpClient::ConnectToServer(const char *serverip,const int port)
{
  m_sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
 
  struct hostent* h; // ip地址信息的数据结构
  if ( (h=gethostbyname(serverip))==0 )
  { close(m_sockfd); m_sockfd=0; return false; }
 
  // 把服务器的地址和端口转换为数据结构
  struct sockaddr_in servaddr;
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(port);
  memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
 
  // 向服务器发起连接请求
  if (connect(m_sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
  { close(m_sockfd); m_sockfd=0; return false; }
 
  return true;
}
 
int CTcpClient::Send(const void *buf,const int buflen)
{
  return send(m_sockfd,buf,buflen,0);
}
 
int CTcpClient::Recv(void *buf,const int buflen)
{
  return recv(m_sockfd,buf,buflen,0);
}
C++与python通过socket实现数据之间的通信

demon功能： python打开本地端口，等待C++发送数据，如果在建立链接之后，C++端1秒内没有发送数据，python端则提示没有收到数据，关闭通信端口

python端采用多线程实现，开启一个定时线程，修改标志位
mport socket
import threading
import time

rece_data = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
rece_data.bind(('127.0.0.1',5051))
rece_data.listen(5)
conn, address = rece_data.accept()
time_over = False
lock = threading.Lock()
no_rece_data = False
def Rece():
    global time_over, no_rece_data
    while True:
        if not time_over:
            ret = conn.recv(1024)
            if(len(ret) == 0):
                no_rece_data = True
            print(ret.decode('utf-8'))
        else:
            break
    print("no data receive in 1s, begin to end the tcp conncect...")
    rece_data.close()

def Timer_Count():
    global time_over
    global lock,no_rece_data
    while True:
        time.sleep(1)
        if(no_rece_data):
            lock.acquire()
            time_over = True
            lock.release()

if __name__ == '__main__':
    t1 = threading.Thread(target=Rece)
    t2 = threading.Thread(target=Timer_Count)
    t1.setDaemon(False)
    t2.setDaemon(False)
    t1.start()
    t2.start()
    print("main init end...")
C++端和上述历程一致，取消接收数据的功能即可
/*
 * 程序名：book247.cpp，此程序用于演示用C++的方法封装socket客户端
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

 
// TCP客户端类
class CTcpClient
{
public:
  int m_sockfd;
 
  CTcpClient();
 
  // 向服务器发起连接，serverip-服务端ip，port通信端口
  bool ConnectToServer(const char *serverip,const int port);
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpClient();
};
 
int main()
{
  CTcpClient TcpClient;
 
  // 向服务器发起连接请求
  if (TcpClient.ConnectToServer("127.0.0.1",5051)==false)
  { printf("TcpClient.ConnectToServer(\"127.0.0.1\",5051) failed,exit...\n"); return -1; }
 
  char strbuffer[1024];
 
  for (int ii=0;ii<5;ii++)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    sprintf(strbuffer,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    if (TcpClient.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
    sleep(1);
    // memset(strbuffer,0,sizeof(strbuffer));
    // if (TcpClient.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    // printf("接收：%s\n",strbuffer);
  }
}
 
CTcpClient::CTcpClient()
{
  m_sockfd=0;  // 构造函数初始化m_sockfd
}
 
CTcpClient::~CTcpClient()
{
  if (m_sockfd!=0) close(m_sockfd);  // 析构函数关闭m_sockfd
}
 
// 向服务器发起连接，serverip-服务端ip，port通信端口
bool CTcpClient::ConnectToServer(const char *serverip,const int port)
{
  m_sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
 
  struct hostent* h; // ip地址信息的数据结构
  if ( (h=gethostbyname(serverip))==0 )
  { close(m_sockfd); m_sockfd=0; return false; }
 
  // 把服务器的地址和端口转换为数据结构
  struct sockaddr_in servaddr;
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(port);
  memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
 
  // 向服务器发起连接请求
  if (connect(m_sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
  { close(m_sockfd); m_sockfd=0; return false; }
 
  return true;
}
 
int CTcpClient::Send(const void *buf,const int buflen)
{
  return send(m_sockfd,buf,buflen,0);
}
 
int CTcpClient::Recv(void *buf,const int buflen)
{
  return recv(m_sockfd,buf,buflen,0);
}
C++ udp 示例程序：
服务端程序
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define SERV_PORT   5000

int main()
{
  /* sock_fd --- socket文件描述符 创建udp套接字*/
  int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
  if(sock_fd < 0)
  {
    perror("socket");
    exit(1);
  }

  /* 将套接字和IP、端口绑定 */
  struct sockaddr_in addr_serv;
  int len;
  memset(&addr_serv, 0, sizeof(struct sockaddr_in));  //每个字节都用0填充
  addr_serv.sin_family = AF_INET; //使用IPV4地址
  addr_serv.sin_port = htons(SERV_PORT); //端口
  /* INADDR_ANY表示不管是哪个网卡接收到数据，只要目的端口是SERV_PORT，就会被该应用程序接收到 */
  addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);  //自动获取IP地址
  len = sizeof(addr_serv);

  /* 绑定socket */
  if(bind(sock_fd, (struct sockaddr *)&addr_serv, sizeof(addr_serv)) < 0)
  {
    perror("bind error:");
    exit(1);
  }


  int recv_num;
  int send_num;
  char send_buf[20] = "i am server!";
  char recv_buf[20];
  struct sockaddr_in addr_client;

  while(1)
  {
    printf("server wait:\n");

    recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_client, (socklen_t *)&len);

    if(recv_num < 0)
    {
      perror("recvfrom error:");
      exit(1);
    }

    recv_buf[recv_num] = '\0';
    printf("server receive %d bytes: %s\n", recv_num, recv_buf);

    send_num = sendto(sock_fd, send_buf, recv_num, 0, (struct sockaddr *)&addr_client, len);

    if(send_num < 0)
    {
      perror("sendto error:");
      exit(1);
    }
  }

  close(sock_fd);

  return 0;
}
客户端程序
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


#define DEST_PORT 5000
#define DSET_IP_ADDRESS  "127.0.0.1"


int main()
{
  /* socket文件描述符 */
  int sock_fd;

  /* 建立udp socket */
  sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
  if(sock_fd < 0)
  {
    perror("socket");
    exit(1);
  }

  /* 设置address */
  struct sockaddr_in addr_serv;
  int len;
  memset(&addr_serv, 0, sizeof(addr_serv));
  addr_serv.sin_family = AF_INET;
  addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
  addr_serv.sin_port = htons(DEST_PORT);
  len = sizeof(addr_serv);


  int send_num;
  int recv_num;
  char send_buf[20] = "hey, who are you?";
  char recv_buf[20];

  printf("client send: %s\n", send_buf);

  send_num = sendto(sock_fd, send_buf, strlen(send_buf), 0, (struct sockaddr *)&addr_serv, len);

  if(send_num < 0)
  {
    perror("sendto error:");
    exit(1);
  }

  recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_serv, (socklen_t *)&len);

  if(recv_num < 0)
  {
    perror("recvfrom error:");
    exit(1);
  }

  recv_buf[recv_num] = '\0';
  printf("client receive %d bytes: %s\n", recv_num, recv_buf);

  close(sock_fd);

  return 0;
}
Chasing中的小强
关注
  • 7
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python进程间通信之共享内存详解
09-21
主要为大家详细介绍了Python进程间通信之共享内存的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++与Python之间跨进程通信（socket实现）
CYS_zxcvbnm的博客
08-13 5312
C++与Python之间跨进程通信（socket实现）1.引言2.实现思路3. 具体代码（1）Python服务端（2）C++客户端 1.引言 之前写过一篇Python调用C++程序的实现方法，这里相反，希望使用Python协助C++完成某些任务。一种解决思路为实现RPC调用，使用C++端（以下称客户端）发送数据，Python端（以下称服务端）处理数据并返回的方法，进一步来说，转换为C++与Python之间通信的问题。 2.实现思路 因为客户端可能希望使用的函数多种多样，这里为了保证灵活，服务端与客户端均
c++ queue用法_Python程序中的进程操作-进程间通信(multiprocess.Queue)
weixin_39626613的博客
01-29 147
进程间通信(multiprocess.Queue)IPC(Inter-Process Communication)二、队列2.1 概念介绍——multiprocess.Queue创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。Queue([maxsize])创建共享的进程队列。参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。...
如何实现C/C++与Python的通信
最新发布
2401_83239642的博客
03-20 1029
在实际开发中，我们经常需要将不同编程语言编写的模块进行集成和交互，其中C/C++由于其高效、底层特性常用于开发高性能计算、系统级应用，而Python则以其简洁易读、丰富的库资源适用于快速开发和数据分析。本文将详细介绍如何实现C/C++与Python之间的通信，主要涉及两种常见方式：Python扩展模块（C API 和 Cython）以及进程间通信（如通过管道、套接字或者队列等）。
Python 与 C++ 的进程通信
weixin_43152152的博客
11-09 5892
python与c++之间的进程通信：管道通信，socket，共享内存等
python&c++通过共享内存通信
明湖小虾的博客
11-04 6397
编程小白，第一次发CSDN博客。近期想要实现本机c++与python多进程间数据传输，找到了共享内存的方法，搜集借鉴了网络上大佬们的实现方法，最后自认为以最简单的方式实现了python进程间交换数据，python与c++之间交换数据以及c++进程之间交换数据。 c++和python都有类似的文件映射的功能，c++中为windows.h中的filemapping库，python则可以通过mmap包来实现。...
socket+多线程linux下简单实现python与C++进程通信(百来行代码 通俗易懂)
Thinkin9的博客
04-02 3899
本文在ubuntu16.04下实现了python向c++发送数据的socket通信，同时在两个进程中分别开启两个线程，主线程负责处理数据，子线程负责socket通信。
C++进程和Python进程通信
qq_28426719的博客
03-20 2235
项目研发过程中用到了进程通信，由C++应用程序创建共享内存及两个同步事件(Event1、Event2)，然后阻塞等待外部进程激活事件Event1，Event1激活后，C++应用程序读取共享内存中的数据，完成数据解析后执行相应指令，并向共享内存中写入指令执行结果，同时激活事件Event2；而Python进程则负责打开共享内存和两个同步事件，向共享内存中写入数据，并激活Event1，然后阻塞等待Event2被激活，Event2激活后，读取共享内存中的数据。进程通讯关系如下图所示： ...
python网络编程：UDP方式传输数据
Python热爱者的博客
12-14 567
UDP — 用户数据报协议（User Datagram Protocol），是一个无连接的简单的面向数据报的运输层协议。 UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。 由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。 开发环境：linux下pycharm3.5 测试：使用terminal终端测试...
win下python3与C++进行socket通信
长虹剑的专栏
06-06 6779
当前自己做的一个东西是有关3D显示和算法控制的。 写算法的时候希望用python，而显示3D网格这些希望用opengl。一开始打算都用python，可是python的那些vtk，pyqt4似乎在python3上不好配置，总之自己弄了很长时间最后放弃了，就打算采用标题的这种方法，本以为这个在网上能够方便地搜到，没想到找了半天找不到合适的，于是简单拼凑出一个示例，记录一下。不知道要实现数据传输有没有更
Win环境下C++和Python的UDP通信
weixin_44372396的博客
02-28 791
使用UDP传输链接C++和python，实现pygame实时作图
websocket通信，python，c++实现
01-11
websocket通信，python，c++实现，欢迎有需求的朋友下载。
C ++ / Python进程间通信与内存映射似乎不起作用
04-05
我遇到一个困扰我的问题，涉及内存映射以及C ++（在Win7 32位下为Visual Studio 2012）和Python 2.7之间的互换。 在我的C ++代码中，我有一个大的（2Mbyte）图像，其更新频率约为25Hz。 我很高兴与其他C ++ .exe共享...
用C++实现python的list风格
12-30
使用了C++的去处符重载方法来实现各种操作，如用[]切片、用=赋值、用+将两个列表合并、以及insert函数、append函数等等，几乎常用的python中的list方法都实现了，当然这段代码并不是从根本上解释python的。只是在C++...
Linux下python与C++使用dlib实现人脸检测.pdf
04-17
Linux下python与C++使用dlib实现人脸检测
matlab-fft求取给定数据的频率及对应的滤波器设计
Chasing的博客
05-05 9920
matlab-fft的使用范围以及使用示例
Ros_PX4_Mavros从零入门--哪些坑
Chasing的博客
04-06 9729
首先创建Ros工作空间。 在期望的路径上创建文件夹，比如这里我们采用如下指令创建一个空的文件夹 mkdir Ros_simulation 然后，进入该文件夹后创建src文件夹，指令同上 cd Ros_simulation mkdir src catkin_init_workspace 此时，就可以返回Ros_simulation文件夹下完成后续工作空间的创建，指令为： cd .. cat...
ROS_调试（三） 打印输出
Chasing的博客
08-16 8874
ROS_INFO 采用类似C语言的形式 ROS_DEBUG ROS_DEBUG_STREAM 采用类似C++语言的形式打印 ROS_DEBUG_STREAM_NAMED ROS_DEBUG_STREAM_THROTTLE_NAMED （n s, “name”, " message"<<“here"); ROS_DEBUG_STREAM_COND(x>0,“message”); 关键词throttle 表示每隔 n 秒打印消息 关键词named 表示给消息起一个类名字，方便查找消息 关键词s
ArduPilot飞行前检查——PreArm解析
Chasing的博客
05-10 8326
ArduPilot飞行前检查 主要包括两个部分: 1. 初始化中遥控器输入检查； 2. 1Hz解锁前检查。 附： 显示地面站信息 参考文章：Ardupilot Pre-Arm安全检查程序分析 1. 初始化中遥控器输入检查 直接跳转进去查看函数为； bool AP_Arming_Copter::rc_calibration_checks(bool display_failure) { const RC_Channel *channels[] = { copter.channel_ro
python与c++之间的通信
05-18
Python和C++之间的通信可以通过以下几种方式实现： 1. 使用标准输入输出流（stdin和stdout）：C++程序可以在命令行中运行，Python程序可以通过subprocess模块调用C++程序，并使用标准输入输出流进行通信。 2. 使用共享内存：C++程序和Python程序可以使用共享内存进行数据交换。C++程序可以使用POSIX或System V共享内存，Python程序可以使用multiprocessing模块中的Value、Array等数据结构。 3. 使用socket网络通信：C++程序和Python程序可以使用socket进行网络通信，通过TCP或UDP协议传输数据。 4. 使用消息队列：C++程序和Python程序可以使用消息队列进行数据交换。C++程序可以使用POSIX或System V消息队列，Python程序可以使用multiprocessing模块中的Queue等数据结构。 5. 使用RPC框架：C++程序和Python程序可以使用RPC框架进行远程调用。常用的RPC框架有gRPC、Thrift、XML-RPC等。 根据具体情况和需求，可以选择适合的方式进行通信。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值