Bryan,
my problems happen as soon as I need to use wrappers. I really need
the class that I extend in python to implement some pure virtual
function in the C++ class. I extended your code and refined what is
going wrong. I tried several Variants with different errors, I used
#defines to show you all 4 versions, next to each Variant I put a C++
comment of what is going wrong.
So here it is:
------------ foo.cpp ------------
#include <boost/python.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <iostream>
using namespace boost::python;
class A
: public boost::enable_shared_from_this<A> {
static int counter;
public:
int id;
A() {
id = counter++;
std::cout << "Constructing A[" << id << "]" << std::endl;
}
~A() {
std::cout << "Destructing A[" << id << "]" << std::endl;
}
boost::shared_ptr<A> ptr() {
return shared_from_this();
}
#define VARIANT0
#ifdef VARIANT0
// this variant works nicely with VARIANT1 below (compiles and
// no error for `aa = a.ptr()`), but it produces wrong results,
// i.e. `77` is returned for `aa.foo()` although it should have
// been `33`.
virtual int foo() {
return 77;
}
#else
virtual int foo() = 0;
#endif
};
struct AWrapper : public A, public boost::python::wrapper<A> {
virtual int foo() {
if( override f = this->get_override("foo") ) {
return f();
} else {
return 42;
}
}
};
int A::counter = 0;
using namespace boost::python;
BOOST_PYTHON_MODULE(foo) {
#define VARIANT1
//#define VARIANT2
//#define VARIANT3
#ifdef VARIANT1
// The following line doesn't compites it gives the error:
// error: cannot allocate an object of abstract type ‘A’
class_<AWrapper, boost::shared_ptr<A>, boost::noncopyable >("A", init<>())
#endif
#ifdef VARIANT2
// the following compiles, but produces an error in python, when executing
// aa = a.ptr();
// RuntimeError: tr1::bad_weak_ptr
class_<AWrapper, boost::noncopyable >("A", init<>())
#endif
#ifdef VARIANT3
// the following compiles, but produces an error in python, when executing
// aa = a.ptr();
// TypeError: No to_python (by-value) converter found for C++ type:
boost::shared_ptr<A>
class_<AWrapper, boost::shared_ptr<AWrapper>, boost::noncopyable
>("A", init<>())
#endif
.def("ptr", &A::ptr)
.def("foo", &A::foo)
;
}
-----------------------------------
------------ foo.py ------------
import foo
class ExtendedA(foo.A):
def foo(self):
return 33;
a0 = foo.A()
a = ExtendedA()
aa = a.ptr();
print a.foo()
del a
print aa.foo()
-----------------------------------
Do you have any suggestion how to get this working?
-Holger
On Thu, Apr 26, 2012 at 18:43, Bryan Catanzaro <bcatanz...@acm.org> wrote:
> Holger Brandsmeier <brandsmeier <at> gmx.de> writes:
>
>>
>> Dear list,
>>
>> how is it possible to have a class in C++ that can be extended from
>> python and that stores a weak_ptr to itself?
>
>
> Have you tried using boost::enable_shared_from_this? The following example
> code
> seems to do what you want.
_______________________________________________
Cplusplus-sig mailing list
Cplusplus-sig@python.org
http://mail.python.org/mailman/listinfo/cplusplus-sig
