Esta pregunta ya tiene una respuesta aquí:

Necesito envolver una biblioteca de C ++ con SWIG para usarla con Java.

Ya tengo algunos métodos funcionando pero me he encontrado con una situación que no sé cómo resolverla.

Tengo un par de métodos como este:

void method1(std::string & name, std::string & result);

bool method2(std::string & name, std::string & alias, std::string & resurnValue, std::string & returnType);

Nota: En realidad, estos son métodos de miembros de una clase llamada MyClass.

Podría cambiar el primer método para devolver unstd::string en vez de servoid, y eso debería funcionar; pero no tengo idea de cómo manejar el segundo método donde los dos últimos parámetros son parámetros de salida. He visto un par de preguntas arbitrando achar * params de salida (Pasando múltiples parámetros y asignando cadenas en C usando Swig / Python), pero en mi caso debería ser unstd::string y la Documentación de SWIG no menciona esta situación.introduzca la descripción del enlace aquí. También es probable que encuentre más métodos que devuelven 3 o más parámetros de salida, probablemente con diferentes tipos.

Finalmente, tengo un poco de control sobre la interfaz, también estoy desarrollando una clase que actúa como un punto de entrada a la biblioteca, pero solo pasa a la implementación real.

Por ejemplo, con esto he logrado cambiar un método comomethod3(std::string & s) amethod3(const std::string & s), así que podría usarlo desde Java con un normalString.

Por lo tanto, es posible modificar un poco las firmas de los métodos, pero si un método nativo devuelve n parámetros de salida, debería devolverlos todos (no puedo crear nuevos métodos para devolver cada uno).

Actualizar: He estado buscando la solución dada por Flexo y funciona muy bien, sin embargo, estoy considerando hacer una clase para ajustar std :: string y usarla para interactuar con las cadenas devueltas, es un enfoque muy similar a la segunda solución de Flexo, pero usando este StringWrapper en lugar de usar una matriz de cadenas Java, básicamente se ve así:

/*
* The MyClass.i file
*/
%module example

%include "std_string.i"

%{
    class StringPtr{

    private:
        stdString str;

    public:
        StringPtr(){

    }

        StringPtr(const stdString & str){
        this->str = stdString(str);
        }

    stdString & getStrRef(){
        return (this->str);
        }

        stdString getStrVal(){
        return stdString(this->str);
        }

        ~StringPtr(){

        }
    };


%}

/////////////////// Export StringPtr to Java

class StringPtr{

    public:
        StringPtr();

    StringPtr(const stdString & str);

    stdString getStrVal();

    ~StringPtr();

};

// I think this is nor necessary
%rename ("$ignore", fullname=1) "StringPtr::getStrRef";

%extend MyClass {

    void method1(cons std::string & name, StringPtr & result){
        $self->method1(name, result.getStrRef());
    }

    bool method2(cons std::string & name, cons std::string & alias, StringPtr & returnValue, StringPtr & returnType){
        $self->method2(name, alias, returnValue.getStrRef(), returnType.getStrRef());
    }

};

%rename ("$ignore", fullname=1) "MyClass::method1";
%rename ("$ignore", fullname=1) "MyClass::method2";

%include "MyClass.h"

Así que me pregunto, desde el punto de vista del rendimiento, qué mejor es la solución de estructuras (por Flexo), la matriz de cadenas de Flexo o este puntero (como una estructura con un solo miembro).