C++与Python之间跨进程通信（socket实现）

1.引言

之前写过一篇Python调用C++程序的实现方法，这里相反，希望使用Python协助C++完成某些任务。一种解决思路为实现RPC调用，使用C++端（以下称客户端）发送数据，Python端（以下称服务端）处理数据并返回的方法，进一步来说，转换为C++与Python之间通信的问题。

2.实现思路

因为客户端可能希望使用的函数多种多样，这里为了保证灵活，服务端与客户端均写成框架的形式（取名CPhone），在实际使用的过程中，可以方便服务端即时自定义函数，客户端灵活调用。服务端文件结构如下：

包CPhone为服务器框架，在实际使用的时候只需编写test.py文件中的内容（定义函数）即可。
客户端：

使用的时候，通过callPyFun()函数调用即可。
为了统一数据格式，在服务端使用numpy的ndarray数据类型，在客户端使用opencv的mat数据类型。

3. 具体代码

（1）Python服务端

CPhone/__init__.py：

import numpy as np
import socket
from datetime import datetime
from threading import Thread
import time
import os
from operator import methodcaller


class CPhone:
    def __init__(self):
        self.g_conn_pool = []
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.thread = Thread(target=self._accept_client) #主线程
        self.thread.setDaemon(True)

    def run(self,ip="localhost",port=8888,max_n=0):
        self.server.bind((ip, port))
        self.server.listen(max_n)
        self.thread.start()

        log = """--------------------------\n--------------------------
%s\t\n(ip=%s,port=%d)\n\tstart listening...
"""% (str(datetime.now()), ip, port)
        if os.path.exists('./log.txt'):
            with open('./log.txt','a',encoding='utf-8') as fo:
                fo.write(log)
        else:
            with open('./log.txt','w',encoding='utf-8') as fo:
                fo.write(log)
        print(log)
        while True:
            cmd = input("""--------------------------
    输入1:查看当前在线人数
    输入0:关闭服务器
--------------------------
""")
            if cmd == '1':
                print("--------------------------")
                print("当前在线人数：\n", len(self.g_conn_pool))
            elif cmd == '0':
                exit()

    def _data_handle(self,client,address): #此函数主要用于解析数据，调用函数处理，并将结构序列化为字符串
        func_name,mat = self._recvall(client)
        #cv2.imwrite('xx.jpg', mat)

        return_data = methodcaller(func_name,mat)(self)

        shape_str = [str(i) for i in return_data.shape]
        shape_str = ','.join(shape_str)
        data_str = str(return_data.reshape(-1).tolist()).replace(' ', '').replace('[', ',').replace(']', ',')
        shape_str = ',%s,%d,' % (shape_str, len(data_str))
        self._sendall(client, shape_str, data_str)
        time.sleep(2)
        client.close()
        self.g_conn_pool.remove(client)
        log = ('%s\t用户(ip:%s port:%d)\t已下线\n'% (str(datetime.now()),address[0], address[1]))
        with open('./log.txt', 'a',encoding='utf-8') as fo:
            fo.write(log)
        print(log)
'''
为了解决C++栈溢出的问题，在发送和接受数据的时候均循环传输。
发送数据时先发送头信息，主要储存数据的shape，调用的函数名等。
'''

    def _recvall(self,sock):
        header = sock.recv(20)
        header = str(header).split('\\',1)[0].replace("b'",'')
        func_name,channels,height,width = header.split(',')
        channels,height,width = int(channels),int(height),int(width)
        count = channels*height*width
        buf = b''
        while count:
            newbuf = sock.recv(count)
            if not newbuf: return None
            buf += newbuf
            count -= len(newbuf)
        data = np.frombuffer(buf, dtype='uint8')
        mat = data.reshape(height, width, channels)
        return func_name,mat

    def _sendall(self,sock,header_str,data_str):
        sock.send(bytes(header_str, encoding="ascii"))
        data_bt = bytes(data_str, encoding="ascii")
        total = len(data_str)
        sended = 0
        while sended<total:
            send = min(total-sended,128*128*3)
            sock.send(data_bt[sended:sended+send])
            sended += send

    def _accept_client(self): #此函数用于接收客户端的链接请求，并为其开启一个线程
        while True:
            client, address = self.server.accept()  # 阻塞，等待客户端连接
            # 加入连接池
            self.g_conn_pool.append(client)
            log = ('%s\t用户(ip:%s port:%d)\t已上线\n' % (str(datetime.now()), address[0], address[1]))
            with open('./log.txt','a',encoding='utf-8') as fo:
                fo.write(log)
            print(log)
            # 给每个客户端创建一个独立的线程进行管理
            thread = Thread(target=self._data_handle, args=(client,address))
            # 设置成守护线程
            thread.setDaemon(True)
            thread.start()

实际使用过程中，需进行如下操作
test.py：

from CPhone import CPhone
import numpy as np
import torchvision.transforms as transforms


class MyCPhone(CPhone): #继承CPhone
    def normalize(self,mat): #这里定义一个归一化函数测试
        transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(
                mean=np.array([0.5, 0.5, 0.5]),
                std=np.array([0.5, 0.5, 0.5])),
        ])
        remat = transform(mat).numpy()
        return remat

    def mean(self,mat): #这里定义一个求均值函数测试
        remat = np.mean(mat)
        remat = np.array([remat])
        return remat


if __name__ == '__main__':
    test = MyCPhone()
    test.run() #开启服务

（2）C++客户端

client.cpp：

#include <stdio.h>  
#include <Winsock2.h>  
#pragma comment(lib,"ws2_32.lib")
#pragma warning(disable:4996)
#include <iostream>
#include <opencv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>
#include <cmath>
#include <vector>
#define BuffSize 1024
#define MaxReceive 256*256*3

class CPhone
{
private:
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
	SOCKET sockClient;
	SOCKADDR_IN addrSrv;
	int sec;
public:
	CPhone(const char*,int);
	cv::Mat callPyFun(const char*, cv::Mat);
	cv::Mat createMatFromImage(const char*);
};

CPhone::CPhone(const char* ip="127.0.0.1",int port=8888)
{
	this->wVersionRequested = MAKEWORD(1, 1);

	this->err = WSAStartup(this->wVersionRequested, &(this->wsaData));
	if (this->err != 0) {
		throw "error!";
	}

	if (LOBYTE(this->wsaData.wVersion) != 1 ||
		HIBYTE(this->wsaData.wVersion) != 1) {
		WSACleanup();
		throw "error!";
	}
	this->sockClient = socket(AF_INET, SOCK_STREAM, 0);
	this->addrSrv.sin_addr.S_un.S_addr = inet_addr(ip);
	this->addrSrv.sin_family = AF_INET;
	this->addrSrv.sin_port = htons(port);
	this->sec = connect(this->sockClient, (SOCKADDR*)&this->addrSrv, sizeof(SOCKADDR));
	if (SOCKET_ERROR == this->sec)
	{
		throw "error!";
	}
}


cv::Mat CPhone::callPyFun(const char* funName, cv::Mat mat)
{
	char* pos = (char*)mat.data;
	int colByte = mat.cols * mat.channels() * sizeof(uchar);
	//cout << mat.size[0];
	char header[30];
	//memcpy(header, &data[], 15);  //buf为储存复制内容的目标数组，sed 为字节数
	sprintf(header, "%s,%d,%d,%d",funName,mat.channels(),mat.size[0],mat.size[1]);
	send(this->sockClient, header, 30, 0);
	for (int i = 0; i < mat.rows; i++)
	{
		char* data = (char*)mat.ptr<uchar>(i); //第i行首地址
		int sedNum = 0;
		char buf[BuffSize] = { 0 };

		//按行拆分，发送数据
		while (sedNum < colByte)
		{
			int sed = BuffSize<(colByte - sedNum)?BuffSize: (colByte - sedNum);
			memcpy(buf, &data[sedNum], sed);  //buf为储存复制内容的目标数组，sed 为字节数
			int SendSize = send(this->sockClient, buf, sed, 0);
			if (SOCKET_ERROR == SendSize)
			{
				cv::Mat mat;
				return  mat;
			}
			/*else
			cout << SendSize << endl;*/
			sedNum += SendSize;
		}
	}
	char shape_str[40]; //收到的shape的字符串
	
	int ns1 = recv(this->sockClient, shape_str,40, 0); //收到的字符串的长度
	shape_str[ns1] = '\0';
	int shape[6] = {0,0,0,0,0,0}; //shape的值
	char temp_num[40];  //当前储存的数字字符
	int isnum = 0; //当前储存了几个字符
	for (int i = 0; i < ns1; i++)
	{
		if (shape_str[i]==',')
		{
			if (isnum) // 已经储存了字符
			{
				temp_num[isnum] = '\0';
				shape[shape[0]+1] = atoi(temp_num);
				shape[0]++;
				isnum = 0;
			}
			else //开始的时候没有储存字符
			{
				continue;
			}
		}
		else //数字字符
		{
			temp_num[isnum] = shape_str[i];
			isnum++;
		}
	}
	int n_num = 1;
	for (int i = 0; i < shape[0]-1; i++)
	{
		n_num *= shape[i + 1];
	}
	int str_len = shape[shape[0]];
	std::vector<double> vet;
	isnum = 0;  //已经储存的字符
	int ns2;
	while (str_len > 0) //循环接收
	{
		char* recvBuf = new char[MaxReceive];//收到的数据
		ns2 = recv(this->sockClient, recvBuf, MaxReceive, 0); //返回字符串的长度
		str_len -= ns2;
		recvBuf[ns2] = '\0';
		for (int i = 0; i < ns2; i++)
		{
			if (recvBuf[i] == ',') //如果遇到','
			{
				if (isnum) //如果已经储存了字符
				{
					temp_num[isnum] = '\0';
					vet.push_back(atof(temp_num));
					isnum = 0;
				}
				else //此时为开始的时候
				{
					continue;
				}
			}
			else
			{
				temp_num[isnum] = recvBuf[i];
				isnum++;
			}
		}
	}
	cv::Mat return_mat = cv::Mat(vet,true);
	switch (shape[0]-1)
	{
	case 1:
		return return_mat.reshape(shape[1]).clone();
		break;
	case 2:
		return return_mat.reshape(shape[1],shape[2]).clone();
		break;
	case 3:
		return return_mat.reshape(shape[3],(shape[1], shape[2])).clone();
		break;
	default:
		cv::Mat mat;
		return  mat;
		break;
	}
}

cv::Mat CPhone::createMatFromImage(const char *path)
{
	return cv::imread(path, cv::IMREAD_UNCHANGED);
}



int main()
{
	CPhone phone;
	cv::Mat img = phone.createMatFromImage("C:\\Users\\Lenovo\\Desktop\\xx.jpg"); //这里读取一张3*640*640的图片
	cv::Mat remat;
	remat = phone.callPyFun("normalize",img).clone(); //参数为调用的函数名，mat数据
	std::cout << remat;
	return 0;
}

使用的时候只需编写main()函数里的代码即可调用。
以下为对两个函数调用的返回结果
mean：

normalize: