Question

我正在使用SWIG从Java访问C ++代码。

C ++中的Getters通常返回const引用：

class B
{
public:
  const A& getA() const { return a_; }
private:
  A a_;
};

生成SWIG包装器。 Java中的B::getA按预期返回引用。然而，JVM不知道此引用与class B相关联。这可能会导致参考文献被破坏：

public A createA() {
    B b = new B();
    return b.getA();
}

当垃圾收集器销毁createA并且JVM对此一无所知时，从B b返回的对象无效。

SWIG提供了解决此问题的文档：references and swig。但这意味着我需要手动添加所有这些参考。

我提出了以下解决方案，它在SWIG生成的代码中返回副本而不是const引用：

%typemap(out) const SWIGTYPE&
{
  *($&1_ltype)&$result = new $1_basetype(($1_type)*$1);
}
%typemap(javaout) const SWIGTYPE&
{
  return new $javaclassname($jnicall, true);
}

我有两个问题：

这种方法安全吗？我没忘记什么吗？
有没有更好的解决方案来解决这个问题，而不是编写太多代码？

感谢任何帮助。

Answer 1

这看起来很合理，但我不建议使用它。

如果您强制它的每个案例都成为副本，那么您将失去const引用返回的语义。这也将影响其他东西的SWIG包装（例如标准库容器）。

与本机库相比，它可能会对包装代码的性能产生负面影响。但更严重的是，它在某些情况下也从根本上改变了行为。例如，考虑以下SWIG示例：

%module test

%typemap(out) const SWIGTYPE&
{
  *($&1_ltype)&$result = new $1_basetype(($1_type)*$1);
}
%typemap(javaout) const SWIGTYPE&
{
  return new $javaclassname($jnicall, true);
}

%inline %{
struct A {
    int v;
    A() : v(0) {}
};

class B
{
public:
  B() { }
  const A& getA() const { return a_; }
  void counter() {
    a_.v++;
  }
  int test() const { return a_.v; }
private:
  A a_;
};

%}

如果我们从Java那里使用它，那么：

public class run {
    public static void main(String[] argv) {
        System.loadLibrary("test");
        A a = test(); 
        System.out.println("A.v = " + a.getV());
    }

    private static A test() {
        B b = new B();
        A result = b.getA();
        System.out.println("A.v = " + b.test() + " (test)");
        b.counter();
        System.out.println("A.v = " + result.getV());
        return result;
    }
}

结果是v总是（意外地）0：

A.v = 0 (test)
A.v = 0
A.v = 0

与相同（正确）的C ++ beahviour对比：

#include <iostream>

struct A {
    int v;
    A() : v(0) {}
};

class B
{
public:
  B() { }
  const A& getA() const { return a_; }
  void counter() {
    a_.v++;
  }
  int test() const { return a_.v; }
private:
  A a_;
};

static A test();

int main() {
    const A& a = test(); 
    std::cout << "A.v = " << a.v << "\n";
}

static A test() {
    B b;
    const A& result = b.getA();
    std::cout << "A.v = " << b.test() << " (test)" << "\n";
    b.counter();
    std::cout << "A.v = " << result.v << "\n";
    return result;
}

哪个正确返回：

A.v = 0 (test)
A.v = 1
A.v = 1

这种不自然的语义对我来说是一个阻碍。

我的建议是跳过复制构造函数计划，并使文档中的示例适用于通用：

%module test

%typemap(javabody,noblock=1) SWIGTYPE {
  private long swigCPtr;
  protected boolean swigCMemOwn;

  protected $javaclassname(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  protected $javaclassname(long cPtr, boolean cMemoryOwn, Object cParent) {
    this(cPtr, cMemoryOwn);
    swigCParent = cParent;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  private Object swigCParent;
}

%typemap(javaout) SWIGTYPE const & {
    return new $javaclassname($jnicall, $owner, this);
  }

%inline %{
struct A {
    int v;
    A() : v(0) {}
};

class B
{
public:
  B() { }
  const A& getA() const { return a_; }
  void counter() {
    a_.v++;
  }
  int test() const { return a_.v; }
private:
  A a_;
};

%}

现在，每个类自动插入和管理一个额外的Object引用，就像C ++等价物一样。

如果你想为静态和非静态方法自动完成这项工作，我们需要使用一些技巧，因为，遗憾的是，没有办法指定一个只应用于非静态方法的类型映射。我使用的技巧详细解释了on another question。通过这个技巧，我们可以修改SWIG接口来添加：

%pragma(java) moduleimports=%{
  import java.lang.reflect.Field;
%}

%pragma(java) modulecode=%{
  static Object getThisOrNull(final Object o, final Class c) {
    for (Field f: o.getClass().getDeclaredFields()) {
      if (f.getType().equals(c)) {
        try {
          return f.get(o);
        }
        catch (IllegalAccessException e) {
          // Omm nom nom...
        }
      }
    }
    return null;
  }
%}

并将javaout typemap更改为：

%typemap(javaout) SWIGTYPE const & {
    return new $javaclassname($jnicall, $owner, $module.getThisOrNull(new Object(){}, $javaclassname.class));
  }

接口的其余部分如前所述，但如果没有父级（即静态方法），此修改现在会导致swigCParent为null。

返回对成员变量的引用时的SWIG-Java内存管理

1 个答案: