SWIG 官方文档第二部分 - 机翻中文人肉修正

C++class MyClass { ... std::vector<int> numbers; public： MyClass(MyClass &&other) : numbers(std::move(other.numbers)) {} MyClass & operator=(MyClass &&other) { numbers = std::move(other.numbers); return *this; } };

C++%ignore MyClass::MyClass(MyClass &&);

C++constexpr int XXX() { return 10; } constexpr int YYY = XXX() + 100;

C++tempate class std::vector<int>; // C++ 03 显式实例化在 C++ extern template class std::vector<int>; // C++11 显式实例化抑制在 C++ %template(VectorInt) std::vector<int>; // SWIG 实例化

Plain Textexample.i:33: Warning 476: Initialization using std::initializer_list.

C++%ignore Container::Container(std::initializer_list<int>);class Container {public: Container(std::initializer_list<int>); // initializer-list constructor Container(); void push_back(const int &); ...};

C++%include <std_vector.i>class Container {public: Container(const std::vector<int> &); Container(std::initializer_list<int>); // initializer-list constructor Container(); void push_back(const int &); ...};

Python>>> c = Container( [1, 2, 3, 4] )

C++%include <std_vector.i> %extend Container { Container(const std::vector<int> &elements) { Container *c = new Container(); for (int element : elements) c->push_back(element); return c; } } %ignore Container::Container(std::initializer_list<int>); class Container {public： Container（std::initializer_list<int>）；// 初始化列表构造函数 Container(); void push_back(const int &); ... };

C++%include <std_vector.i>class Container {public: Container(const std::vector<int> &);// Container(std::initializer_list<int>); // initializer-list constructor (ignored) Container(); void push_back(const int &); ...};;

C++%typemap(in) std::initializer_list<int> { $1 = {10, 20, 30, 40, 50}; } class Container { public: Container(std::initializer_list<int>); // 初始化列表构造函数 Container(); void push_back(const int &); ... };

C++struct BasicStruct { int x; double y; }; struct AltStruct { AltStruct(int x, double y) : x_{x}, y_{y} {} int x_; double y_；}; BasicStruct var1{5, 3.2}; // 只填充结构体组件AltStruct var2{2, 4.3}; // 调用构造函数

Python>>>一个= AltStruct（10，142.15）>>> a.x_ 10 >>> a.y_ 142.15

C++int i;decltype(i) j;

C++int i; int j;decltype(i+j) k; // syntax error

C++auto val = [] { return something；}; auto sum = [](int x, int y) { return x+y; }; auto sum = [](int x, int y) -> int { return x+y; };

C++auto six = [](int x, int y) { return x+y; }(4, 2);

C++struct SomeStruct { int FuncName(int x, int y); };

C++struct SomeStruct { auto FuncName(int x, int y) -> int; }; auto SomeStruct::FuncName(int x, int y) -> int { return x + y; }

Python>>> a = SomeStruct() >>> a.FuncName(10, 5) 15

C++auto square(float a, float b) -> decltype(a);

C++class A {public: int a; int b; int c; A() : A(10) {} A(int aa) : A(aa, 20) {} A(int aa, int bb) : A(aa, bb, 30) {} A(int aa, int bb, int cc) { a=aa; b=bb; c=cc; }};

C++class BaseClass { public: BaseClass(int iValue); }; class DerivedClass: public BaseClass { public: using BaseClass::BaseClass; // 添加 DerivedClass(int) 构造函数};

C++class SomeClass { public: SomeClass() {} explicit SomeClass(int new_value) : value(new_value) {} int value = 5; };

C++struct BaseStruct { virtual void ab() const = 0; virtual void cd(); virtual void ef(); virtual ~BaseStruct();};struct DerivedStruct : BaseStruct { virtual void ab() const override; virtual void cd() final; virtual void ef() final override; virtual ~DerivedStruct() override;};

C++enum class MyEnum : unsigned int;

C++struct Color { enum class RainbowColors : unsigned int { Red, Orange, Yellow, Green, Blue, Indigo, Violet }; enum class WarmColors { Yellow, Orange, Red }; // Note normal enum enum PrimeColors { Red=100, Green, Blue };};

Pythonprint Color.RainbowColors_Red、Color.WarmColors_Red、Color.Red

JavaSystem.out.println(Color.RainbowColors.Red.swigValue() + " " + Color.WarmColors.Red.swigValue() + " " + Color.PrimeColors.Red.swigValue());

C++std::vector<std::vector<int>> myIntTable;

C++class U {public: int u;}; class V {public: int v;}; class TestClass {public: //implicit converting constructor TestClass(U const &val) { t=val.u; } // explicit constructor explicit TestClass(V const &val) { t=val.v; } int t;}; struct Testable { // explicit conversion operator explicit operator bool() const { return false; }};

C++using PFD = void (*)(double); // 新引入的语法

C++typedef void (*PFD)(double); // 旧样式

C++template< typename T1, typename T2, int N > class SomeType { public: T1 a; T2 b; }; template< typename T2 > using TypedefName = SomeType<char*, T2, 5>;

C++%template(SomeTypeBool) SomeType<char*, bool, 5>; %template() TypedefName<bool>;

C++struct point { point() {} point(int x, int y) : x_(x), y_(y) {} int x_, y_;}; #include <new> // For placement 'new' in the constructor belowunion P { int z; double w; point p; // Illegal in C++03; legal in C++11. // Due to the point member, a constructor definition is required. P() { new(&p) point(); }} p1;

C++template <typename... BaseClasses> class ClassName : public BaseClasses... { public: ClassName (BaseClasses &&... baseClasses) : BaseClasses(baseClasses)... {} }

C++%template(MyVariant1) ClassName<> // 尚不支持零参数%template(MyVariant2) ClassName<int> // ok %template(MyVariant3) ClassName<int, int> // 尚不支持太多参数

C++const int SIZE = sizeof...(ClassName<int, int>);

C++// 新的字符串文字wstring aa = L"Wide string"; const char *bb = u8"UTF-8 字符串"; const char16_t *cc = u"UTF-16 字符串"; const char32_t *dd = U"UTF-32 字符串"; // 原始字符串字面量const char *xx = ")I'm an \"ascii\" \\ string."; const char *ee = R"XXX()I'm an "ascii" \ string.)XXX"; // 与 xx 相同wstring ff = LR"XXX(I'm a "raw wide" \ string.)XXX";const char *gg = u8R"XXX(I'm a "raw UTF-8" \ string.)XXX";const char16_t *hh = uR"XXX(I'm a "raw UTF-16" \ string.)XXX";const char32_t *ii = UR"XXX(I'm a "raw UTF-32" \ string.)XXX";

C++OutputType operator "" _myRawLiteral(const char * value);

C++OutputType operator "" _mySuffixIntegral(unsigned long long);OutputType operator "" _mySuffixFloat(long double);

C++OutputType operator "" _mySuffix(const char * string_values, size_t num_chars);OutputType operator "" _mySuffix(const wchar_t * string_values, size_t num_chars);OutputType operator "" _mySuffix(const char16_t * string_values, size_t num_chars);OutputType operator "" _mySuffix(const char32_t * string_values, size_t num_chars);

Plain Textexample.i:27: Warning 503: Can't wrap 'operator "" _myRawLiteral' unless renamed to a valid identifier.

C++%rename(MyRawLiteral) operator"" _myRawLiteral(const char * value);

C++%ignore operator "" _myRawLiteral(const char * value);

C++OutputType var1 = "1234"_suffix;OutputType var2 = 1234_suffix;OutputType var3 = 3.1416_suffix;

C++struct A { static thread_local int val; }; thread_local int global_val;

C++struct NonCopyable { NonCopyable & operator=(const NonCopyable &) = delete; /* 删除 operator= */ NonCopyable(const NonCopyable &) = delete; /* 删除复制构造函数 */ NonCopyable() = default; /* 明确允许空构造函数 */ };

C++struct NoInt { void f(double i); void f(int) = delete；};

C++tempalte<typename T> struct Check { static_assert(sizeof(int) <= sizeof(T)，“not engoth”）；};

C++struct A { int member；}; const int SIZE = sizeof(A::member); // 不适用于 C++03。用 C++11 没问题

Python>>> SIZE8

C++static void noex1() noexcept;int noex2(int) noexcept(true);int noex3(int, bool) noexcept(false);

C++const int align1 = alignof(A::member);

C++struct alignas(16) S { int num; }; alignas(double) unsigned char c[sizeof(double)];

C++#define alignas(T)

C++int [[attr1]] i [[attr2, attr3]]; [[noreturn, nothrow]] void f [[noreturn]]();

C++%rename(__call__) Test::operator(); // 默认重命名用于 Python struct Test { bool operator()(int x, int y); // 函数对象}; #include <function> std::function<void (int, int)> pF = Test; // 函数模板包装器

Pythont = Test() b = t(1, 2) # 调用 C++ 函数对象

C++#include <type_traits> // 第一种操作方式。template< bool B > struct algorithm { template< class T1, class T2 > static int do_it(T1 &, T2 &) { /*...*/ return 1; } }; // 第二种操作方式。template<> struct algorithm<true> { template< class T1, class T2 > static int do_it(T1, T2) { /*...*/ return 2; } }; // 实例化 'elaborate' 会根据使用的类型自动实例化正确的操作方式。template< class T1, class T2 > int Explain(T1 A, T2 B) { // 仅当 'T1' 是整数且如果 'T2' 是浮点数时才使用第二种方式， // 否则使用第一种方式。 return algorithm< std::is_integral<T1>::value && std::is_floating_point<T2>::value >::do_it(A, B); }

C++%template(Elaborate) elaborate<int, int>; %template(Elaborate) elaborate<int, double>;

Python>>> Elaborate(0, 0) 1 >>> Elaborate(0, 0.0) 2

C++%inline %{ #include <function> typedef double(*fn_ptr)(double); %} namespace std { // 前向声明 result_of template<typename Func> struct result_of; // 添加 result_of 的部分特化 template<> struct result_of< fn_ptr(double) > { typedef double type; }; } %template() std::result_of< fn_ptr(double) >; %inline %{ double square(double x) { return (x * x); } template<class Fun, class Arg> typename std::result_of<Fun(Arg)>::type test_result_impl(Fun fun, Arg arg) { return fun(arg); } } %} %template(test_result) test_result_impl< fn_ptr, double >; %constant double (*SQUARE)(double) = square;

Python>>> test_result(SQUARE, 5.0) 25.0

C++%include "pointer.i"

C++%import "foo.i"

Plain TextSWIG Always defined when SWIG is processing a fileSWIGIMPORTED Defined when SWIG is importing a file with %importSWIG_VERSION Hexadecimal (binary-coded decimal) number containing SWIG version, such as 0x010311 (corresponding to SWIG-1.3.11). SWIGALLEGROCL Defined when using Allegro CLSWIGCFFI Defined when using CFFISWIGCHICKEN Defined when using CHICKENSWIGCLISP Defined when using CLISPSWIGCSHARP Defined when using C#SWIGGUILE Defined when using GuileSWIGJAVA Defined when using JavaSWIGJAVASCRIPT Defined when using JavascriptSWIG_JAVASCRIPT_JSC Defined when using Javascript for JavascriptCoreSWIG_JAVASCRIPT_V8 Defined when using Javascript for v8 or node.js SWIGLUA Defined when using LuaSWIGMODULA3 Defined when using Modula-3SWIGMZSCHEME Defined when using MzschemeSWIGOCAML Defined when using OcamlSWIGOCTAVE Defined when using OctaveSWIGPERL Defined when using PerlSWIGPHP Defined when using PHP5 or PHP7SWIGPHP5 Defined when using PHP5SWIGPHP7 Defined when using PHP7SWIGPIKE Defined when using PikeSWIGPYTHON Defined when using PythonSWIGR Defined when using RSWIGRUBY Defined when using RubySWIGSCILAB Defined when using ScilabSWIGSEXP Defined when using S-expressionsSWIGTCL Defined when using TclSWIGXML Defined when using XML

Plain Text__LINE__ 当前行号__FILE__ 当前文件名__STDC__ 定义为指示 ANSI C __cplusplus 使用 -c++ 选项时定义

C++#ifndef _FOO_H 1 #define _FOO_H 1 ... #endif

C++#define EXTERN extern #ifdef __STDC__ #define _ANSI(args) (args) #else #define _ANSI(args) () #endif

C++%define ARRAYHELPER(type, name) %inline %{ type *new_ ## name (int nitems) { return (type *) malloc(sizeof(type)*nitems); } void delete_ ## name(type *t) { free(t); }type name ## _get(type *t, int index) { return t[index]; } void name ## _set(type *t, int index, type val) { t[index] = val; } %} %enddef ARRAYHELPER(int, IntArray) ARRAYHELPER(double, DoubleArray)

C++#define DEBUGF(fmt, ...) fprintf(stderr, fmt, __VA_ARGS__)

C++DEBUGF("hello"); --> fprintf(stderr, "hello", );

C++#define DEBUGF(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)

C++#define DEBUGF(fmt, args...) fprintf(stdout, fmt, args)

C++%{ #ifdef NEED_BLAH int blah() { ... } #endif %}

Perl%extend Foo { void bar() { #ifdef DEBUG printf("I'm in bar\n"); #endif } }

C++%extend Foo { void bar() { %#ifdef DEBUG printf("I'm in bar\n"); %#endif }}

C++#define SWIG_macro(CAST) (CAST)$input %typemap(in) Int {$1= SWIG_macro(int);}

C++ { arg1=(int)jarg1; }

C++#define SWIG_macro(CAST) (CAST)$input %typemap(in, noblock=1) Int {$1= SWIG_macro(int);}

C++arg1=(int)jarg1;

C++#define SWIG_macro(CAST) (CAST)$input %typemap(in) Int %{$1=SWIG_macro(int);%}

C++arg1=SWIG_macro(int);

C++#error "这是一条致命错误消息" #warning "这是一条警告消息"

C++ /* 修改行为：#error 不会导致 SWIG 以错误退出 */ #pragma SWIG cpperraswarn=1 /* 正常行为：#error 确实导致 SWIG 以错误退出 */ #pragma SWIG cpperraswarn=0

C++%module example%include "cpointer.i" /* Create some functions for working with "int *" */%pointer_functions(int, intp); /* A function that uses an "int *" */void add(int x, int y, int *result);

Python>>> import example >>> c = example.new_intp() # 创建一个“int”来存储结果>>> example.add(3, 4, c) # 调用函数>>> example.intp_value(c) #取消引用7 >>> example.delete_intp(c) # 删除

C++struct name{ name()；// 创建指针对象 ~name(); // 删除指针对象 void assign(type value); // 赋值 type value(); // 获取值 type *cast(); // 将指针转换为原始类型 static name *frompointer(type *); // 从现有的 // 指针创建类包装器};

C++%module example %include "cpointer.i" /* 将类接口包裹在 "int *" */ %pointer_class(int, intp); /* 一个使用“int *”的函数 */ void add(int x, int y, int *result);

Python>>> import example >>> c = example.intp() # 创建一个“int”来存储结果>>> example.add(3, 4, c) # 调用函数>>> c.value() # 解引用7

C++%pointer_cast(int *, unsigned int *, int_to_uint);

C++void print_array(double x[10]) { int i; for (i = 0; i < 10; i++) { printf("[%d] = %g\n", i, x[i]); } }

C++%module example %include "carrays.i" %array_functions(double, doubleArray); void print_array(double x[10]);

Pythona = new_doubleArray(10) # Create an arrayfor i in range(0, 10): doubleArray_setitem(a, i, 2*i) # Set a valueprint_array(a) # Pass to Cdelete_doubleArray(a) # Destroy array

C++struct name { name(int nelements); // Create an array ~name(); // Delete array type getitem(int index); // Return item void setitem(int index, type value); // Set item type *cast(); // Cast to original type static name *frompointer(type *); // Create class wrapper from // existing pointer};

C++%module example%include "carrays.i" %array_class(double, doubleArray); void print_array(double x[10]);

Pythonimport example c = example.doubleArray(10) # Create double[10] for i in range(0, 10): c[i] = 2*i # 赋值example.print_array(c) # 传递给 C

C++type *malloc_ name (int nbytes = sizeof( type ));

C++type *calloc_ name (int nobj =1, int sz = sizeof( type ));

C++type *realloc_name（type *ptr, int nitems);

C++void free_ name ( type *ptr);

C++%constant int sizeof_ name = sizeof( type );

C++// SWIG 接口%module 示例%include "cmalloc.i" %malloc(int); %free(int); %malloc(int *, intp); %free(int *, intp); %allocators(double);

Python>>> from example import * >>> a = malloc_int() >>> a '_000efa70_p_int' >>> free_int(a) >>> b = malloc_intp() >>> b '_000efb20_p_p_int' >>> free_intp(b ) >>> c = calloc_double(50) >>> c '_000fab98_p_double' >>> c = realloc_double(100000) >>> free_double(c) >>> 打印 sizeof_double 8 >>>

C++// SWIG 接口%module example%include "carrays.i" %include "cdata.i" %array_class(int, intArray);

Python>>> a = intArray(10) >>> for i in range(0, 10): ... a[i] = i >>> b = cdata(a, 40) >>> b '\x00\ x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04 \x00\x00\x00\x05\x00\x05\x00\x00 x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\t' >>> c = intArray(10) >>> memmove(c, b) >>> print c[4] 4 >>>

C++char *cdata_name(type* ptr, int nitems)

C++char *foo(char *s);

Python% foo Hello

C++size_t parity(char *str, size_t len, size_t initial);

C++%apply (char *STRING, size_t LENGTH) { (char *str, size_t len) }; ... size_t parity(char *str, size_t len, size_t initial);

Python>>> s = "H\x00\x15eg\x09\x20">>> parity(s, 0)

C++char *foo() { char *result = (char *) malloc(...); ... return result;}

C++%newobject foo; ... char *foo();

C++void get_path(char *s) { // 潜在的缓冲区溢出---呃，哦。 sprintf(s, "%s/%s", base_directory, sub_directory); } ... // C 程序中的其他地方{ char path[1024]; ... get_path(path); ... }

C++%cstring_bounded_output(char *path, 1024); ... void get_path(char *path);

Python>>> get_path() /home/beazley/packages/Foo/Bar >>>

C++%cstring_chunk_output(char *packet, PACKETSIZE); ... void get_packet(char *packet);

Python>>> get_packet() '\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88' >>>

C++%cstring_bounded_mutable(char *ustr, 1024); ... void make_upper(char *ustr);

Python>>> make_upper("hello world") 'hello world' >>>

C++%cstring_mutable(char *ustr); ... void make_upper(char *ustr); %cstring_mutable(char *hstr, HEADER_SIZE); ... void attach_header(char *hstr);

Python>>> make_upper("hello world") 'HELLO WORLD' >>> attach_header("Hello world") 'header: Hello world' >>>

C++%cstring_output_maxsize(char *path, int maxpath); ... void get_path(char *path, int maxpath);

Python>>> get_path(1024) '/home/beazley/Packages/Foo/Bar' >>>

C++%cstring_output_withsize(char *data, int *maxdata); ... void get_data(char *data, int *maxdata);

Python>>> get_data(1024) 'x627388912' >>> get_data(1024) 'xyzzy' >>>

C++void foo(char **s) { *s = (char *) malloc(64); sprintf(*s, "Hello world\n"); }

C++%cstring_output_allocate(char **s, free(*$1)); ... void foo(char **s);

Python>>> foo() 'Hello world\n' >>>

C++void foo(char **s, int *sz) { *s = (char *) malloc(64); *sz = 64; // 写入一些二进制数据 ... }

C++%cstring_output_allocate_size(char **s, int *slen, free(*$1)); ... void foo(char **s, int *slen);

Python>>> foo() '\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88' >>>

C++char *get_data(int *len);

C++void my_get_data(char **result, int *len) { *result = get_data(len); }

C++类

C++ 库文件

SWIG 接口库文件

C++%module example%include "std_string.i" std::string foo(); void bar(const std::string &x);

Pythonx = foo(); # 返回一个字符串对象bar("Hello World"); # 将字符串作为 std::string 传递

C++%module example%include "std_string.i" %apply const std::string& {std::string* foo}; struct my_struct { std::string foo; };

Pythonx = my_struct(); x.foo="Hello World"; # 用字符串赋值print x.foo; # 打印为字符串

C++%module example%include "std_string.i" using namespace std; typedef std::string String；... void foo(string s, const String &t); // std_string 类型映射仍然适用

C++%module example%include "std_vector.i" namespace std { %template(vectori) vector<int>; %template(vectord) vector<double>; };

C++/* 文件：example.h */ #include <vector> #include <algorithm> #include <functional> #include <numeric> double average(std::vector<int> v) { return std::accumulate(v.begin(), v.end(), 0.0)/v.size(); } std::vector<double> half(const std::vector<double>& v) { std::vector<double> w(v); for (unsigned int i=0; i<w.size(); i++) w[i] /= 2.0; return w; } void halve_in_place(std::vector<double>& v) { std::transform(v.begin(), v.end(), v.begin(), std::bind2nd(std::divides<double> (), 2.0)); }

C++%module example %{ #include "example.h" %} %include "std_vector.i" // 实例化 example 用到的模板namespace std { %template(IntVector) vector<int>; %template(DoubleVector) vector<double>; } // 包含具有上述原型的头文件%include "example.h"

Shell>>> from example import *>>> iv = IntVector(4) # Create an vector<int>>>> for i in range(0, 4):... iv[i] = i>>> average(iv) # Call method1.5>>> average([0, 1, 2, 3]) # Call with list1.5>>> half([1, 2, 3]) # Half a list(0.5, 1.0, 1.5)>>> halve_in_place([1, 2, 3]) # OopsTraceback (most recent call last): File "<stdin>", line 1, in ?TypeError: Type error. Expected _p_std__vectorTdouble_t>>> dv = DoubleVector(4)>>> for i in range(0, 4):... dv[i] = i>>> halve_in_place(dv) # Ok>>> for i in dv:... print i...0.00.51.01.5>>> dv[20] = 4.5Traceback (most recent call last): File "<stdin>", line 1, in ? File "example.py", line 81, in __setitem__ def __setitem__(*args): return apply(examplec.DoubleVector___setitem__, args)IndexError: vector index out of range>>>

C++include "std_vector.i" namespace std { %template(IntVector) vector<int>;} using namespace std;typedef std::vector Vector; void foo(vector<int> *x, const Vector &x);

C++%module exapmle%include "std_vector.i" %typemap(throws) std::out_of_range { // 自定义异常处理程序} %template(VectInt) std::vector<int>;

C++%include "exception.i" %exception { try { $action } catch (const std::exception& e) { SWIG_exception(SWIG_RuntimeError, e.what()); } }

C++%include <std_shared_ptr.i>

C++#define SWIG_SHARED_PTR_SUBNAMESPACE tr1 %include <std_shared_ptr.i>

C++%include <boost_shared_ptr.i>

C++%module example%include <boost_shared_ptr.i> %shared_ptr(IntValue) %inline %{ #include <boost/shared_ptr.hpp> struct IntValue { int value; IntValue(int v) : value(v) {} }; static int extractValue(const IntValue &t) { return t.value; } static int extractValueSmart(boost::shared_ptr<IntValue> t) { return t->value; } %}

JavaIntValue iv = new IntValue(1234); int val1 = example.extractValue(iv); int val2 = example.extractValueSmart(iv); System.out.println(val1 + " " + val2);

C++%shared_ptr(DerivedIntValue) %inline %{ struct DerivedIntValue : IntValue { DerivedIntValue(int value) : IntValue(value) {} ... }; %}

C++DerivedIntValue div = new DerivedIntValue(5678); int val3 = example.extractValue(div); int val4 = example.extractValueSmart(div);

C++%include "boost_shared_ptr.i" %shared_ptr(Parent); %inline %{ #include <boost/shared_ptr.hpp> struct GrandParent { virtual ~GrandParent() {} }; struct Parent : GrandParent { virtual ~Parent() {} }; struct Child : Parent { virtual ~Child() {} }; %}

Plain Textexample.i:12: Warning 520: Base class 'GrandParent' of 'Parent' is not similarly marked as a smart pointer.example.i:16: Warning 520: Derived class 'Child' of 'Parent' is not similarly marked as a smart pointer.

C++%include "boost_shared_ptr.i" %shared_ptr(GrandParent); %shared_ptr(Parent); %shared_ptr(Child); ... as before ...

C++%include <std_auto_ptr.i> %auto_ptr(Klass) %inline %{ class Klass { public: // 创建这个类的对象的工厂函数： static std::auto_ptr<Klass> Create(int value) { return std::auto_ptr <Klass>(新的Klass(value)); } int getValue() const { return m_value; } private: DerivedIntValue(int value) : m_value(value) {} int m_value; }; %}

C#Klass k = Klass.Create(17); int value = k.getValue();

C++SWIG_MemoryError SWIG_IOError SWIG_RuntimeError SWIG_IndexError SWIG_TypeError SWIG_DivisionByZero SWIG_OverflowError SWIG_SyntaxError SWIG_ValueError SWIG_SystemError

C++%include "exception.i" %exception std::vector::getitem { try { $action } catch (std::out_of_range & e) { SWIG_exception(SWIG_IndexError, const_cast<char*>(e.what())); } }

C++void add(double a, double b, double *result) { *result = a + b; }

C++// 使用类型映射的简单示例%module example %include "typemaps.i" %apply double *OUTPUT { double *result }; %inline %{ extern void add(double a, double b, double *result); %}

Python>>> a = add(3, 4) >>> print a7 >>>

C++%module example%include "typemaps.i" %apply double *OUTPUT { double *result }; %inline %{ extern void add(double a, double b, double *result); extern void sub(double a, double b, double *result); extern void mul(double a, double b, double *result); extern void div(double a, double b, double *result); %} ...

C++%include "typemaps.i" %apply int *OUTPUT { int *width, int *height }; // 返回一对 (width, height) void getwinsize(int winid, int *width, int *height);

Lua>>> w, h = genwinsize(wid) >>> print w 400 >>> print h 300 >>>

C++// 使用类型映射的简单示例%module example %include "typemaps.i" %{ extern void add(double a, double b, double *OUTPUT); %} extern void add(double a, double b, double *OUTPUT);

C++%clear double *result; // 删除 double *result 的所有类型映射

C++int *INPUT short *INPUT long *INPUT unsigned int *INPUT unsigned short *INPUT unsigned long *INPUT double *INPUT float *INPUT

C++double add(double *a, double *b) { return *a+*b; }

C++%module example%include "typemaps.i" ... %{ extern double add(double *, double *); %} extern double add(double *INPUT, double *INPUT);

Pythonresult = add(3, 4)

C++int *OUTPUT short *OUTPUT long *OUTPUT unsigned int *OUTPUT unsigned short *OUTPUT unsigned long *OUTPUT double *OUTPUT float *OUTPUT

C++void add(double a, double b, double *c) { *c = a+b; }

C++%module example%include "typemaps.i" ... %inline %{ extern void add(double a, double b, double *OUTPUT); %}

C++extern int foo(double a, double b, double *OUTPUT);

Luairesult, dresult = foo(3.5, 2)

C++int *INOUT short *INOUT long *INOUT unsigned int *INOUT unsigned short *INOUT unsigned long *INOUT double *INOUT float *INOUT

C++void negate(double *x) { *x = -(*x); }

C++%module example%include "typemaps.i" ... %{ extern void negate(double *); %} extern void negate(double *INOUT);

Pythona = negate(3); # a = -3 调用后

C++// 使 double *result 成为输出值%apply double *OUTPUT { double *result }; // 使 Int32 *in 成为输入值%apply int *INPUT { Int32 *in }; // 使 long *x inout %apply long *INOUT {long *x};

C++%clear double *result; %clear Int32 *in, long *x;

C++// 带有约束的接口文件%module example %include "constraints.i" double exp(double x); double log(double POSITIVE); // 只允许正值double sqrt(double NONNEGATIVE); // 非负值只有double inv(double NONZERO); // 非零值void free(void *NONNULL); // 仅非空指针

Plain TextPOSITIVE Any number > 0 (not zero)NEGATIVE Any number < 0 (not zero)NONNEGATIVE Any number >= 0NONPOSITIVE Any number <= 0NONZERO Nonzero numberNONNULL Non-NULL pointer (pointers only).

C++// 对 Real 变量应用约束%apply Number POSITIVE { Real in }; // 对指针类型应用约束%apply Pointer NONNULL { Vector * };

C++%clear Real in；%clear Vector *;