Inheritance

Inheritance in Python

Py_cpp extension classes support single and multiple-inheritance in Python, just like regular Python classes. You can mix built-in Python classes with py_cpp extension classes in a derived class' tuple of bases. Whenever a py_cpp extension class is among the bases for a new class in Python, the result is an extension class:

>>> class MyPythonClass:
...     def f(): return 'MyPythonClass.f()'
...
>>> import my_extension_module
>>> class Derived(my_extension_module.MyExtensionClass, MyPythonClass):
...     '''This is an extension class'''
...     pass
...
>>> x = Derived()
>>> x.f()
'MyPythonClass.f()'
>>> x.g()
'MyExtensionClass.g()'

Reflecting C++ Inheritance Relationships

Py_cpp also allows us to represent C++ inheritance relationships so that wrapped derived classes may be passed where values, pointers, or references to a base class are expected as arguments:

#include  // for std::auto_ptr<>

struct Base
{
    virtual ~Base() {}
    virtual const char* name() const { return "Base"; }
};

struct Derived
{
    Derived() : x(-1) {}
    virtual const char* name() const { return "Derived"; }
    int x;
};

std::auto_ptr base_factory() {
    return std::auto_ptr(new Derived);
}

const char* get_name(const Base& b) {
    return b.name();
}

int get_derived_x(const Derived& d) {
    return d.x;
}
    

#include <py_cpp/class_wrapper.h>
extern "C"
#ifdef _WIN32
__declspec(dllexport)
#endif
void initmy_module()
{
    try
    {
       py::Module my_module("my_module");

       py::ClassWrapper<Base> base_class(my_module, "Base");
       base_class.def(py::Constructor<void>());

       py::ClassWrapper<Derived> derived_class(my_module, "Derived");
       derived_class.def(py::Constructor<void>());
       // This establishes the inheritance relationship between Base and Derived
       derived_class.declare_base(base_class);

       my_module.def(base_factory, "base_factory");
       my_module.def(get_name, "get_name");
       my_module.def(get_derived_x, "get_derived_x");
    }
    catch(...)
    {
       py::handle_exception();    // Deal with the exception for Python
    }
}

Then, in Python:

>>> from my_module import *
>>> base = Base()
>>> derived = Derived()
>>> get_name(base)
'Base'
>>> # objects of wrapped class Derived may be passed where Base is expected
>>> get_name(derived) 
'Derived'
>>> # objects of wrapped class Derived can be passed where Derived is 
>>> # expected but where type information has been lost.
>>> get_derived_x(base_factory()) 
-1

Inheritance Without Virtual Functions

If for some reason your base class has no virtual functions but you still want to represent the inheritance relationship between base and derived classes, pass the special symbol py::without_downcast as the 2nd parameter to declare_base:

struct Base2 {};
struct Derived2 { int f(); };

   ...
   py::ClassWrapper<Base> base2_class(my_module, "Base2");
   base2_class.def(py::Constructor<void>());

   py::ClassWrapper<Derived2> derived2_class(my_module, "Derived2");
   derived2_class.def(py::Constructor<void>());
   derived_class.declare_base(base_class, py::without_downcast);

This approach will allow Derived2 objects to be passed where Base2 is expected, but does not attempt to implicitly convert (downcast) smart-pointers to Base2 into Derived2 pointers, references, or values.

Previous: Function Overloading Next: Special Method Names Up: Top

© Copyright David Abrahams 2000. Permission to copy, use, modify, sell and distribute this document is granted provided this copyright notice appears in all copies. This document is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.

Updated: Oct 30, 2000