SWIG_SHARED_PTR宏和模板类 [英] SWIG_SHARED_PTR macro with templated class

查看:119
本文介绍了SWIG_SHARED_PTR宏和模板类的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着小编来一起学习吧!

问题描述

我使用SWIG与boost共享指针来创建python扩展。我当前的问题是SWIG_SHARED_PTR宏似乎工作不同于模板类。我将给出两个例子,一个没有模板(示例),一个有模板(example2)。

I'm using SWIG with boost shared pointers to create python extensions. My current issue is that the SWIG_SHARED_PTR macro seems to work differently with templated classes. I'll give two examples, one without templates (example), and one with templates (example2).

首先我将包含代码,

基本问题是没有模板的共享指针出现在python中

The basic problem is that without templates the shared pointers appear in python as

< example.Derived;代理< Swig在0xb772c4b8处的derived_sptr *类型的对象> >

,而当包装类是实例化模板时,显示为

whereas when the wrapped class is an instantiated template the appear as

< Swig对象类型'derived_int_sptr *'在0xb787e4b8>

没有模板(工作正常)

example.h

#include <boost/shared_ptr.hpp>                                                                                                

#ifndef EXAMPLE_H                                                                                                              
#define EXAMPLE_H                                                                                                              

class Base {                                                                                                                   
 public:                                                                                                                       
  Base(int number1);                                                                                                           
  int get_number1();                                                                                                           
  virtual int get_number2() = 0;                                                                                               
 protected:                                                                                                                    
  int number1;                                                                                                                 
};                                                                                                                             

class Derived : public Base {                                                                                                  
 public:                                                                                                                       
  Derived(int number1, int number2);                                                                                           
  int get_number2();                                                                                                           
 private:                                                                                                                      
  int number2;                                                                                                                 
};                                                                                                                             

typedef boost::shared_ptr<Base> base_sptr;                                                                                     
typedef boost::shared_ptr<Derived> derived_sptr;                                                                               

derived_sptr make_derived(int number1, int number2);                                                                           

int get_number1(base_sptr b);                                                                                                  

#endif

example.cc

#include "example.h"                                                                                                       

Base::Base(int number1) :                                                                                                  
  number1(number1)                                                                                                         
{}                                                                                                                         

int Base::get_number1() {                                                                                                  
  return number1;                                                                                                          
}                                                                                                                          

Derived::Derived(int number1, int number2) :                                                                               
  Base(number1),                                                                                                           
  number2(number2)                                                                                                         
{}                                                                                                                         

int Derived::get_number2() {                                                                                               
  return number2;                                                                                                          
}                                                                                                                          

derived_sptr make_derived(int number1, int number2) {                                                                      
  return derived_sptr(new Derived(number1, number2));                                                                      
}                                                                                                                          

int get_number1(base_sptr b) {                                                                                             
  return b->get_number1();                                                                                                 
}

example.i
$ b

example.i

%module example                                                                                                            
%{                                                                                                                         
  #include "example.h"                                                                                                     
%}                                                                                                                         

%include boost_shared_ptr.i                                                                                                

SWIG_SHARED_PTR(base_sptr, Base)                                                                                           
SWIG_SHARED_PTR_DERIVED(derived_sptr, Base, Derived)                                                                       

%include example.h                                                                                                         

使用范本(无效)

example2.h

example2.cc

example2.cc

example2.i

example2.i
$ b

%module example2 %{ #include "example2.h" %} %include boost_shared_ptr.i SWIG_SHARED_PTR(base_int_sptr, base_int) SWIG_SHARED_PTR_DERIVED(derived_int_sptr, base_int, derived_int) %include example.h %template(base_int) Base<int>; %template(derived_int) Derived<int>;

Example of Difference:

差异示例:



推荐答案

在example2.i的行

SWIG_SHARED_PTR(base_int_sptr, base_int) SWIG_SHARED_PTR_DERIVED(derived_int_sptr, base_int, derived_int)

should be replaced by

应替换为

这篇关于SWIG_SHARED_PTR宏和模板类的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!

查看全文
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆