C++实现跨语言（如Python/Java）的调用封装：处理堆栈转换与数据序列化

C++跨语言调用封装：堆栈转换与数据序列化

大家好，今天我们要深入探讨C++如何实现跨语言调用，例如调用Python或Java代码。这涉及两个核心挑战：堆栈转换和数据序列化/反序列化。我们将通过理论讲解和实际代码示例，详细阐述如何应对这些挑战。

1. 跨语言调用的必要性与常见方案

跨语言调用通常出现在以下场景：

• 利用现有资源: 某些语言拥有成熟的库或框架，C++项目可能需要利用这些资源，例如Python的科学计算库NumPy或Java的大数据处理框架Spark。
• 性能优化: C++以其高性能著称，可以用来优化Python或Java等语言编写的性能瓶颈代码。
• 遗留系统集成: 将用不同语言编写的旧系统整合到一个新的系统中。

常见的跨语言调用方案包括：

• COM (Component Object Model): 主要用于Windows平台，允许不同语言编写的组件进行交互。
• CORBA (Common Object Request Broker Architecture): 一种分布式对象架构，允许不同语言编写的程序通过网络进行通信。
• JNI (Java Native Interface): 允许Java代码调用本地(通常是C/C++)代码。
• SWIG (Simplified Wrapper and Interface Generator): 一个代码生成器，可以自动生成不同语言的接口代码，简化跨语言调用。
• gRPC (gRPC Remote Procedure Calls): 一种高性能、开源的通用 RPC 框架，使用 Protocol Buffers 作为接口定义语言。
• 自定义桥接库: 使用C/C++作为桥梁，手动处理数据序列化和函数调用。

本文重点介绍最后一种方案，即自定义桥接库，因为它能让我们更深入地理解跨语言调用的底层原理，并提供最大的灵活性。

2. 堆栈转换：不同语言的函数调用约定

不同编程语言使用不同的函数调用约定（calling convention）。调用约定规定了函数参数的传递方式（例如，通过寄存器还是堆栈）、参数的传递顺序（从左到右还是从右到左），以及谁负责清理堆栈（调用者还是被调用者）。

C++常见的调用约定包括：

• cdecl: C/C++的默认调用约定，参数从右到左压入堆栈，调用者负责清理堆栈。
• stdcall: 主要用于Windows API，参数从右到左压入堆栈，被调用者负责清理堆栈。
• fastcall: 尝试将参数通过寄存器传递，以提高性能，具体实现依赖于编译器。

Python和Java也有自己的调用约定。当C++调用Python或Java函数时，必须按照目标语言的调用约定来准备参数，并在函数返回后正确清理堆栈。

示例：C++调用Python函数

为了调用Python函数，我们需要使用Python提供的C API。以下是一个简单的例子，展示了如何从C++调用Python函数：

#include <Python.h>
#include <iostream>

int main() {
  // 1. 初始化Python解释器
  Py_Initialize();

  // 2. 导入Python模块
  PyObject* pModule = PyImport_ImportModule("my_python_module");
  if (!pModule) {
    PyErr_Print();
    return 1;
  }

  // 3. 获取Python函数
  PyObject* pFunc = PyObject_GetAttrString(pModule, "my_python_function");
  if (!pFunc || !PyCallable_Check(pFunc)) {
    PyErr_Print();
    return 1;
  }

  // 4. 准备参数 (将C++数据转换为Python对象)
  PyObject* pArgs = PyTuple_New(1); // 创建一个包含一个元素的元组
  PyObject* pValue = PyLong_FromLong(123); // 将C++ int 转换为 Python long
  PyTuple_SetItem(pArgs, 0, pValue); // 设置元组的第一个元素

  // 5. 调用Python函数
  PyObject* pResult = PyObject_CallObject(pFunc, pArgs);
  if (!pResult) {
    PyErr_Print();
    return 1;
  }

  // 6. 处理返回值 (将Python对象转换为C++数据)
  long result = PyLong_AsLong(pResult);
  std::cout << "Python function returned: " << result << std::endl;

  // 7. 清理资源
  Py_DECREF(pModule);
  Py_DECREF(pFunc);
  Py_DECREF(pArgs);
  Py_DECREF(pResult);

  // 8. 释放Python解释器
  Py_Finalize();

  return 0;
}

在这个例子中，我们做了以下堆栈转换工作：

• 将C++的int类型的数值 123 转换为 Python的 long 类型的 PyObject。
• Python函数返回的 PyObject 转换为 C++ 的 long 类型。

my_python_module.py:

def my_python_function(x):
  return x * 2

编译和链接:

你需要安装Python开发包，并将其包含目录和库目录添加到C++编译器的搜索路径中。 例如，在使用g++编译时，可能需要添加类似以下的选项：

g++ -I/usr/include/python3.8 -L/usr/lib/python3.8 -lpython3.8 main.cpp -o my_cpp_program

关键点:

• Py_Initialize() 和 Py_Finalize() 用于初始化和释放Python解释器。
• PyImport_ImportModule() 用于导入Python模块。
• PyObject_GetAttrString() 用于获取Python对象（例如函数）。
• PyObject_CallObject() 用于调用Python函数。
• PyTuple_New(), PyLong_FromLong(), PyTuple_SetItem() 用于创建和填充参数元组。
• PyLong_AsLong() 用于将Python对象转换为C++的long类型。
• Py_DECREF() 用于减少Python对象的引用计数，避免内存泄漏。

示例：C++调用Java函数 (通过JNI)

JNI (Java Native Interface) 是 Java 平台的标准机制，允许 Java 代码调用本地（通常是 C/C++）代码。

#include <jni.h>
#include <iostream>

// 声明Java类和方法的签名 (需要根据Java代码生成)
extern "C" {
  JNIEXPORT jstring JNICALL Java_MyJavaClass_myJavaMethod(JNIEnv* env, jobject obj, jstring javaString);
}

// 实现 JNI 函数
JNIEXPORT jstring JNICALL Java_MyJavaClass_myJavaMethod(JNIEnv* env, jobject obj, jstring javaString) {
  // 1. 将 Java 字符串转换为 C++ 字符串
  const char* str = env->GetStringUTFChars(javaString, 0);
  std::string cppString(str);
  env->ReleaseStringUTFChars(javaString, str);

  // 2. 在 C++ 中处理字符串
  std::string result = "Hello from C++: " + cppString;

  // 3. 将 C++ 字符串转换为 Java 字符串
  return env->NewStringUTF(result.c_str());
}

MyJavaClass.java:

public class MyJavaClass {
  static {
    System.loadLibrary("my_native_library"); // 加载本地库
  }

  public native String myJavaMethod(String input);

  public static void main(String[] args) {
    MyJavaClass obj = new MyJavaClass();
    String result = obj.myJavaMethod("World");
    System.out.println(result); // 输出: Hello from C++: World
  }
}

编译和链接:

1. 编译 Java 代码: javac MyJavaClass.java
2. 生成头文件: javah MyJavaClass (这将生成 MyJavaClass.h 文件，其中包含 JNI 函数的声明)

3. 编译 C++ 代码: 你需要包含 jni.h 头文件，该文件通常位于 JDK 的 include 目录下。例如，使用 g++ 编译时，可能需要添加类似以下的选项：

   g++ -I/usr/lib/jvm/java-11-openjdk-amd64/include -I/usr/lib/jvm/java-11-openjdk-amd64/include/linux -shared -fPIC my_native_library.cpp -o libmy_native_library.so

   • -I 选项指定包含目录。
   • -shared 选项创建共享库（.so 文件）。
   • -fPIC 选项生成位置无关代码。

关键点:

• jni.h 头文件包含 JNI 相关的函数和数据结构的定义。
• JNIEnv* 是一个指向 JNI 环境的指针，提供了访问 Java 虚拟机的功能。
• jobject 是指向 Java 对象的引用。
• jstring 是 Java 字符串的 JNI 类型。
• GetStringUTFChars() 和 ReleaseStringUTFChars() 用于将 Java 字符串转换为 C++ 字符串，以及释放资源。
• NewStringUTF() 用于将 C++ 字符串转换为 Java 字符串。
• System.loadLibrary() 用于加载本地库。
• JNI 函数的命名约定：Java_包名_类名_方法名。

3. 数据序列化/反序列化：跨语言的数据交换

不同语言使用不同的数据类型和内存布局。为了在C++和Python/Java之间传递数据，我们需要将数据序列化成一种通用的格式，然后在目标语言中反序列化。

常见的数据序列化格式包括：

• JSON (JavaScript Object Notation): 一种轻量级的数据交换格式，易于阅读和编写，被广泛应用于Web API。
• XML (Extensible Markup Language): 一种标记语言，可以用来描述复杂的数据结构，但相比JSON更冗长。
• Protocol Buffers: 一种由Google开发的序列化协议，具有高性能和可扩展性，常用于gRPC。
• MessagePack: 一种高效的二进制序列化格式，类似于JSON，但更紧凑。

示例：使用JSON进行数据交换 (C++和Python)

C++ (使用 RapidJSON 库):

#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include <iostream>
#include <string>

using namespace rapidjson;

std::string serializeToJson() {
  Document document;
  document.SetObject();
  Document::AllocatorType& allocator = document.GetAllocator();

  document.AddMember("name", Value("John Doe", allocator).Move(), allocator);
  document.AddMember("age", 30, allocator);

  Value address(kObjectType);
  address.AddMember("street", Value("123 Main St", allocator).Move(), allocator);
  address.AddMember("city", Value("Anytown", allocator).Move(), allocator);
  document.AddMember("address", address, allocator);

  StringBuffer buffer;
  Writer<StringBuffer> writer(buffer);
  document.Accept(writer);

  return buffer.GetString();
}

int main() {
  std::string jsonString = serializeToJson();
  std::cout << "JSON: " << jsonString << std::endl;
  return 0;
}

Python:

import json

def deserialize_json(json_string):
  data = json.loads(json_string)
  print(f"Name: {data['name']}")
  print(f"Age: {data['age']}")
  print(f"Address: {data['address']['street']}, {data['address']['city']}")

# 假设你从C++程序获得了 JSON 字符串
json_string = '{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown"}}'
deserialize_json(json_string)

解释:

• C++: 我们使用 RapidJSON 库来创建和序列化JSON对象。RapidJSON是一个快速的C++ JSON库，易于使用。
• Python: 我们使用 json 模块来解析JSON字符串并访问其中的数据。

示例：使用 Protocol Buffers 进行数据交换 (C++和Python)

person.proto:

syntax = "proto3";

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;
}

C++ (使用 protobuf 库):

#include "person.pb.h"
#include <iostream>
#include <fstream>

int main() {
  // 创建一个 Person 对象
  tutorial::Person person;
  person.set_name("John Doe");
  person.set_id(123);
  person.set_email("[email protected]");

  // 序列化到字符串
  std::string serialized_string;
  person.SerializeToString(&serialized_string);

  // 序列化到文件
  std::fstream output("person.data", std::ios::out | std::ios::trunc | std::ios::binary);
  if (!person.SerializeToOstream(&output)) {
    std::cerr << "Failed to write person to file." << std::endl;
    return -1;
  }

  std::cout << "Serialized person to string: " << serialized_string << std::endl;
  return 0;
}

Python:

import person_pb2  # 导入由 protobuf 编译器生成的 Python 模块
import google.protobuf.text_format

def deserialize_person(serialized_string):
  person = person_pb2.Person()
  person.ParseFromString(serialized_string)
  print(f"Name: {person.name}")
  print(f"ID: {person.id}")
  print(f"Email: {person.email}")

# 假设你从C++程序获得了序列化的字符串
with open("person.data", "rb") as f:
    serialized_string = f.read()

deserialize_person(serialized_string)

编译和链接:

1. 安装 Protocol Buffers 编译器: 你需要安装 protoc 编译器。

2. 生成 C++ 和 Python 代码:

   protoc --cpp_out=. person.proto
   protoc --python_out=. person.proto

   这将生成 person.pb.h 和 person.pb.cc (C++) 以及 person_pb2.py (Python) 文件。

3. 编译 C++ 代码: 你需要链接 Protocol Buffers 库。例如，使用 g++ 编译时，可能需要添加类似以下的选项：

   g++ -I/usr/local/include -L/usr/local/lib -lprotobuf main.cpp person.pb.cc -o my_cpp_program

   • -I 选项指定 Protocol Buffers 头文件所在的目录。
   • -L 选项指定 Protocol Buffers 库文件所在的目录。
   • -lprotobuf 选项链接 Protocol Buffers 库。

解释:

• Protocol Buffers: 我们首先定义一个 .proto 文件来描述数据结构，然后使用 protoc 编译器生成 C++ 和 Python 代码。
• C++: 我们使用生成的 C++ 类来创建和序列化 Person 对象。SerializeToString() 将对象序列化为字符串，SerializeToOstream() 将对象序列化到输出流。
• Python: 我们使用生成的 Python 类来解析序列化的字符串并访问其中的数据。ParseFromString() 从字符串中解析对象。

选择合适的序列化格式:

选择哪种序列化格式取决于具体的需求：

格式	优点	缺点	适用场景
JSON	易于阅读和编写，跨语言支持广泛，调试方便。	性能相对较低，数据类型有限（不支持二进制数据），安全性较差（容易受到注入攻击）。	Web API，配置文件，简单的数据交换。
XML	可以描述复杂的数据结构，具有良好的可扩展性。	冗长，解析和序列化性能较低。	配置文件，文档存储，企业级数据交换。
Protocol Buffers	性能高，数据结构定义清晰，支持多种语言，具有良好的可扩展性。	需要定义 .proto 文件并生成代码，调试相对困难。	高性能网络通信，数据存储，服务间通信。
MessagePack	紧凑的二进制格式，性能高，易于使用。	可读性较差，调试相对困难。	高性能网络通信，数据存储。

4. 错误处理与异常传递

跨语言调用时，错误处理是一个重要的考虑因素。我们需要将C++的异常或错误码传递给Python/Java，并在目标语言中进行处理。

示例：C++ 异常传递给 Python

#include <Python.h>
#include <iostream>
#include <stdexcept>

PyObject* cpp_function() {
  try {
    // 模拟一个可能抛出异常的操作
    throw std::runtime_error("Something went wrong in C++!");
  } catch (const std::exception& e) {
    // 1. 创建一个 Python 异常对象
    PyObject* pException = PyExc_RuntimeError; // 或者其他合适的 Python 异常类型
    // 2. 设置异常信息
    PyErr_SetString(pException, e.what());
    // 3. 返回 NULL，表示发生了异常
    return nullptr;
  }
  // 如果没有发生异常，返回一个 Python 对象 (例如 Py_None)
  Py_RETURN_NONE;
}

static PyObject* py_wrapper(PyObject* self, PyObject* args) {
  return cpp_function();
}

static PyMethodDef methods[] = {
    {"cpp_function", py_wrapper, METH_NOARGS, "Call C++ function"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef module = {
    PyModuleDef_HEAD_INIT,
    "my_cpp_module",
    NULL,
    -1,
    methods
};

PyMODINIT_FUNC PyInit_my_cpp_module() {
    return PyModule_Create(&module);
}

Python:

import my_cpp_module

try:
  my_cpp_module.cpp_function()
except RuntimeError as e:
  print(f"Caught exception from C++: {e}")

解释:

• C++:
  • 在 cpp_function() 中，我们使用 try-catch 块来捕获C++异常。
  • 如果捕获到异常，我们使用 PyErr_SetString() 创建一个 Python 异常对象，并将异常信息设置为 C++ 异常的 what() 方法返回的字符串。
  • 我们返回 nullptr，表示发生了异常。
• Python:
  • 我们使用 try-except 块来捕获 Python 异常。
  • 如果 C++ 代码抛出了异常，Python 会将其转换为相应的 Python 异常类型（在本例中为 RuntimeError）。

示例：C++ 错误码传递给 Java (通过 JNI)

#include <jni.h>
#include <iostream>

extern "C" {
  JNIEXPORT jint JNICALL Java_MyJavaClass_myNativeFunction(JNIEnv* env, jobject obj);
}

JNIEXPORT jint JNICALL Java_MyJavaClass_myNativeFunction(JNIEnv* env, jobject obj) {
  int result = 0;
  try {
    // 模拟一个可能发生错误的操作
    if (true) {
      // 发生错误
      result = -1; // 返回一个错误码
      // 可选: 抛出一个 Java 异常
      jclass exceptionClass = env->FindClass("java/lang/Exception");
      env->ThrowNew(exceptionClass, "Error occurred in C++");
    } else {
      // 成功
      result = 0; // 返回 0 表示成功
    }
  } catch (...) {
    // 处理 C++ 异常
    result = -2; // 返回一个错误码
    jclass exceptionClass = env->FindClass("java/lang/Exception");
    env->ThrowNew(exceptionClass, "C++ exception occurred");
  }
  return result;
}

MyJavaClass.java:

public class MyJavaClass {
  static {
    System.loadLibrary("my_native_library");
  }

  public native int myNativeFunction();

  public static void main(String[] args) {
    MyJavaClass obj = new MyJavaClass();
    int result = obj.myNativeFunction();
    if (result != 0) {
      System.err.println("Native function returned error code: " + result);
      // 处理错误
    } else {
      System.out.println("Native function executed successfully.");
    }
  }
}

解释:

• C++:
  • 我们使用 try-catch 块来捕获 C++ 异常。
  • 我们使用整数错误码来指示函数是否成功执行。
  • 如果发生错误，我们可以选择抛出一个 Java 异常，使用 env->ThrowNew() 函数。
• Java:
  • 我们在 Java 代码中检查本地函数返回的错误码。
  • 如果错误码不为 0，表示发生了错误，我们需要进行相应的处理。

总结：选择合适的策略

跨语言调用封装是一个复杂的过程，需要仔细考虑堆栈转换、数据序列化和错误处理等问题。 通过自定义桥接库，我们可以更好地理解跨语言调用的底层原理，并提供最大的灵活性。 在实际应用中，可以根据具体的需求选择合适的序列化格式和错误处理机制，以实现高效、可靠的跨语言调用。

更多IT精英技术系列讲座，到智猿学院