如何用SWIG处理Java调用C++时被修改的char*输出参数？

一、处理固定大小的输出缓冲区 #

如果可以接受固定大小（比如原代码中的512字节），可以通过自定义SWIG typemap将char*输出参数映射为Java的StringBuilder，实现类似C++的调用体验：

1. 在SWIG接口文件中添加以下typemap配置：

// 将char*输出参数映射为Java StringBuilder
%typemap(jtype) char* OUTPUT "StringBuilder"
%typemap(jstype) char* OUTPUT "StringBuilder"
%typemap(jni) char* OUTPUT "jobject"
%typemap(javain) char* OUTPUT "$javainput"

// C++端分配固定大小的缓冲区
%typemap(in) char* OUTPUT {
    $1 = new char[512];
    memset($1, 0, 512); // 初始化缓冲区
}

// 调用后将C++缓冲区内容写入Java StringBuilder
%typemap(argout) char* OUTPUT {
    jstring jstr = JCALL1(NewStringUTF, jenv, $1);
    JCALL1(AppendString, jenv, $input, jstr);
    JCALL1(DeleteLocalRef, jenv, jstr);
    delete[] $1; // 释放C++端缓冲区
}

2. 修改接口中methodA的声明，标记c为输出参数：

bool methodA(const char* a, const int b, char* OUTPUT c);

3. Java端调用方式：

int q = 5;
StringBuilder returnOutput = new StringBuilder();
String name = "someName";
classA objA = new classA();
Boolean success = objA.methodA(name, q, returnOutput);
if (success) {
    System.out.println("Return output from methodA is " + returnOutput.toString());
}

二、动态确定缓冲区大小 #

如果需要动态适配输出内容的长度，有两种可行方案：

方案1：利用C++方法返回所需长度（推荐） #

如果可以修改C++代码，让methodA支持传入nullptr时返回所需的缓冲区长度：

// 修改后的C++ methodA逻辑
bool classA::methodA(const char* a, const int b, char* c) {
    if (!c) {
        // 返回所需的字符串长度（含终止符）
        return calculateRequiredLength(a, b);
    }
    // 原有的写入逻辑
    strcpy(c, "动态生成的内容");
    return true;
}

然后在SWIG接口中添加包装函数和对应typemap：

%inline %{
#include <cstring>
struct MethodAResult {
    bool success;
    char* output;
};

MethodAResult classA_methodA_dynamic(classA* obj, const char* a, int b) {
    MethodAResult res;
    res.success = false;
    int requiredLen = obj->methodA(a, b, nullptr);
    if (requiredLen <= 0) return res;
    // 分配足够的缓冲区
    res.output = new char[requiredLen];
    memset(res.output, 0, requiredLen);
    // 调用实际方法写入内容
    res.success = obj->methodA(a, b, res.output);
    return res;
}
%}

// 自动处理结构体中的char*为Java String
%apply char* OUTPUT { char* output };
%rename(methodA) classA_methodA_dynamic;

Java端调用：

int q = 5;
String name = "someName";
classA objA = new classA();
MethodAResult result = objA.methodA(name, q);
if (result.success) {
    System.out.println("Return output from methodA is " + result.output);
}

方案2：动态分配缓冲区（无需修改C++原方法） #

如果无法修改C++代码，可以在SWIG包装中先分配一个足够大的缓冲区，调用后再截断到实际长度：

%inline %{
#include <cstring>
struct MethodAResult {
    bool success;
    char* output;
};

bool classA_methodA_wrapper(classA* obj, const char* a, int b, char** outStr) {
    // 初始分配一个较大的缓冲区（如4096字节）
    *outStr = new char[4096];
    memset(*outStr, 0, 4096);
    bool success = obj->methodA(a, b, *outStr);
    if (!success) {
        delete[] *outStr;
        *outStr = nullptr;
        return false;
    }
    // 截断到实际字符串长度
    size_t actualLen = strlen(*outStr);
    char* temp = new char[actualLen + 1];
    strcpy(temp, *outStr);
    delete[] *outStr;
    *outStr = temp;
    return success;
}

MethodAResult classA_methodA_dynamic(classA* obj, const char* a, int b) {
    MethodAResult res;
    char* out = nullptr;
    res.success = classA_methodA_wrapper(obj, a, b, &out);
    res.output = out;
    return res;
}
%}

// 自动处理结构体中的char*为Java String
%apply char* OUTPUT { char* output };
%rename(methodA) classA_methodA_dynamic;

注意事项 #

• 确保C++端的字符串是UTF-8编码，否则NewStringUTF可能会导致乱码
• 所有在SWIG包装中分配的内存必须手动释放，避免内存泄漏
• 如果原methodA写入的内容可能包含二进制数据，需要改用byte[]而非String/StringBuilder，此时需要调整typemap处理字节数组

内容的提问来源于stack exchange，提问作者Shreyak Mysore Shamprasad