如何实现 C/C++ 与 Python 的通信？
实现 C/C++ 与 Python 的通信是一个非常常见且重要的需求，它允许我们充分利用 C/C++ 的高性能和 Python 的易用性及丰富的库。下面我将详细介绍几种主流的通信方式，并尽可能地提供详细的解释和示例。
为什么需要 C/C++ 与 Python 通信？
性能优化: C/C++ 在计算密集型任务中通常比 Python 更快。可以将性能关键的代码用 C/C++ 实现，然后由 Python 调用。
利用现有库: 许多成熟的科学计算、图像处理、机器学习库是用 C/C++ 编写的。通过接口，Python 可以方便地使用这些库。
系统级编程: C/C++ 更适合进行底层系统操作，如文件 I/O、内存管理、硬件交互等。
代码复用: 将已有的 C/C++ 代码库集成到 Python 项目中，避免重复开发。
C/C++ 与 Python 通信的主要方式
目前主流的通信方式可以分为以下几类：
1. 直接生成 Python 扩展模块 (Native Extension Modules)
Python C API: 最直接也是最底层的方式。
Cython: 一种更高级的工具，可以让你用类似 Python 的语法编写 C 扩展。
pybind11: 一个轻量级的、跨平台的头文件库，用于创建 Python 和 C++ 之间的绑定。
SWIG (Simplified Wrapper and Interface Generator): 一个强大的工具，可以自动生成用于多种脚本语言（包括 Python）的 C/C++ 接口。
2. 进程间通信 (InterProcess Communication IPC)
管道 (Pipes): 简单、高效的单向通信。
套接字 (Sockets): 更灵活，支持网络通信，可以实现双向通信。
共享内存 (Shared Memory): 速度最快，但需要同步机制。
消息队列 (Message Queues): 异步通信，解耦发送者和接收者。
3. 远程过程调用 (Remote Procedure Call RPC)
gRPC: Google 开发的高性能、开源的通用 RPC 框架。
Thrift: Apache 开发的跨语言服务开发框架。
XMLRPC / JSONRPC: 基于 HTTP 的远程过程调用协议。
4. 其他方式
数据交换 (File I/O): 通过文件（如 CSV、JSON、二进制文件）传递数据。
嵌入式解释器: 将 Python 解释器嵌入到 C/C++ 程序中。
详细介绍各种通信方式
1. 直接生成 Python 扩展模块
这是最常见也是最推荐的方式，因为它可以实现更紧密的集成和更高的性能。
1.1 Python C API
这是 Python 官方提供的一种方式，允许你用 C 语言编写模块，这些模块可以直接被 Python 导入和使用。
核心概念:
`PyObject`: Python 中所有对象的基础类型。你的 C 代码需要创建和操作 `PyObject` 来与 Python 对象交互。
引用计数: Python 使用引用计数来管理内存。你的 C 代码需要正确增加和减少对象的引用计数，否则会导致内存泄漏或崩溃。
模块定义: 需要定义一个包含模块名称、函数列表以及模块初始化函数的结构体。
`setup.py`: 使用 Python 的 `setuptools` 库来编译和安装你的 C 扩展模块。
工作流程:
1. 编写 C 源代码:
包含 `Python.h` 头文件。
定义用于处理 Python 调用（如函数调用、对象访问）的 C 函数。这些函数接收 `PyObject` 作为参数，并返回 `PyObject`。
创建 Python 可见的方法（函数）列表，每个条目包含函数名、C 函数指针、参数类型和文档字符串。
定义模块结构体，包含模块名称、方法列表和模块初始化函数。
实现模块初始化函数，该函数会使用 `Py_InitModule`（或更新的 `PyModule_Create`) 来创建模块对象。
2. 编写 `setup.py`:
使用 `setuptools.Extension` 来定义你的 C 扩展。
使用 `setuptools.setup` 来构建和打包模块。
3. 编译和安装:
在命令行运行 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_module`
示例 (简单的加法函数):
`my_module.c`:
```c
include
// C 函数：接收两个整数对象，返回它们的和
static PyObject my_module_add(PyObject self, PyObject args) {
int a, b;
// 解析 Python 参数为 C 变量
// "ii" 表示期望两个整数参数
if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
return NULL; // 解析失败，返回 NULL
}
// 执行加法
int result = a + b;
// 将 C 整数转换为 Python 整数对象
return PyLong_FromLong(result);
}
// 定义模块的方法列表
// 每个条目是 {方法名, C函数指针, 参数类型, 文档字符串}
static PyMethodDef MyModuleMethods[] = {
{"add", my_module_add, METH_VARARGS, "Add two integers."},
{NULL, NULL, 0, NULL} // 列表结束标志
};
// 定义模块
static struct PyModuleDef mymodule = {
PyModuleDef_HEAD_INIT,
"my_module", // 模块名
"A simple C extension module for Python.", // 模块文档字符串
1, // 模块状态大小，1 表示不包含状态
MyModuleMethods // 方法列表
};
// 模块初始化函数 (名字必须是 PyInit_<模块名>)
PyMODINIT_FUNC PyInit_my_module(void) {
return PyModule_Create(&mymodule);
}
```
`setup.py`:
```python
from setuptools import setup, Extension
定义 C 扩展模块
my_module_extension = Extension(
'my_module', Python 中导入时使用的模块名
sources=['my_module.c'] C 源文件列表
)
setup(
name='my_module',
version='1.0',
description='A simple C extension module for Python',
ext_modules=[my_module_extension] 包含定义的扩展模块
)
```
编译和使用:
1. 保存以上代码为 `my_module.c` 和 `setup.py`。
2. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
3. 现在你可以在 Python 中使用它了：
```python
import my_module
result = my_module.add(5, 10)
print(f"5 + 10 = {result}") 输出: 5 + 10 = 15
```
Python C API 的优缺点:
优点:
最底层，控制力最强。
性能最高，没有额外的开销。
官方支持，最稳定。
缺点:
学习曲线陡峭，需要熟悉 Python 的对象模型和引用计数。
编写和调试 C 代码比较繁琐。
容易出错（如内存泄漏）。
1.2 Cython
Cython 是一个 Python 的超集，它允许你编写静态类型的 Python 代码，然后将其编译成 C 或 C++ 代码，最终生成 Python 扩展模块。它大大简化了使用 C API 的过程。
核心概念:
`.pyx` 文件: Cython 的源代码文件，语法是 Python 的扩展，可以加入 C 类型声明。
`setup.py`: 同样需要 `setup.py` 来编译 `.pyx` 文件。
类型声明: 在 Cython 中，你可以使用 `cdef` 关键字来声明 C 变量、函数和类，从而获得 C 的性能。
工作流程:
1. 编写 `.pyx` 源代码:
可以像写 Python 代码一样编写，但可以添加 C 类型声明。
2. 编写 `setup.py`:
使用 `setuptools.setup` 和 `Cython.Build.cythonize` 来编译 `.pyx` 文件。
3. 编译和安装:
运行 `python setup.py build_ext inplace` (在当前目录生成 `.so` 或 `.pyd` 文件) 或 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_module`
示例 (简单的加法函数):
`my_cython_module.pyx`:
```cython
my_cython_module.pyx
声明一个 C 函数，使其可以被 Python 调用
def add_cython(int a, int b):
Cython 会自动将 int 转换为 PyLong_FromLong
也可以显式声明返回类型：def add_cython(int a, int b) > int:
cdef int result = a + b
return result
```
`setup.py`:
```python
from setuptools import setup
from Cython.Build import cythonize
setup(
ext_modules = cythonize("my_cython_module.pyx") 指定 .pyx 文件
)
```
编译和使用:
1. 保存以上代码为 `my_cython_module.pyx` 和 `setup.py`。
2. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py build_ext inplace
```
这会在当前目录生成 `my_cython_module.c` (Cython 预编译生成的 C 代码) 和 `my_cython_module.so` (或 `.pyd`)。
3. 现在你可以在 Python 中使用它了：
```python
import my_cython_module
result = my_cython_module.add_cython(20, 30)
print(f"20 + 30 = {result}") 输出: 20 + 30 = 50
```
Cython 的优缺点:
优点:
大大降低了编写 C 扩展的复杂度，语法接近 Python。
可以通过类型声明获得接近 C 的性能。
可以轻松调用 C/C++ 代码。
可以用来加速纯 Python 代码的执行。
缺点:
仍需要学习 Cython 特定的语法和概念。
有时调试可能不如纯 Python 或纯 C 直观。
1.3 pybind11
pybind11 是一个专门为 C++11 和更高版本设计的轻量级、跨平台的头文件库，用于创建 Python 和 C++ 之间的绑定。它提供了一种非常简洁优雅的方式来暴露 C++ 类和函数给 Python。
核心概念:
头文件库: 无需编译过程，只需要包含头文件即可。
简洁的语法: 使用宏和模板来定义绑定。
自动类型转换: pybind11 会自动处理大部分 Python 和 C++ 类型之间的转换。
C++ 特性: 对 C++11 的 lambda、智能指针、STL 等有很好的支持。
工作流程:
1. 编写 C++ 源代码:
包含 `pybind11/pybind11.h` 和 `pybind11/stl.h` (如果使用 STL 容器)。
使用 `PYBIND11_MODULE` 宏来定义模块。
在模块定义中，使用 `m.def()` 来暴露 C++ 函数，使用 `py::class_` 来暴露 C++ 类。
2. 编写 `setup.py`:
使用 `setuptools.Extension`，但需要配置编译器和 include 路径以包含 pybind11 的头文件。
3. 编译和安装:
运行 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_cpp_module`
示例 (简单的加法函数和类):
`my_cpp_module.cpp`:
```cpp
include
// C++ 函数
int cpp_add(int i, int j) {
return i + j;
}
// C++ 类
class Pet {
public:
Pet(const std::string &name) : name(name) {}
void setName(const std::string &name_) { name = name_; }
const std::string &getName() const { return name; }
private:
std::string name;
};
// PYBIND11_MODULE 宏定义了一个模块
// 第一个参数是模块名 (Python 中导入时使用)，第二个参数是模块对象 (通常是 m)
PYBIND11_MODULE(my_cpp_module, m) {
m.doc() = "pybind11 example plugin"; // 可选的模块文档字符串
// 暴露 C++ 函数
// m.attr("add") 是在 Python 中访问的名称
m.attr("add") = &cpp_add;
// 或者使用更简洁的写法：m.def("add", &cpp_add, "A function that adds two numbers");
// 暴露 C++ 类
pybind11::class_(m, "Pet")
.def(pybind11::init(), "Constructor for Pet") // 构造函数
.def("setName", &Pet::setName, "Set the pet's name") // 成员函数
.def("getName", &Pet::getName, "Get the pet's name"); // 成员函数
}
```
`setup.py`:
```python
import sys
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
pybind11 是一个头文件库，所以我们不需要链接到特殊的库文件
但是我们需要确保编译器能够找到 pybind11 的头文件
通常，你需要将 pybind11 的路径添加到 include_dirs
如果你使用 vcpkg, poetry, pipenv 或 Conda 安装 pybind11，它可能会被自动找到
找到 pybind11 的安装路径（如果通过 pip 安装）
try:
import pybind11
PYBIND11_INCLUDE_DIRS = [pybind11.get_include()]
except ImportError:
PYBIND11_INCLUDE_DIRS = []
print("Pybind11 not found. Please install it using: pip install pybind11")
sys.exit(1)
class BuildExt(build_ext):
"""A custom build_ext command that enables std=c++11 when building modules."""
c_opts = {
'msvc': [],
'unix': ['std=c++11', 'O3', 'Wall'],
}
l_opts = {
'msvc': [],
'unix': [],
}
if sys.platform == 'win32':
extra_compile_args = c_opts['msvc']
else:
extra_compile_args = c_opts['unix']
extra_link_args = l_opts['unix']
def build_extensions(self):
for ext in self.extensions:
ext.extra_compile_args = self.extra_compile_args
ext.extra_link_args = self.extra_link_args
build_ext.build_extensions(self)
cpp_module_extension = Extension(
'my_cpp_module',
sources=['my_cpp_module.cpp'],
include_dirs=PYBIND11_INCLUDE_DIRS,
language='c++',
extra_compile_args=['std=c++11'], Explicitly set C++ standard
)
setup(
name='my_cpp_module',
version='0.1.0',
author='Your Name',
author_email='your.email@example.com',
description='A C++ extension for Python using pybind11',
long_description='',
ext_modules=[cpp_module_extension],
install_requires=['pybind11'], Specify pybind11 as a dependency
cmdclass={'build_ext': BuildExt},
zip_safe=False,
)
```
编译和使用:
1. 安装 pybind11: `pip install pybind11`
2. 保存以上代码为 `my_cpp_module.cpp` 和 `setup.py`。
3. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
或者为了在当前目录生成文件：
```bash
python setup.py build_ext inplace
```
4. 现在你可以在 Python 中使用它了：
```python
import my_cpp_module
调用 C++ 函数
result = my_cpp_module.add(100, 200)
print(f"100 + 200 = {result}") 输出: 100 + 200 = 300
使用 C++ 类
pet = my_cpp_module.Pet("Buddy")
print(f"Pet's name: {pet.getName()}") 输出: Pet's name: Buddy
pet.setName("Max")
print(f"Pet's new name: {pet.getName()}") 输出: Pet's new name: Max
```
pybind11 的优缺点:
优点:
非常简洁优雅的 C++ 绑定语法。
对 C++11 特性的良好支持。
无需学习新的语言（如 Cython），直接使用 C++。
性能好，开销小。
跨平台性好。
缺点:
只能用于 C++ (如果你需要 C，可能需要考虑 CPython API 或 SWIG)。
仍需要编写 C++ 代码和 `setup.py`。
1.4 SWIG
SWIG (Simplified Wrapper and Interface Generator) 是一个非常成熟的工具，可以为 C/C++ 代码生成多种脚本语言（包括 Python）的接口。它通过一个接口文件 (`.i`) 来描述你想暴露哪些 C/C++ 的函数、类、结构体等。
核心概念:
接口文件 (`.i`): 这是 SWIG 的核心，用于描述要包装的 C/C++ 代码的哪些部分。
SWIG 命令: 使用 `swig` 命令来生成 C/C++ 的包装代码和 Python 接口文件。
编译和链接: 生成的 C/C++ 包装代码需要被编译并链接到一个 Python 模块。
`setup.py`: 用于协调 SWIG 生成的代码的编译和链接。
工作流程:
1. 编写 C/C++ 源代码: 正常编写你的 C/C++ 代码。
2. 编写 SWIG 接口文件 (`.i`):
声明要包装的头文件 (`%include`)。
使用 `%module` 定义模块名。
使用 `%typemap` 定义类型映射。
可以使用 `%ignore` 忽略不需要暴露的函数/变量。
3. 运行 SWIG 命令: `swig python your_interface.i`
这会生成 `your_interface_wrap.cxx` (C++ 包装代码) 和 `your_interface.py` (Python 接口文件)。
4. 编写 `setup.py`:
使用 `setuptools.Extension` 来编译 `.cxx` 文件，并链接你的 C/C++ 源文件。
5. 编译和安装:
运行 `python setup.py install`。
6. 在 Python 中导入和使用:
`from your_module import your_interface`
示例 (简单的 C++ 函数):
`my_swig_lib.h`:
```c++
ifndef MY_SWIG_LIB_H
define MY_SWIG_LIB_H
int multiply(int a, int b);
endif // MY_SWIG_LIB_H
```
`my_swig_lib.cpp`:
```cpp
include "my_swig_lib.h"
int multiply(int a, int b) {
return a b;
}
```
`my_swig_lib.i` (SWIG 接口文件):
```swig
// my_swig_lib.i
%module my_swig_lib // Python 中导入的模块名
%{
/ Includes the header in the wrapper code /
include "my_swig_lib.h"
%}
/ Parse the header file to generate the Python bindings /
%include "my_swig_lib.h"
```
`setup.py`:
```python
import os
import sys
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
SWIG 命令行选项
SWIG_FLAGS = ['c++', 'python', 'modern'] c++ for C++, python for Python bindings, modern for modern Python features
SWIG executable path (you might need to adjust this if swig is not in your PATH)
SWIG_EXECUTABLE = "swig"
Generate Python bindings using SWIG
if not os.path.exists("my_swig_lib_wrap.cxx"):
print("Running SWIG...")
swig_command = f"{SWIG_EXECUTABLE} {' '.join(SWIG_FLAGS)} outdir ./ my_swig_lib.i"
print(f"Executing: {swig_command}")
os.system(swig_command)
print("SWIG finished.")
Define the extension module
my_swig_module = Extension(
'_my_swig_lib', Python uses a leading underscore for the compiled extension module
sources=['my_swig_lib.cpp', 'my_swig_lib_wrap.cxx'], C++ source and SWIG generated wrapper
language='c++',
Add any necessary include directories or linker flags for your C++ code
include_dirs=[...],
library_dirs=[...],
libraries=[...],
extra_compile_args=['std=c++11', 'O3'] Example C++11 flag
)
setup(
name='my_swig_lib',
version='0.1.0',
description='A C++ library wrapped with SWIG for Python',
ext_modules=[my_swig_module],
py_modules=["my_swig_lib"], This tells setuptools to package the .py file generated by SWIG
install_requires=[],
cmdclass={'build_ext': build_ext}
)
```
编译和使用:
1. 安装 SWIG: 根据你的操作系统安装 SWIG。
2. 保存以上代码为 `my_swig_lib.h`, `my_swig_lib.cpp`, `my_swig_lib.i`, 和 `setup.py`。
3. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
或者为了在当前目录生成文件：
```bash
python setup.py build_ext inplace
```
首先 SWIG 会运行生成 `my_swig_lib_wrap.cxx` 和 `my_swig_lib.py`。然后 `setup.py` 会编译这些文件。
4. 现在你可以在 Python 中使用它了：
```python
import my_swig_lib
result = my_swig_lib.multiply(7, 8)
print(f"7 8 = {result}") 输出: 7 8 = 56
```
SWIG 的优缺点:
优点:
支持多种脚本语言，不仅仅是 Python。
处理复杂的 C/C++ 代码（如继承、模板）的能力很强。
可以自动化大量绑定代码的生成。
缺点:
学习曲线相对陡峭，需要掌握 SWIG 的接口语言。
生成的代码可能不如手写或 pybind11 精简。
调试可能比直接 C API 或 pybind11 更困难。
2. 进程间通信 (IPC)
当你的 C/C++ 程序和 Python 程序是独立运行时，可以使用 IPC 来交换数据。这种方式解耦了两个进程，但数据交换会有序列化/反序列化的开销。
2.1 管道 (Pipes)
管道是最简单的 IPC 机制之一，用于进程间通信。它通常是单向的。
工作流程:
1. 启动子进程: Python 可以使用 `subprocess` 模块启动 C/C++ 程序，并为其创建标准输入、输出和错误流。
2. 数据写入: C/C++ 程序向其标准输出写入数据。
3. 数据读取: Python 程序从 C/C++ 进程的标准输出中读取数据。
4. 数据写入 (反向): Python 程序向 C/C++ 进程的标准输入写入数据。
5. 数据读取 (反向): C/C++ 程序从其标准输入读取数据。
示例:
`calculator.cpp`:
```cpp
include
include
include
int main() {
std::string line;
while (std::cin >> line) {
std::stringstream ss(line);
int a, b;
char op;
ss >> a >> op >> b; // 假设输入格式为 "数字 运算符 数字"
int result;
if (op == '+') {
result = a + b;
} else if (op == '') {
result = a b;
} else {
result = 1; // 简单错误处理
}
std::cout << result << std::endl; // 输出结果
}
return 0;
}
```
`run_calculator.py`:
```python
import subprocess
import sys
编译 C++ 代码 (如果还没有编译)
在实际项目中，您会使用 CMake 或其他构建系统来管理编译
subprocess.run(["g++", "calculator.cpp", "o", "calculator_exe"])
启动 C++ 程序作为子进程
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
text=True 表示将输入输出作为文本处理 (自动编码/解码)
process = subprocess.Popen(
["./calculator_exe"], 替换为你的 C++ 程序路径
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True 使用文本模式
)
发送数据给 C++ 程序
input_data = "10 + 20 "
print(f"Python sending: {input_data.strip()}")
stdout, stderr = process.communicate(input=input_data)
stdout 包含 C++ 程序的所有输出
if stdout:
print(f"Python received: {stdout.strip()}")
stderr 包含 C++ 程序的错误输出
if stderr:
print(f"C++ stderr: {stderr.strip()}")
发送另一个数据
input_data_2 = "5 6 "
print(f"Python sending: {input_data_2.strip()}")
使用 process.stdin.write() 和 process.stdout.read() 进行更细粒度的控制
这里为了简单起见，重新使用 communicate (请注意，communicate 只能调用一次，除非重新创建进程)
更常见的方法是使用 stdin.write() 和 stdout.read() 并手动处理行结束符
让我们演示一下更精细的控制
process = subprocess.Popen(
["./calculator_exe"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
process.stdin.write("15 + 25 ")
process.stdin.flush() 确保数据被发送
result_line = process.stdout.readline() 读取一行输出
print(f"Python received: {result_line.strip()}")
关闭 stdin
process.stdin.close()
获取剩余的 stderr (如果存在)
stderr_output = process.stderr.read()
if stderr_output:
print(f"C++ stderr: {stderr_output.strip()}")
```
管道的优缺点:
优点:
简单易用，适用于简单的进程间通信。
操作系统内置支持。
缺点:
通常是单向通信，双向需要两个管道。
数据需要序列化/反序列化。
如果 C++ 程序不是为管道设计的，需要修改。
2.2 套接字 (Sockets)
套接字是更通用的 IPC 和网络通信方式。你可以创建一个 TCP/IP 套接字服务器（用 C++ 或 Python）和一个客户端（用另一个语言）。
工作流程:
1. 服务器端:
创建套接字。
绑定到一个地址和端口。
监听连接。
接受客户端连接。
接收/发送数据。
关闭连接/套接字。
2. 客户端:
创建套接字。
连接到服务器的地址和端口。
发送/接收数据。
关闭套接字。
示例 (使用 TCP 套接字):
`server.cpp`:
```cpp
include
include
include
include // For memset
include
include
include // For close
define PORT 8080
define BUFFER_SIZE 1024
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[BUFFER_SIZE] = {0};
// 创建 socket 文件描述符
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 强制连接到指定端口
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt");
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY; // 监听任何 IP 地址
address.sin_port = htons(PORT); // 端口号
// 绑定 socket 到指定地址和端口
if (bind(server_fd, (struct sockaddr )&address, sizeof(address)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
// 开始监听，最多允许 backlog 个连接
if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
std::cout << "Server listening on port " << PORT << std::endl;
// 接受客户端连接
if ((new_socket = accept(server_fd, (struct sockaddr )&address, (socklen_t)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}
std::cout << "Connection accepted." << std::endl;
// 读取客户端发送的数据
int valread = read(new_socket, buffer, BUFFER_SIZE);
if (valread < 0) {
perror("read failed");
} else {
std::cout << "Message from client: " << buffer << std::endl;
// 处理数据，例如执行计算
// 假设客户端发送的是 "add 10 20"
std::string msg(buffer);
if (msg.rfind("add", 0) == 0) { // Check if message starts with "add"
std::stringstream ss(msg);
std::string command;
int a, b;
ss >> command >> a >> b;
int result = a + b;
std::string response = std::to_string(result);
send(new_socket, response.c_str(), response.length(), 0);
std::cout << "Sent result to client: " << result << std::endl;
} else {
send(new_socket, "Unknown command", 15, 0);
}
}
// 关闭套接字
close(new_socket);
close(server_fd);
std::cout << "Server stopped." << std::endl;
return 0;
}
```
`client.py`:
```python
import socket
HOST = '127.0.0.1' Standard loopback interface address (localhost)
PORT = 8080 Port to listen on (nonprivileged ports are > 1023)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
发送一个请求到 C++ 服务器
request = "add 50 60"
print(f"Python sending: {request}")
s.sendall(request.encode()) 发送编码后的字节
接收响应
data = s.recv(1024) 接收最多 1024 字节
print(f"Python received: {data.decode()}") 解码接收到的字节
注意：这个例子是 Python 作为客户端连接到 C++ 服务器。
如果你想 C++ 作为客户端连接到 Python 服务器，你需要修改 server.cpp 为 client.cpp
并创建一个 Python 服务器脚本。
```
套接字的优缺点:
优点:
非常灵活，支持网络通信，可以在不同机器之间通信。
支持 TCP (可靠传输) 和 UDP (不可靠但快速传输)。
成熟的协议和库支持。
缺点:
需要编写服务器和客户端逻辑。
数据序列化/反序列化开销。
网络延迟。
需要处理更复杂的错误和异常情况。
2.3 共享内存 (Shared Memory)
共享内存允许两个进程直接访问同一块内存区域，速度非常快，但需要谨慎管理，避免竞态条件。通常需要同步机制（如信号量、互斥锁）。
实现方式:
POSIX 共享内存: 通过 `shm_open`, `ftruncate`, `mmap` 等系统调用实现。
System V 共享内存: 通过 `shmget`, `shmat`, `shmdt` 等系统调用实现。
Python 库: `multiprocessing.shared_memory` (Python 3.8+)。
工作流程 (以 Python `multiprocessing.shared_memory` 为例):
1. 创建共享内存: 一个进程（通常是主进程）创建共享内存块。
2. 访问共享内存: 其他进程通过名称查找并访问该共享内存块。
3. 读写数据: 进程直接在共享内存区域读写数据。
4. 同步: 使用锁或其他同步机制保护对共享内存的访问。
5. 关闭/释放: 使用完毕后，需要关闭和释放共享内存。
示例 (简化的 C++ 读，Python 写):
`shared_memory_reader.cpp`:
```cpp
include
include
include
include
include
include // For strlen
define SHM_NAME "/my_shared_memory"
define SHM_SIZE 1024
int main() {
// 打开已存在的共享内存对象
int shm_fd = shm_open(SHM_NAME, O_RDONLY, 0666);
if (shm_fd == 1) {
perror("shm_open");
return 1;
}
// 将共享内存映射到进程地址空间
void ptr = mmap(0, SHM_SIZE, PROT_READ, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
std::cout << "Shared memory mapped. Waiting for data..." << std::endl;
char shared_data = (char)ptr;
// 循环读取数据直到看到特定标记或空字符串
while (true) {
if (strlen(shared_data) > 0) {
std::cout << "Read from shared memory: " << shared_data << std::endl;
// 在实际应用中，你可能需要一个同步机制来知道何时数据有效
// 这里为了简单，我们只是打印并让 Python 更新它
// 如果需要更复杂的同步，可以使用信号量
// 清空共享内存，表示数据已被读取 (如果需要)
// memset(shared_data, 0, SHM_SIZE);
// 或者等待 Python 写入新的数据
sleep(1); // 短暂休眠，避免 CPU 空转
} else {
// 如果共享内存为空，稍作等待
usleep(100000); // 100ms
}
}
// unmap and close (in this example, it runs indefinitely, so this part is not reached)
// munmap(ptr, SHM_SIZE);
// close(shm_fd);
// shm_unlink(SHM_NAME); // Only the creator should unlink
return 0;
}
```
`shared_memory_writer.py`:
```python
import multiprocessing.shared_memory
import time
SHM_NAME = "/my_shared_memory"
SHM_SIZE = 1024
try:
创建或打开共享内存
如果不存在，创建；如果存在，打开
shm = multiprocessing.shared_memory.SharedMemory(name=SHM_NAME, create=True, size=SHM_SIZE)
print(f"Shared memory '{SHM_NAME}' created/opened successfully.")
给 C++ 进程一点时间来映射
time.sleep(2)
将数据写入共享内存
message = "Hello from Python!"
print(f"Writing to shared memory: {message}")
将字符串转换为字节并复制到共享内存中
注意：共享内存的内容是字节，需要正确处理编码和长度
shm.buf[:len(message)] = message.encode()
在实际应用中，您可能需要一个同步机制来通知 C++ 读取数据
例如，可以写入一个单独的标志位或者等待 C++ 的确认
等待一段时间，让 C++ 读取
time.sleep(3)
写入新的消息
message_2 = "Another message from Python."
print(f"Writing to shared memory: {message_2}")
shm.buf[:len(message_2)] = message_2.encode()
time.sleep(3)
except FileExistsError:
print(f"Shared memory '{SHM_NAME}' already exists. Trying to connect to it.")
try:
shm = multiprocessing.shared_memory.SharedMemory(name=SHM_NAME)
print(f"Connected to existing shared memory '{SHM_NAME}'.")
在这个场景下，您可能只需要作为写入者，而另一个进程是只读的
例如， Python 写入，C++ 读取
message = "Hello from Python!"
print(f"Writing to shared memory: {message}")
shm.buf[:len(message)] = message.encode()
time.sleep(3)
message_2 = "Another message from Python."
print(f"Writing to shared memory: {message_2}")
shm.buf[:len(message_2)] = message_2.encode()
time.sleep(3)
except FileNotFoundError:
print(f"Error: Shared memory '{SHM_NAME}' not found.")
except Exception as e:
print(f"An error occurred: {e}")
finally:
关闭共享内存
if 'shm' in locals() and shm:
shm.close()
通常，只有创建者才应该unlink共享内存
如果你希望每次运行都重新创建，可以取消下面这行注释
shm.unlink()
print(f"Shared memory '{SHM_NAME}' closed.")
```
共享内存的优缺点:
优点:
速度极快，因为数据不需要复制。
适合传输大量数据。
缺点:
实现复杂，需要处理同步问题，容易发生数据冲突。
需要明确的内存管理。
跨平台性可能不如套接字。
3. 远程过程调用 (RPC)
RPC 允许一个程序调用另一个地址空间（通常是另一台机器上）的过程，就好像它是本地过程一样。
3.1 gRPC
gRPC 是一个高性能、开源的通用 RPC 框架，由 Google 开发。它使用 Protocol Buffers 作为接口定义语言 (IDL)，并支持多种语言。
工作流程:
1. 定义服务 (`.proto` 文件): 使用 Protocol Buffers 定义服务接口和消息结构。
2. 生成代码: 使用 `protoc` 编译器和相应的 gRPC 语言插件生成服务器和客户端的代码框架。
3. 实现服务器: 编写 C++ 或 Python 代码实现服务接口，并启动 gRPC 服务器。
4. 实现客户端: 编写 C++ 或 Python 代码作为客户端，调用服务。
优点:
高性能，基于 HTTP/2。
接口定义清晰，易于维护。
跨语言支持极佳。
支持流式通信。
缺点:
学习曲线相对较陡峭，需要理解 Protocol Buffers 和 gRPC 概念。
需要编译和生成代码。
3.2 Thrift / XMLRPC / JSONRPC
这些也是常见的 RPC 框架，工作流程类似 gRPC，但使用的 IDL 和传输协议可能不同。
4. 其他方式
4.1 数据交换 (File I/O)
最简单直接的方式，但效率最低。
流程: C++ 程序将数据写入文件，Python 程序读取文件；或反之。
优点: 非常简单，无需额外库。
缺点: 速度慢，有磁盘 I/O 开销，不适合实时通信。
4.2 嵌入式解释器
将 Python 解释器嵌入到 C/C++ 程序中，允许 C/C++ 程序直接调用 Python 代码和对象。
Python C API: 通过 `Python.h` 提供的函数可以在 C/C++ 中初始化 Python 解释器，执行 Python 语句，调用 Python 函数，传递数据。
优点: 深度集成，C/C++ 可以完全控制 Python 的行为。
缺点: 配置和管理复杂，需要处理引用计数和全局解释器锁 (GIL)。
示例 (在 C++ 中嵌入 Python):
`embedded_python.cpp`:
```cpp
include
include
include
int main() {
PyObject pName, pModule, pFunc;
PyObject pArgs, pValue;
// 初始化 Python 解释器
Py_Initialize();
// 导入 Python 模块 (假设有一个名为 "my_python_script" 的文件)
pName = PyUnicode_DecodeFSDefault("my_python_script"); // 模块名
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
// 获取模块中的函数 (假设函数名为 "greet")
pFunc = PyObject_GetAttrString(pModule, "greet");
// 检查函数是否存在且可调用
if (pFunc && PyCallable_Check(pFunc)) {
// 创建传递给函数的参数列表
pArgs = PyTuple_New(1); // 一个参数
pValue = PyUnicode_FromString("C++ Program"); // 要传递的字符串
if (!pValue) {
PyErr_Print();
Py_DECREF(pFunc);
Py_DECREF(pModule);
Py_Finalize();
return 1;
}
PyTuple_SetItem(pArgs, 0, pValue); // 将参数放入元组
// 调用 Python 函数
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
// 处理函数返回值
const char greeting = PyUnicode_AsUTF8(pValue);
std::cout << "Received from Python: " << greeting << std::endl;
Py_DECREF(pValue);
} else {
PyErr_Print();
}
} else {
if (PyErr_Occurred()) PyErr_Print();
fprintf(stderr, "Cannot find function "greet" ");
}
Py_XDECREF(pFunc); // 使用 XDECREF 来处理 pFunc 可能为 NULL 的情况
Py_DECREF(pModule);
} else {
PyErr_Print();
fprintf(stderr, "Failed to load "my_python_script" ");
Py_Finalize();
return 1;
}
// 结束 Python 解释器
Py_Finalize();
return 0;
}
```
`my_python_script.py`:
```python
def greet(name):
return f"Hello, {name}! This is Python speaking."
```
编译和使用:
1. 安装 Python 开发头文件: 确保你的系统安装了 Python 开发包（例如，在 Debian/Ubuntu 上是 `python3dev`，在 Fedora 上是 `python3devel`）。
2. 保存文件: 将上面的 C++ 代码保存为 `embedded_python.cpp`，Python 代码保存为 `my_python_script.py`。
3. 编译 C++ 代码: 使用 g++，并链接 Python 库。具体的编译命令取决于你的操作系统和 Python 安装方式。
Linux/macOS (示例):
```bash
查找 Python 库和头文件路径
PYTHON_INCLUDE=$(python3config includes)
PYTHON_LIB=$(python3config libs)
g++ embedded_python.cpp o embedded_python_exe $PYTHON_INCLUDE $PYTHON_LIB lpython3.x 替换 x 为你的 Python 小版本号
```
你需要找到正确的 `python3.x` 来链接。
如果 Python 安装在非标准位置，你可能需要手动指定 `I` 和 `L` 路径。
4. 运行:
```bash
python3 my_python_script.py 确保 Python 脚本可被找到
./embedded_python_exe
```
输出应该类似：
```
Received from Python: Hello, C++ Program! This is Python speaking.
```
嵌入式解释器的优缺点:
优点:
允许 C/C++ 代码动态执行和控制 Python 代码。
非常适合需要调用大量 Python 函数或脚本的场景。
缺点:
配置和管理复杂。
性能开销可能较大。
GIL 问题可能影响并发性能。
错误处理和调试难度较大。
总结与选择建议
| 通信方式 | 适用场景 | 优点 | 缺点 |
| : | : | : | : |
| Python C API | 性能极致要求，直接访问 Python 对象 | 最底层，控制力最强，性能最高 | 学习曲线陡峭，易出错 |
| Cython | Python 性能优化，简化 C 扩展编写 | 接近 Python 语法，性能好 | 需要学习 Cython 语法 |
| pybind11 | C++ 代码暴露给 Python | 简洁优雅，C++11 支持好，跨平台 | 只能用于 C++ |
| SWIG | 包装大量 C/C++ 代码，支持多种脚本语言 | 支持语言多，自动化程度高 | 接口文件学习，代码可能不够精简 |
| 管道 (Pipes) | 简单进程间通信 | 简单易用 | 单向，数据格式固定 |
| 套接字 (Sockets) | 网络通信，独立进程通信 | 灵活通用，支持网络，协议多样 | 需要服务器/客户端逻辑，序列化开销 |
| 共享内存 | 大数据量传输，高性能进程间通信 | 速度极快 | 实现复杂，需要同步，平台依赖性 |
| gRPC / Thrift (RPC) | 分布式系统，微服务，跨语言服务调用 | 高性能，接口定义清晰，跨语言 | 学习曲线，需要编译生成代码 |
| 文件 I/O | 数据持久化，简单非实时数据交换 | 最简单 | 效率低 |
| 嵌入式解释器 | C/C++ 程序需要动态调用 Python | C/C++ 完全控制 Python | 配置复杂，GIL 问题，调试困难 |
如何选择？
如果你想将 C/C++ 代码作为库提供给 Python:
C++: 强烈推荐 pybind11。它最现代、最简洁，对 C++11/14/17 的支持非常好。
C: Python C API 是最基础但也是最强大的选择，但编写复杂。Cython 是一个不错的折衷，可以让你用接近 Python 的语法写高性能代码。SWIG 适合包装现有的大型 C 库。
如果你的 C++ 程序是一个独立的服务器，Python 是客户端:
网络通信: 使用 套接字 或更高级的 RPC 框架如 gRPC。gRPC 尤其适合构建微服务和需要高性能的场景。
如果你的 C++ 和 Python 程序在同一台机器上运行，但需要独立进程:
简单的通信: 管道 或 套接字。
大数据量: 共享内存，但要小心处理同步。
如果你想在 C++ 程序中运行 Python 脚本或调用 Python 函数:
嵌入式解释器 是你的首选。
最佳实践:
清晰的接口定义: 无论使用哪种方法，都要有一个清晰的数据和功能接口定义。
错误处理: 充分考虑双方可能出现的错误，并进行妥善处理。
性能考虑: 在性能敏感的场景下，选择开销最小的通信方式，并进行基准测试。
构建系统: 使用 CMake、setuptools、Makefile 等构建工具来管理编译和打包过程。
版本控制: 确保 C/C++ 和 Python 代码的版本兼容性。
希望这份详细的介绍能够帮助你理解和选择合适的 C/C++ 与 Python 通信方式！
为什么需要 C/C++ 与 Python 通信？
性能优化: C/C++ 在计算密集型任务中通常比 Python 更快。可以将性能关键的代码用 C/C++ 实现，然后由 Python 调用。
利用现有库: 许多成熟的科学计算、图像处理、机器学习库是用 C/C++ 编写的。通过接口，Python 可以方便地使用这些库。
系统级编程: C/C++ 更适合进行底层系统操作，如文件 I/O、内存管理、硬件交互等。
代码复用: 将已有的 C/C++ 代码库集成到 Python 项目中，避免重复开发。
C/C++ 与 Python 通信的主要方式
目前主流的通信方式可以分为以下几类：
1. 直接生成 Python 扩展模块 (Native Extension Modules)
Python C API: 最直接也是最底层的方式。
Cython: 一种更高级的工具，可以让你用类似 Python 的语法编写 C 扩展。
pybind11: 一个轻量级的、跨平台的头文件库，用于创建 Python 和 C++ 之间的绑定。
SWIG (Simplified Wrapper and Interface Generator): 一个强大的工具，可以自动生成用于多种脚本语言（包括 Python）的 C/C++ 接口。
2. 进程间通信 (InterProcess Communication IPC)
管道 (Pipes): 简单、高效的单向通信。
套接字 (Sockets): 更灵活，支持网络通信，可以实现双向通信。
共享内存 (Shared Memory): 速度最快，但需要同步机制。
消息队列 (Message Queues): 异步通信，解耦发送者和接收者。
3. 远程过程调用 (Remote Procedure Call RPC)
gRPC: Google 开发的高性能、开源的通用 RPC 框架。
Thrift: Apache 开发的跨语言服务开发框架。
XMLRPC / JSONRPC: 基于 HTTP 的远程过程调用协议。
4. 其他方式
数据交换 (File I/O): 通过文件（如 CSV、JSON、二进制文件）传递数据。
嵌入式解释器: 将 Python 解释器嵌入到 C/C++ 程序中。
详细介绍各种通信方式
1. 直接生成 Python 扩展模块
这是最常见也是最推荐的方式，因为它可以实现更紧密的集成和更高的性能。
1.1 Python C API
这是 Python 官方提供的一种方式，允许你用 C 语言编写模块，这些模块可以直接被 Python 导入和使用。
核心概念:
`PyObject`: Python 中所有对象的基础类型。你的 C 代码需要创建和操作 `PyObject` 来与 Python 对象交互。
引用计数: Python 使用引用计数来管理内存。你的 C 代码需要正确增加和减少对象的引用计数，否则会导致内存泄漏或崩溃。
模块定义: 需要定义一个包含模块名称、函数列表以及模块初始化函数的结构体。
`setup.py`: 使用 Python 的 `setuptools` 库来编译和安装你的 C 扩展模块。
工作流程:
1. 编写 C 源代码:
包含 `Python.h` 头文件。
定义用于处理 Python 调用（如函数调用、对象访问）的 C 函数。这些函数接收 `PyObject` 作为参数，并返回 `PyObject`。
创建 Python 可见的方法（函数）列表，每个条目包含函数名、C 函数指针、参数类型和文档字符串。
定义模块结构体，包含模块名称、方法列表和模块初始化函数。
实现模块初始化函数，该函数会使用 `Py_InitModule`（或更新的 `PyModule_Create`) 来创建模块对象。
2. 编写 `setup.py`:
使用 `setuptools.Extension` 来定义你的 C 扩展。
使用 `setuptools.setup` 来构建和打包模块。
3. 编译和安装:
在命令行运行 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_module`
示例 (简单的加法函数):
`my_module.c`:
```c
include
// C 函数：接收两个整数对象，返回它们的和
static PyObject my_module_add(PyObject self, PyObject args) {
int a, b;
// 解析 Python 参数为 C 变量
// "ii" 表示期望两个整数参数
if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
return NULL; // 解析失败，返回 NULL
}
// 执行加法
int result = a + b;
// 将 C 整数转换为 Python 整数对象
return PyLong_FromLong(result);
}
// 定义模块的方法列表
// 每个条目是 {方法名, C函数指针, 参数类型, 文档字符串}
static PyMethodDef MyModuleMethods[] = {
{"add", my_module_add, METH_VARARGS, "Add two integers."},
{NULL, NULL, 0, NULL} // 列表结束标志
};
// 定义模块
static struct PyModuleDef mymodule = {
PyModuleDef_HEAD_INIT,
"my_module", // 模块名
"A simple C extension module for Python.", // 模块文档字符串
1, // 模块状态大小，1 表示不包含状态
MyModuleMethods // 方法列表
};
// 模块初始化函数 (名字必须是 PyInit_<模块名>)
PyMODINIT_FUNC PyInit_my_module(void) {
return PyModule_Create(&mymodule);
}
```
`setup.py`:
```python
from setuptools import setup, Extension
定义 C 扩展模块
my_module_extension = Extension(
'my_module', Python 中导入时使用的模块名
sources=['my_module.c'] C 源文件列表
)
setup(
name='my_module',
version='1.0',
description='A simple C extension module for Python',
ext_modules=[my_module_extension] 包含定义的扩展模块
)
```
编译和使用:
1. 保存以上代码为 `my_module.c` 和 `setup.py`。
2. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
3. 现在你可以在 Python 中使用它了：
```python
import my_module
result = my_module.add(5, 10)
print(f"5 + 10 = {result}") 输出: 5 + 10 = 15
```
Python C API 的优缺点:
优点:
最底层，控制力最强。
性能最高，没有额外的开销。
官方支持，最稳定。
缺点:
学习曲线陡峭，需要熟悉 Python 的对象模型和引用计数。
编写和调试 C 代码比较繁琐。
容易出错（如内存泄漏）。
1.2 Cython
Cython 是一个 Python 的超集，它允许你编写静态类型的 Python 代码，然后将其编译成 C 或 C++ 代码，最终生成 Python 扩展模块。它大大简化了使用 C API 的过程。
核心概念:
`.pyx` 文件: Cython 的源代码文件，语法是 Python 的扩展，可以加入 C 类型声明。
`setup.py`: 同样需要 `setup.py` 来编译 `.pyx` 文件。
类型声明: 在 Cython 中，你可以使用 `cdef` 关键字来声明 C 变量、函数和类，从而获得 C 的性能。
工作流程:
1. 编写 `.pyx` 源代码:
可以像写 Python 代码一样编写，但可以添加 C 类型声明。
2. 编写 `setup.py`:
使用 `setuptools.setup` 和 `Cython.Build.cythonize` 来编译 `.pyx` 文件。
3. 编译和安装:
运行 `python setup.py build_ext inplace` (在当前目录生成 `.so` 或 `.pyd` 文件) 或 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_module`
示例 (简单的加法函数):
`my_cython_module.pyx`:
```cython
my_cython_module.pyx
声明一个 C 函数，使其可以被 Python 调用
def add_cython(int a, int b):
Cython 会自动将 int 转换为 PyLong_FromLong
也可以显式声明返回类型：def add_cython(int a, int b) > int:
cdef int result = a + b
return result
```
`setup.py`:
```python
from setuptools import setup
from Cython.Build import cythonize
setup(
ext_modules = cythonize("my_cython_module.pyx") 指定 .pyx 文件
)
```
编译和使用:
1. 保存以上代码为 `my_cython_module.pyx` 和 `setup.py`。
2. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py build_ext inplace
```
这会在当前目录生成 `my_cython_module.c` (Cython 预编译生成的 C 代码) 和 `my_cython_module.so` (或 `.pyd`)。
3. 现在你可以在 Python 中使用它了：
```python
import my_cython_module
result = my_cython_module.add_cython(20, 30)
print(f"20 + 30 = {result}") 输出: 20 + 30 = 50
```
Cython 的优缺点:
优点:
大大降低了编写 C 扩展的复杂度，语法接近 Python。
可以通过类型声明获得接近 C 的性能。
可以轻松调用 C/C++ 代码。
可以用来加速纯 Python 代码的执行。
缺点:
仍需要学习 Cython 特定的语法和概念。
有时调试可能不如纯 Python 或纯 C 直观。
1.3 pybind11
pybind11 是一个专门为 C++11 和更高版本设计的轻量级、跨平台的头文件库，用于创建 Python 和 C++ 之间的绑定。它提供了一种非常简洁优雅的方式来暴露 C++ 类和函数给 Python。
核心概念:
头文件库: 无需编译过程，只需要包含头文件即可。
简洁的语法: 使用宏和模板来定义绑定。
自动类型转换: pybind11 会自动处理大部分 Python 和 C++ 类型之间的转换。
C++ 特性: 对 C++11 的 lambda、智能指针、STL 等有很好的支持。
工作流程:
1. 编写 C++ 源代码:
包含 `pybind11/pybind11.h` 和 `pybind11/stl.h` (如果使用 STL 容器)。
使用 `PYBIND11_MODULE` 宏来定义模块。
在模块定义中，使用 `m.def()` 来暴露 C++ 函数，使用 `py::class_` 来暴露 C++ 类。
2. 编写 `setup.py`:
使用 `setuptools.Extension`，但需要配置编译器和 include 路径以包含 pybind11 的头文件。
3. 编译和安装:
运行 `python setup.py install`。
4. 在 Python 中导入和使用:
`import your_cpp_module`
示例 (简单的加法函数和类):
`my_cpp_module.cpp`:
```cpp
include
// C++ 函数
int cpp_add(int i, int j) {
return i + j;
}
// C++ 类
class Pet {
public:
Pet(const std::string &name) : name(name) {}
void setName(const std::string &name_) { name = name_; }
const std::string &getName() const { return name; }
private:
std::string name;
};
// PYBIND11_MODULE 宏定义了一个模块
// 第一个参数是模块名 (Python 中导入时使用)，第二个参数是模块对象 (通常是 m)
PYBIND11_MODULE(my_cpp_module, m) {
m.doc() = "pybind11 example plugin"; // 可选的模块文档字符串
// 暴露 C++ 函数
// m.attr("add") 是在 Python 中访问的名称
m.attr("add") = &cpp_add;
// 或者使用更简洁的写法：m.def("add", &cpp_add, "A function that adds two numbers");
// 暴露 C++ 类
pybind11::class_
.def(pybind11::init
.def("setName", &Pet::setName, "Set the pet's name") // 成员函数
.def("getName", &Pet::getName, "Get the pet's name"); // 成员函数
}
```
`setup.py`:
```python
import sys
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
pybind11 是一个头文件库，所以我们不需要链接到特殊的库文件
但是我们需要确保编译器能够找到 pybind11 的头文件
通常，你需要将 pybind11 的路径添加到 include_dirs
如果你使用 vcpkg, poetry, pipenv 或 Conda 安装 pybind11，它可能会被自动找到
找到 pybind11 的安装路径（如果通过 pip 安装）
try:
import pybind11
PYBIND11_INCLUDE_DIRS = [pybind11.get_include()]
except ImportError:
PYBIND11_INCLUDE_DIRS = []
print("Pybind11 not found. Please install it using: pip install pybind11")
sys.exit(1)
class BuildExt(build_ext):
"""A custom build_ext command that enables std=c++11 when building modules."""
c_opts = {
'msvc': [],
'unix': ['std=c++11', 'O3', 'Wall'],
}
l_opts = {
'msvc': [],
'unix': [],
}
if sys.platform == 'win32':
extra_compile_args = c_opts['msvc']
else:
extra_compile_args = c_opts['unix']
extra_link_args = l_opts['unix']
def build_extensions(self):
for ext in self.extensions:
ext.extra_compile_args = self.extra_compile_args
ext.extra_link_args = self.extra_link_args
build_ext.build_extensions(self)
cpp_module_extension = Extension(
'my_cpp_module',
sources=['my_cpp_module.cpp'],
include_dirs=PYBIND11_INCLUDE_DIRS,
language='c++',
extra_compile_args=['std=c++11'], Explicitly set C++ standard
)
setup(
name='my_cpp_module',
version='0.1.0',
author='Your Name',
author_email='your.email@example.com',
description='A C++ extension for Python using pybind11',
long_description='',
ext_modules=[cpp_module_extension],
install_requires=['pybind11'], Specify pybind11 as a dependency
cmdclass={'build_ext': BuildExt},
zip_safe=False,
)
```
编译和使用:
1. 安装 pybind11: `pip install pybind11`
2. 保存以上代码为 `my_cpp_module.cpp` 和 `setup.py`。
3. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
或者为了在当前目录生成文件：
```bash
python setup.py build_ext inplace
```
4. 现在你可以在 Python 中使用它了：
```python
import my_cpp_module
调用 C++ 函数
result = my_cpp_module.add(100, 200)
print(f"100 + 200 = {result}") 输出: 100 + 200 = 300
使用 C++ 类
pet = my_cpp_module.Pet("Buddy")
print(f"Pet's name: {pet.getName()}") 输出: Pet's name: Buddy
pet.setName("Max")
print(f"Pet's new name: {pet.getName()}") 输出: Pet's new name: Max
```
pybind11 的优缺点:
优点:
非常简洁优雅的 C++ 绑定语法。
对 C++11 特性的良好支持。
无需学习新的语言（如 Cython），直接使用 C++。
性能好，开销小。
跨平台性好。
缺点:
只能用于 C++ (如果你需要 C，可能需要考虑 CPython API 或 SWIG)。
仍需要编写 C++ 代码和 `setup.py`。
1.4 SWIG
SWIG (Simplified Wrapper and Interface Generator) 是一个非常成熟的工具，可以为 C/C++ 代码生成多种脚本语言（包括 Python）的接口。它通过一个接口文件 (`.i`) 来描述你想暴露哪些 C/C++ 的函数、类、结构体等。
核心概念:
接口文件 (`.i`): 这是 SWIG 的核心，用于描述要包装的 C/C++ 代码的哪些部分。
SWIG 命令: 使用 `swig` 命令来生成 C/C++ 的包装代码和 Python 接口文件。
编译和链接: 生成的 C/C++ 包装代码需要被编译并链接到一个 Python 模块。
`setup.py`: 用于协调 SWIG 生成的代码的编译和链接。
工作流程:
1. 编写 C/C++ 源代码: 正常编写你的 C/C++ 代码。
2. 编写 SWIG 接口文件 (`.i`):
声明要包装的头文件 (`%include`)。
使用 `%module` 定义模块名。
使用 `%typemap` 定义类型映射。
可以使用 `%ignore` 忽略不需要暴露的函数/变量。
3. 运行 SWIG 命令: `swig python your_interface.i`
这会生成 `your_interface_wrap.cxx` (C++ 包装代码) 和 `your_interface.py` (Python 接口文件)。
4. 编写 `setup.py`:
使用 `setuptools.Extension` 来编译 `.cxx` 文件，并链接你的 C/C++ 源文件。
5. 编译和安装:
运行 `python setup.py install`。
6. 在 Python 中导入和使用:
`from your_module import your_interface`
示例 (简单的 C++ 函数):
`my_swig_lib.h`:
```c++
ifndef MY_SWIG_LIB_H
define MY_SWIG_LIB_H
int multiply(int a, int b);
endif // MY_SWIG_LIB_H
```
`my_swig_lib.cpp`:
```cpp
include "my_swig_lib.h"
int multiply(int a, int b) {
return a b;
}
```
`my_swig_lib.i` (SWIG 接口文件):
```swig
// my_swig_lib.i
%module my_swig_lib // Python 中导入的模块名
%{
/ Includes the header in the wrapper code /
include "my_swig_lib.h"
%}
/ Parse the header file to generate the Python bindings /
%include "my_swig_lib.h"
```
`setup.py`:
```python
import os
import sys
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
SWIG 命令行选项
SWIG_FLAGS = ['c++', 'python', 'modern'] c++ for C++, python for Python bindings, modern for modern Python features
SWIG executable path (you might need to adjust this if swig is not in your PATH)
SWIG_EXECUTABLE = "swig"
Generate Python bindings using SWIG
if not os.path.exists("my_swig_lib_wrap.cxx"):
print("Running SWIG...")
swig_command = f"{SWIG_EXECUTABLE} {' '.join(SWIG_FLAGS)} outdir ./ my_swig_lib.i"
print(f"Executing: {swig_command}")
os.system(swig_command)
print("SWIG finished.")
Define the extension module
my_swig_module = Extension(
'_my_swig_lib', Python uses a leading underscore for the compiled extension module
sources=['my_swig_lib.cpp', 'my_swig_lib_wrap.cxx'], C++ source and SWIG generated wrapper
language='c++',
Add any necessary include directories or linker flags for your C++ code
include_dirs=[...],
library_dirs=[...],
libraries=[...],
extra_compile_args=['std=c++11', 'O3'] Example C++11 flag
)
setup(
name='my_swig_lib',
version='0.1.0',
description='A C++ library wrapped with SWIG for Python',
ext_modules=[my_swig_module],
py_modules=["my_swig_lib"], This tells setuptools to package the .py file generated by SWIG
install_requires=[],
cmdclass={'build_ext': build_ext}
)
```
编译和使用:
1. 安装 SWIG: 根据你的操作系统安装 SWIG。
2. 保存以上代码为 `my_swig_lib.h`, `my_swig_lib.cpp`, `my_swig_lib.i`, 和 `setup.py`。
3. 在终端中，进入保存文件的目录，运行：
```bash
python setup.py install
```
或者为了在当前目录生成文件：
```bash
python setup.py build_ext inplace
```
首先 SWIG 会运行生成 `my_swig_lib_wrap.cxx` 和 `my_swig_lib.py`。然后 `setup.py` 会编译这些文件。
4. 现在你可以在 Python 中使用它了：
```python
import my_swig_lib
result = my_swig_lib.multiply(7, 8)
print(f"7 8 = {result}") 输出: 7 8 = 56
```
SWIG 的优缺点:
优点:
支持多种脚本语言，不仅仅是 Python。
处理复杂的 C/C++ 代码（如继承、模板）的能力很强。
可以自动化大量绑定代码的生成。
缺点:
学习曲线相对陡峭，需要掌握 SWIG 的接口语言。
生成的代码可能不如手写或 pybind11 精简。
调试可能比直接 C API 或 pybind11 更困难。
2. 进程间通信 (IPC)
当你的 C/C++ 程序和 Python 程序是独立运行时，可以使用 IPC 来交换数据。这种方式解耦了两个进程，但数据交换会有序列化/反序列化的开销。
2.1 管道 (Pipes)
管道是最简单的 IPC 机制之一，用于进程间通信。它通常是单向的。
工作流程:
1. 启动子进程: Python 可以使用 `subprocess` 模块启动 C/C++ 程序，并为其创建标准输入、输出和错误流。
2. 数据写入: C/C++ 程序向其标准输出写入数据。
3. 数据读取: Python 程序从 C/C++ 进程的标准输出中读取数据。
4. 数据写入 (反向): Python 程序向 C/C++ 进程的标准输入写入数据。
5. 数据读取 (反向): C/C++ 程序从其标准输入读取数据。
示例:
`calculator.cpp`:
```cpp
include
include
include
int main() {
std::string line;
while (std::cin >> line) {
std::stringstream ss(line);
int a, b;
char op;
ss >> a >> op >> b; // 假设输入格式为 "数字 运算符 数字"
int result;
if (op == '+') {
result = a + b;
} else if (op == '') {
result = a b;
} else {
result = 1; // 简单错误处理
}
std::cout << result << std::endl; // 输出结果
}
return 0;
}
```
`run_calculator.py`:
```python
import subprocess
import sys
编译 C++ 代码 (如果还没有编译)
在实际项目中，您会使用 CMake 或其他构建系统来管理编译
subprocess.run(["g++", "calculator.cpp", "o", "calculator_exe"])
启动 C++ 程序作为子进程
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
text=True 表示将输入输出作为文本处理 (自动编码/解码)
process = subprocess.Popen(
["./calculator_exe"], 替换为你的 C++ 程序路径
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True 使用文本模式
)
发送数据给 C++ 程序
input_data = "10 + 20 "
print(f"Python sending: {input_data.strip()}")
stdout, stderr = process.communicate(input=input_data)
stdout 包含 C++ 程序的所有输出
if stdout:
print(f"Python received: {stdout.strip()}")
stderr 包含 C++ 程序的错误输出
if stderr:
print(f"C++ stderr: {stderr.strip()}")
发送另一个数据
input_data_2 = "5 6 "
print(f"Python sending: {input_data_2.strip()}")
使用 process.stdin.write() 和 process.stdout.read() 进行更细粒度的控制
这里为了简单起见，重新使用 communicate (请注意，communicate 只能调用一次，除非重新创建进程)
更常见的方法是使用 stdin.write() 和 stdout.read() 并手动处理行结束符
让我们演示一下更精细的控制
process = subprocess.Popen(
["./calculator_exe"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
process.stdin.write("15 + 25 ")
process.stdin.flush() 确保数据被发送
result_line = process.stdout.readline() 读取一行输出
print(f"Python received: {result_line.strip()}")
关闭 stdin
process.stdin.close()
获取剩余的 stderr (如果存在)
stderr_output = process.stderr.read()
if stderr_output:
print(f"C++ stderr: {stderr_output.strip()}")
```
管道的优缺点:
优点:
简单易用，适用于简单的进程间通信。
操作系统内置支持。
缺点:
通常是单向通信，双向需要两个管道。
数据需要序列化/反序列化。
如果 C++ 程序不是为管道设计的，需要修改。
2.2 套接字 (Sockets)
套接字是更通用的 IPC 和网络通信方式。你可以创建一个 TCP/IP 套接字服务器（用 C++ 或 Python）和一个客户端（用另一个语言）。
工作流程:
1. 服务器端:
创建套接字。
绑定到一个地址和端口。
监听连接。
接受客户端连接。
接收/发送数据。
关闭连接/套接字。
2. 客户端:
创建套接字。
连接到服务器的地址和端口。
发送/接收数据。
关闭套接字。
示例 (使用 TCP 套接字):
`server.cpp`:
```cpp
include
include
include
include
include
include
include
define PORT 8080
define BUFFER_SIZE 1024
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[BUFFER_SIZE] = {0};
// 创建 socket 文件描述符
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 强制连接到指定端口
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt");
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY; // 监听任何 IP 地址
address.sin_port = htons(PORT); // 端口号
// 绑定 socket 到指定地址和端口
if (bind(server_fd, (struct sockaddr )&address, sizeof(address)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
// 开始监听，最多允许 backlog 个连接
if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
std::cout << "Server listening on port " << PORT << std::endl;
// 接受客户端连接
if ((new_socket = accept(server_fd, (struct sockaddr )&address, (socklen_t)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}
std::cout << "Connection accepted." << std::endl;
// 读取客户端发送的数据
int valread = read(new_socket, buffer, BUFFER_SIZE);
if (valread < 0) {
perror("read failed");
} else {
std::cout << "Message from client: " << buffer << std::endl;
// 处理数据，例如执行计算
// 假设客户端发送的是 "add 10 20"
std::string msg(buffer);
if (msg.rfind("add", 0) == 0) { // Check if message starts with "add"
std::stringstream ss(msg);
std::string command;
int a, b;
ss >> command >> a >> b;
int result = a + b;
std::string response = std::to_string(result);
send(new_socket, response.c_str(), response.length(), 0);
std::cout << "Sent result to client: " << result << std::endl;
} else {
send(new_socket, "Unknown command", 15, 0);
}
}
// 关闭套接字
close(new_socket);
close(server_fd);
std::cout << "Server stopped." << std::endl;
return 0;
}
```
`client.py`:
```python
import socket
HOST = '127.0.0.1' Standard loopback interface address (localhost)
PORT = 8080 Port to listen on (nonprivileged ports are > 1023)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
发送一个请求到 C++ 服务器
request = "add 50 60"
print(f"Python sending: {request}")
s.sendall(request.encode()) 发送编码后的字节
接收响应
data = s.recv(1024) 接收最多 1024 字节
print(f"Python received: {data.decode()}") 解码接收到的字节
注意：这个例子是 Python 作为客户端连接到 C++ 服务器。
如果你想 C++ 作为客户端连接到 Python 服务器，你需要修改 server.cpp 为 client.cpp
并创建一个 Python 服务器脚本。
```
套接字的优缺点:
优点:
非常灵活，支持网络通信，可以在不同机器之间通信。
支持 TCP (可靠传输) 和 UDP (不可靠但快速传输)。
成熟的协议和库支持。
缺点:
需要编写服务器和客户端逻辑。
数据序列化/反序列化开销。
网络延迟。
需要处理更复杂的错误和异常情况。
2.3 共享内存 (Shared Memory)
共享内存允许两个进程直接访问同一块内存区域，速度非常快，但需要谨慎管理，避免竞态条件。通常需要同步机制（如信号量、互斥锁）。
实现方式:
POSIX 共享内存: 通过 `shm_open`, `ftruncate`, `mmap` 等系统调用实现。
System V 共享内存: 通过 `shmget`, `shmat`, `shmdt` 等系统调用实现。
Python 库: `multiprocessing.shared_memory` (Python 3.8+)。
工作流程 (以 Python `multiprocessing.shared_memory` 为例):
1. 创建共享内存: 一个进程（通常是主进程）创建共享内存块。
2. 访问共享内存: 其他进程通过名称查找并访问该共享内存块。
3. 读写数据: 进程直接在共享内存区域读写数据。
4. 同步: 使用锁或其他同步机制保护对共享内存的访问。
5. 关闭/释放: 使用完毕后，需要关闭和释放共享内存。
示例 (简化的 C++ 读，Python 写):
`shared_memory_reader.cpp`:
```cpp
include
include
include
include
include
include
define SHM_NAME "/my_shared_memory"
define SHM_SIZE 1024
int main() {
// 打开已存在的共享内存对象
int shm_fd = shm_open(SHM_NAME, O_RDONLY, 0666);
if (shm_fd == 1) {
perror("shm_open");
return 1;
}
// 将共享内存映射到进程地址空间
void ptr = mmap(0, SHM_SIZE, PROT_READ, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
std::cout << "Shared memory mapped. Waiting for data..." << std::endl;
char shared_data = (char)ptr;
// 循环读取数据直到看到特定标记或空字符串
while (true) {
if (strlen(shared_data) > 0) {
std::cout << "Read from shared memory: " << shared_data << std::endl;
// 在实际应用中，你可能需要一个同步机制来知道何时数据有效
// 这里为了简单，我们只是打印并让 Python 更新它
// 如果需要更复杂的同步，可以使用信号量
// 清空共享内存，表示数据已被读取 (如果需要)
// memset(shared_data, 0, SHM_SIZE);
// 或者等待 Python 写入新的数据
sleep(1); // 短暂休眠，避免 CPU 空转
} else {
// 如果共享内存为空，稍作等待
usleep(100000); // 100ms
}
}
// unmap and close (in this example, it runs indefinitely, so this part is not reached)
// munmap(ptr, SHM_SIZE);
// close(shm_fd);
// shm_unlink(SHM_NAME); // Only the creator should unlink
return 0;
}
```
`shared_memory_writer.py`:
```python
import multiprocessing.shared_memory
import time
SHM_NAME = "/my_shared_memory"
SHM_SIZE = 1024
try:
创建或打开共享内存
如果不存在，创建；如果存在，打开
shm = multiprocessing.shared_memory.SharedMemory(name=SHM_NAME, create=True, size=SHM_SIZE)
print(f"Shared memory '{SHM_NAME}' created/opened successfully.")
给 C++ 进程一点时间来映射
time.sleep(2)
将数据写入共享内存
message = "Hello from Python!"
print(f"Writing to shared memory: {message}")
将字符串转换为字节并复制到共享内存中
注意：共享内存的内容是字节，需要正确处理编码和长度
shm.buf[:len(message)] = message.encode()
在实际应用中，您可能需要一个同步机制来通知 C++ 读取数据
例如，可以写入一个单独的标志位或者等待 C++ 的确认
等待一段时间，让 C++ 读取
time.sleep(3)
写入新的消息
message_2 = "Another message from Python."
print(f"Writing to shared memory: {message_2}")
shm.buf[:len(message_2)] = message_2.encode()
time.sleep(3)
except FileExistsError:
print(f"Shared memory '{SHM_NAME}' already exists. Trying to connect to it.")
try:
shm = multiprocessing.shared_memory.SharedMemory(name=SHM_NAME)
print(f"Connected to existing shared memory '{SHM_NAME}'.")
在这个场景下，您可能只需要作为写入者，而另一个进程是只读的
例如， Python 写入，C++ 读取
message = "Hello from Python!"
print(f"Writing to shared memory: {message}")
shm.buf[:len(message)] = message.encode()
time.sleep(3)
message_2 = "Another message from Python."
print(f"Writing to shared memory: {message_2}")
shm.buf[:len(message_2)] = message_2.encode()
time.sleep(3)
except FileNotFoundError:
print(f"Error: Shared memory '{SHM_NAME}' not found.")
except Exception as e:
print(f"An error occurred: {e}")
finally:
关闭共享内存
if 'shm' in locals() and shm:
shm.close()
通常，只有创建者才应该unlink共享内存
如果你希望每次运行都重新创建，可以取消下面这行注释
shm.unlink()
print(f"Shared memory '{SHM_NAME}' closed.")
```
共享内存的优缺点:
优点:
速度极快，因为数据不需要复制。
适合传输大量数据。
缺点:
实现复杂，需要处理同步问题，容易发生数据冲突。
需要明确的内存管理。
跨平台性可能不如套接字。
3. 远程过程调用 (RPC)
RPC 允许一个程序调用另一个地址空间（通常是另一台机器上）的过程，就好像它是本地过程一样。
3.1 gRPC
gRPC 是一个高性能、开源的通用 RPC 框架，由 Google 开发。它使用 Protocol Buffers 作为接口定义语言 (IDL)，并支持多种语言。
工作流程:
1. 定义服务 (`.proto` 文件): 使用 Protocol Buffers 定义服务接口和消息结构。
2. 生成代码: 使用 `protoc` 编译器和相应的 gRPC 语言插件生成服务器和客户端的代码框架。
3. 实现服务器: 编写 C++ 或 Python 代码实现服务接口，并启动 gRPC 服务器。
4. 实现客户端: 编写 C++ 或 Python 代码作为客户端，调用服务。
优点:
高性能，基于 HTTP/2。
接口定义清晰，易于维护。
跨语言支持极佳。
支持流式通信。
缺点:
学习曲线相对较陡峭，需要理解 Protocol Buffers 和 gRPC 概念。
需要编译和生成代码。
3.2 Thrift / XMLRPC / JSONRPC
这些也是常见的 RPC 框架，工作流程类似 gRPC，但使用的 IDL 和传输协议可能不同。
4. 其他方式
4.1 数据交换 (File I/O)
最简单直接的方式，但效率最低。
流程: C++ 程序将数据写入文件，Python 程序读取文件；或反之。
优点: 非常简单，无需额外库。
缺点: 速度慢，有磁盘 I/O 开销，不适合实时通信。
4.2 嵌入式解释器
将 Python 解释器嵌入到 C/C++ 程序中，允许 C/C++ 程序直接调用 Python 代码和对象。
Python C API: 通过 `Python.h` 提供的函数可以在 C/C++ 中初始化 Python 解释器，执行 Python 语句，调用 Python 函数，传递数据。
优点: 深度集成，C/C++ 可以完全控制 Python 的行为。
缺点: 配置和管理复杂，需要处理引用计数和全局解释器锁 (GIL)。
示例 (在 C++ 中嵌入 Python):
`embedded_python.cpp`:
```cpp
include
include
include
int main() {
PyObject pName, pModule, pFunc;
PyObject pArgs, pValue;
// 初始化 Python 解释器
Py_Initialize();
// 导入 Python 模块 (假设有一个名为 "my_python_script" 的文件)
pName = PyUnicode_DecodeFSDefault("my_python_script"); // 模块名
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
// 获取模块中的函数 (假设函数名为 "greet")
pFunc = PyObject_GetAttrString(pModule, "greet");
// 检查函数是否存在且可调用
if (pFunc && PyCallable_Check(pFunc)) {
// 创建传递给函数的参数列表
pArgs = PyTuple_New(1); // 一个参数
pValue = PyUnicode_FromString("C++ Program"); // 要传递的字符串
if (!pValue) {
PyErr_Print();
Py_DECREF(pFunc);
Py_DECREF(pModule);
Py_Finalize();
return 1;
}
PyTuple_SetItem(pArgs, 0, pValue); // 将参数放入元组
// 调用 Python 函数
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
// 处理函数返回值
const char greeting = PyUnicode_AsUTF8(pValue);
std::cout << "Received from Python: " << greeting << std::endl;
Py_DECREF(pValue);
} else {
PyErr_Print();
}
} else {
if (PyErr_Occurred()) PyErr_Print();
fprintf(stderr, "Cannot find function "greet" ");
}
Py_XDECREF(pFunc); // 使用 XDECREF 来处理 pFunc 可能为 NULL 的情况
Py_DECREF(pModule);
} else {
PyErr_Print();
fprintf(stderr, "Failed to load "my_python_script" ");
Py_Finalize();
return 1;
}
// 结束 Python 解释器
Py_Finalize();
return 0;
}
```
`my_python_script.py`:
```python
def greet(name):
return f"Hello, {name}! This is Python speaking."
```
编译和使用:
1. 安装 Python 开发头文件: 确保你的系统安装了 Python 开发包（例如，在 Debian/Ubuntu 上是 `python3dev`，在 Fedora 上是 `python3devel`）。
2. 保存文件: 将上面的 C++ 代码保存为 `embedded_python.cpp`，Python 代码保存为 `my_python_script.py`。
3. 编译 C++ 代码: 使用 g++，并链接 Python 库。具体的编译命令取决于你的操作系统和 Python 安装方式。
Linux/macOS (示例):
```bash
查找 Python 库和头文件路径
PYTHON_INCLUDE=$(python3config includes)
PYTHON_LIB=$(python3config libs)
g++ embedded_python.cpp o embedded_python_exe $PYTHON_INCLUDE $PYTHON_LIB lpython3.x 替换 x 为你的 Python 小版本号
```
你需要找到正确的 `python3.x` 来链接。
如果 Python 安装在非标准位置，你可能需要手动指定 `I` 和 `L` 路径。
4. 运行:
```bash
python3 my_python_script.py 确保 Python 脚本可被找到
./embedded_python_exe
```
输出应该类似：
```
Received from Python: Hello, C++ Program! This is Python speaking.
```
嵌入式解释器的优缺点:
优点:
允许 C/C++ 代码动态执行和控制 Python 代码。
非常适合需要调用大量 Python 函数或脚本的场景。
缺点:
配置和管理复杂。
性能开销可能较大。
GIL 问题可能影响并发性能。
错误处理和调试难度较大。
总结与选择建议
| 通信方式 | 适用场景 | 优点 | 缺点 |
| : | : | : | : |
| Python C API | 性能极致要求，直接访问 Python 对象 | 最底层，控制力最强，性能最高 | 学习曲线陡峭，易出错 |
| Cython | Python 性能优化，简化 C 扩展编写 | 接近 Python 语法，性能好 | 需要学习 Cython 语法 |
| pybind11 | C++ 代码暴露给 Python | 简洁优雅，C++11 支持好，跨平台 | 只能用于 C++ |
| SWIG | 包装大量 C/C++ 代码，支持多种脚本语言 | 支持语言多，自动化程度高 | 接口文件学习，代码可能不够精简 |
| 管道 (Pipes) | 简单进程间通信 | 简单易用 | 单向，数据格式固定 |
| 套接字 (Sockets) | 网络通信，独立进程通信 | 灵活通用，支持网络，协议多样 | 需要服务器/客户端逻辑，序列化开销 |
| 共享内存 | 大数据量传输，高性能进程间通信 | 速度极快 | 实现复杂，需要同步，平台依赖性 |
| gRPC / Thrift (RPC) | 分布式系统，微服务，跨语言服务调用 | 高性能，接口定义清晰，跨语言 | 学习曲线，需要编译生成代码 |
| 文件 I/O | 数据持久化，简单非实时数据交换 | 最简单 | 效率低 |
| 嵌入式解释器 | C/C++ 程序需要动态调用 Python | C/C++ 完全控制 Python | 配置复杂，GIL 问题，调试困难 |
如何选择？
如果你想将 C/C++ 代码作为库提供给 Python:
C++: 强烈推荐 pybind11。它最现代、最简洁，对 C++11/14/17 的支持非常好。
C: Python C API 是最基础但也是最强大的选择，但编写复杂。Cython 是一个不错的折衷，可以让你用接近 Python 的语法写高性能代码。SWIG 适合包装现有的大型 C 库。
如果你的 C++ 程序是一个独立的服务器，Python 是客户端:
网络通信: 使用 套接字 或更高级的 RPC 框架如 gRPC。gRPC 尤其适合构建微服务和需要高性能的场景。
如果你的 C++ 和 Python 程序在同一台机器上运行，但需要独立进程:
简单的通信: 管道 或 套接字。
大数据量: 共享内存，但要小心处理同步。
如果你想在 C++ 程序中运行 Python 脚本或调用 Python 函数:
嵌入式解释器 是你的首选。
最佳实践:
清晰的接口定义: 无论使用哪种方法，都要有一个清晰的数据和功能接口定义。
错误处理: 充分考虑双方可能出现的错误，并进行妥善处理。
性能考虑: 在性能敏感的场景下，选择开销最小的通信方式，并进行基准测试。
构建系统: 使用 CMake、setuptools、Makefile 等构建工具来管理编译和打包过程。
版本控制: 确保 C/C++ 和 Python 代码的版本兼容性。
希望这份详细的介绍能够帮助你理解和选择合适的 C/C++ 与 Python 通信方式！
网友意见
想在 C++ 中用 Python 进行数值计算，Python 需要访问 C++ 的变量并计算后返回数值。有什么好办法呢？
类似的话题
-
实现 C/C++ 与 Python 的通信是一个非常常见且重要的需求，它允许我们充分利用 C/C++ 的高性能和 Python 的易用性及丰富的库。下面我将详细介绍几种主流的通信方式，并尽可能地提供详细的解释和示例。 为什么需要 C/C++ 与 Python 通信？ 性能优化: C/C++ 在计............. -
const 的守护之剑：编译器如何雕琢 C/C++ 中的不变之道在C/C++的世界里，`const` 并非只是一个简单的关键字，它更像一把锋利的守护之剑，承诺着数据的不可变性，为程序的稳定性和可维护性筑起一道坚实的壁垒。那么，这把剑究竟是如何被铸造和挥舞的呢？这背后，是编译器一系列精巧的设计和严密的.............
-
C 和 C++ 在软件开发领域各有其独特的优势和适用的场景。理解它们各自的适用范围，以及如何构建和维护 C++ 的动态库，对于成为一名优秀的工程师至关重要。 C 的适用场合C 语言以其简洁、高效和对底层硬件的直接控制能力而闻名。这使得它在许多对性能和资源消耗要求极高的领域大放异彩： 操作系统内核.............
-
好的，让我为你详细讲解一下如何在 C 中实现类似 `Nullable` 的效果，不使用列表，并且尽力做到自然、深入。想象一下，我们经常会遇到这样的情况：一个变量，它要么拥有一个有效的值，要么就是“不存在”——没有具体的值。在 C 中，`int`、`string`、`DateTime` 这些值类型（v.............
-
当然，我们来聊聊如何在 C 中实现一个避免装箱的通用容器。这实际上是一个挺有意思的话题，因为它触及了 C 类型系统和性能优化的核心。你提到的“装箱”（boxing）是指当一个值类型（比如 `int`, `float`, `struct`）被当作引用类型（比如 `object`）来处理时，会在托管堆上.............
-
在 C 中与 Native DLL 进行线程间通信，尤其是在 Native DLL 内部创建了新的线程，这确实是一个比较考验功力的问题。我们通常不是直接“命令” Native DLL 中的某个线程与 C 中的某个线程通信，而是通过一套约定好的机制，让双方都能感知到对方的存在和传递的数据。这里我们不谈.............
-
好的，咱们来聊聊 C++11 里怎么把单例模式玩明白。这玩意儿看着简单，但要弄得既安全又高效，还得考虑不少细节。咱们就抛开那些花里胡哨的“AI风”描述，实打实地把这事儿掰开了揉碎了说。单例模式，说白了就是保证一个类在整个程序的生命周期里，只有一个实例存在，并且提供一个全局的访问点。想象一下，你有个配.............
-
好的，咱们就来聊聊 C++ 这玩意儿，从它“根儿上”是怎么玩的。别以为 C++ 就是个简单的指令堆砌，它的背后可是一套相当精巧、而且历久弥新的设计思想。首先得明确一个概念：C++ 本身并不是一种可以直接在硬件上运行的语言。它是一种高级语言，我们写的是 C++ 代码，然后得通过一个叫做编译器的东西，把.............
-
C 语言中指针加一这看似简单的操作，背后隐藏着计算机底层的工作原理。这并不是简单的数值加一，而是与内存的组织方式和数据类型紧密相关。要理解指针加一，我们首先需要明白什么是“指针”。在 C 语言里，指针本质上是一个变量，它存储的是另一个变量的内存地址。你可以把它想象成一个房间号，这个房间号指向的是实际.............
-
在 C 中实现 Go 语言 `select` 模式的精髓，即 等待多个异步操作中的任何一个完成，并对其进行处理，最贴切的类比就是使用 `Task` 的组合操作，尤其是 `Task.WhenAny`。Go 的 `select` 语句允许你监听多个通道（channel）的状态，当其中任何一个通道有数据可.............
-
.......
-
好的，非常乐意为您详细讲解如何使用 C 语言和 Windows API 实现一个基本的 SSL/TLS 协议。您提到参考资料已备齐，这非常好，因为 SSL/TLS 是一个相当复杂的协议，没有参考资料很难深入理解。我们将从一个高层次的概述开始，然后逐步深入到具体的 Windows API 函数和 C .............
-
在 C/C++ 项目中，将函数的声明和实现（也就是函数体）直接写在同一个头文件里，看似方便快捷，实际上隐藏着不少潜在的麻烦。这种做法就像是把家里的厨房和卧室直接打通，虽然一开始可能觉得省事，但长远来看，带来的问题会远超于那一点点便利。首先，最直接也是最普遍的问题是 重复定义错误 (Multiple .............
-
长城汽车在2021年率先推出全球首款C级氢燃料电池SUV的雄心，无疑是一记响亮的宣言，预示着其在新能源汽车领域的深刻布局。如果这一目标能够如期实现，无疑将在汽车行业留下浓墨重彩的一笔。然而，这并非一条平坦的道路，长城汽车在实现这一宏伟蓝图的过程中，必然要面对一系列严峻的挑战。一、核心技术与成本的双重.............
-
咱们聊聊 C 里的接口，这玩意儿在实际开发中，那可是个顶顶重要的角色，但要是光看定义，可能觉得有点抽象。我试着把这些实际用法给你掰开了揉碎了讲讲，尽量避免那些“AI味儿”的说法，就跟咱们哥俩坐一块儿聊天一样。接口是啥？通俗点说，就是一份“合同”你可以把接口想象成一个约定，或者一份“合同”。这份合同规.............
-
从“纸上谈兵”到“上阵杀敌”：让你的 C++ 真正落地生根许多人学习 C++，往往沉溺于其强大的语法和丰富的功能，如同进入一个精巧的数学王国。我们熟练掌握了指针、类、继承、多态，能够写出逻辑严谨的代码。然而，当真正面对一个复杂的软件项目时，却发现自己仿佛置身于一个陌生的战场，曾经熟悉的语法工具似乎不.............
-
这道题确实很有意思，问的是三个实数 $a, b, c$ 的立方和的最小值，并且给定了两个重要的约束条件：$a+b+c=1$ 和 $a^2+b^2+c^2=1$。我们来一步步地把它解开。1. 理解题目和已知条件我们有： $a, b, c in mathbb{R}$ (实数) $a+b+c = .............
-
《C++并发编程实战》：一本让你真正驾驭多核时代的必读之作对于 C++ 开发者而言，在当今多核处理器已经成为标配的时代，掌握并发编程技术无疑是提升代码性能和应对复杂场景的关键。而说到 C++ 并发编程，很少有书能像《C++并发编程实战》（英文原版为《C++ Concurrency in Action.............
-
葡萄牙国家队如今的实力，就像一张摆满了精致菜肴的餐桌，但缺少了那位能将所有味道完美融合的大厨。看如今的葡萄牙国家队，我首先想到的是“人才济济，但整体性略显不足”。 中前场的黄金一代依然闪耀： 别忘了，我们仍然坐拥像B费、B席、Leão这样的球员，他们在各自的俱乐部都是绝对的核心。B费的创造力、B.............
-
“病有所医”是中国人民最基本的愿望之一，也是衡量一个国家医疗卫生体系健康与否的重要指标。在2020年这个特殊的年份，面对全球疫情的洗礼，人们对“病有所医”的理解和需求也更加深刻。要实现“病有所医”，需要系统性的改革和持续的投入，以下是我在2020年可以提出的几点详细建议，涵盖了医保、医疗资源、人才培.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有