example.h文件

Question

我有一个C ++数据类，它存储一个指向堆分配内存的指针;我使用SWIG生成的包装器从C＃实例化和使用它没有问题。当我尝试在包装库中调用一个想要这些数据类数组的函数时，我的问题出现了;我每次都会遇到分段错误。我尝试了两种方法，如下所示。

简而言之，我的情况是

class DataClass
{
   char* _data;
   ...
}
void printDataClassArray(DataClass *toPrint, std::size_t size)
{ ... }

函数printDataClassArray默认包装为void printDataClassArray(DataClass toPrint, int size)，我尝试了两种不同的方法来解决这个问题。我发布下面的完整代码来帮助那些试图帮助我的好人：example.h包含我想要包装的C ++库，example.i包含SWIG接口代码，consumer.cs是消耗导出的函数和类的C＃函数。

我试过研究这个，特别是我已经跟着这个帖子：Wrong values passed as parameter to C library using SWIG但我找不到答案。我不知道我是否遗漏了一些明显的东西，但我认为这应该是SWIG中的例子的一部分，因为这是一个相当常见的情况。

我尝试了两种方法，即使用CSHARP_ARRAYS和使用array_class，但没有一种方法可行。请参阅下面的SWIG代码以及下面的完整列表。

使用 _CSHARP_ARRAYS _

 CSHARP_ARRAYS(DataClass, DataClass);
 %apply DataClass INPUT[]{ DataClass *toprint }
 %inline %{
 static void PrintAllDataArray(DataClass *toprint, std::size_t size)
 {
     PrintAllData(toprint, size);
 }
 %}

使用 _array_class _

 // Methodology 2
 %array_class(DataClass, DataClassArray);
 %inline %{
   static void PrintAllVariants(DataClassArray va, std::size_t size)
   {
     PrintAllData(DataClassArray_cast(&va), size);
   }
 %}

example.h文件

#include <cstring> // for memcpy
#include <string> // for std::string
#include <sstream>
#include <iostream>
#include "assert.h"


inline char* copyString(const char* value, std::size_t size) {
  char* newstring = new char[size + 1];
  memcpy(newstring, value, size);
  newstring[size] = 0;
  std::cout << "Allocated string of " << size << " characters at " << reinterpret_cast<const void*>(newstring) << std::endl;
  return newstring;
}

struct DataEncapsulator {
    struct StringValue {
      const char* ptr;
      int size;
    } svalue;
};

inline DataEncapsulator copyData(DataEncapsulator source) {
  DataEncapsulator copy = source;
    copy.svalue.ptr = copyString(source.svalue.ptr,
      source.svalue.size);
  return copy;
}

inline void deleteString(const char* string)
{
  std::printf("Deallocating string  at %p\n", reinterpret_cast<const void*>(string));
  delete[] string;
}

class DataClass {
  DataEncapsulator impl_;
public:
  DataClass()
  {
    impl_.svalue.ptr = NULL;
    std::cout << "Empty constructor called on " << myAddress() << std::endl;
  }

  DataClass(const char* string)
  {
    std::cout << "Constructor called on " << myAddress() << std::endl;
    std::size_t len = std::strlen(string);
    impl_.svalue.ptr = copyString(string, len);
    impl_.svalue.size = len;
  }

  DataClass(const DataClass& other) {
    std::cout << "Copy constructor, copying from " << other.myAddress() << " to " << myAddress() << std::endl;
    impl_ = copyData(other.impl_);
  }

  ~DataClass()
  {
    std::cout << "Destructor called on " << myAddress() << std::endl;
    deleteString(impl_.svalue.ptr);
  }

  std::string myAddress()const
  {
    std::ostringstream strs;
    strs << reinterpret_cast<const void*>(this);
    return strs.str();
  }

  std::string toString() const
  {
    std::ostringstream strs;
    strs << "\"" << impl_.svalue.ptr << "\"  - string address: " << reinterpret_cast<const void*>(impl_.svalue.ptr);
    return strs.str();
  }

  const char* c_str() const
  {
    return impl_.svalue.ptr;
  }

  DataClass& operator=(const DataClass& other) {
    std::cout << "Assignment, copying from " << other.myAddress() <<  " to " << myAddress() << std::endl;
    deleteString(impl_.svalue.ptr);
    impl_ = copyData(other.impl_);
    return *this;
  }
};

static void PrintAllData(DataClass toprint[], std::size_t size)
{
  std::cout << "PrintAllVariants passed array of " << size << " variants at " << reinterpret_cast<const void*>(toprint) << std::endl;
  if (size > 0)
  {
    for (std::size_t i = 0; i < size; i++)
      std::cout <<  i << ": " << toprint[i].myAddress() << " - " << toprint[i].toString() << std::endl;
  }
}

example.i

%module example
%include "std_string.i"
%include "arrays_csharp.i"
%include "carrays.i"

#ifdef _WIN32
%include <windows.i>
#endif

%inline %{
  namespace std {
    typedef unsigned int size_t;
  }
%}
%ignore DataEncapsulator;
%ignore copyString;
%ignore copyData;
%ignore deleteString;

%{
#include "example.h"
%}
%rename(copy) *::operator=;
%include "example.h"


// Methodology 1
CSHARP_ARRAYS(DataClass, DataClass);
%apply DataClass INPUT[]{ DataClass *toprint }
%inline %{
static void PrintAllDataArray(DataClass *toprint, std::size_t size)
{
  PrintAllData(toprint, size);
}
%}

// Methodology 2
%array_class(DataClass, DataClassArray);
%inline %{
  static void PrintAllVariants(DataClassArray va, std::size_t size)
  {
    PrintAllData(DataClassArray_cast(&va), size);
  }
%}

consumer.cs

var a = new DataClass("first");
var b = new DataClass("second");
// Methodology 1
DataClassArray va = new DataClassArray(2);
va.setitem(0, a);
va.setitem(1, b);
example.PrintAllVariants(va, 2);


// Methodology 2
DataClass[] da = new DataClass[2];
da[0] = a;
da[1] = b;
example.PrintAllDataArray(da, 2);
Console.WriteLine();

Answer 1

经过大量调查，走极端以避免使用std::vector，这是朋友建议的一个非常简单的解决方案：更改方法2中辅助函数的签名以传递DataClassArray通过引用，所以来自：

static void PrintAllVariants(DataClassArray va, std::size_t size)

到

static void PrintAllVariants(DataClassArray &va, std::size_t size)

希望它有所帮助。

SWIG：如何将C＃中的C ++对象数组传递给C ++？

example.h文件

example.i

consumer.cs

1 个答案: