inheritance and cxx

[John Hunter]

I am using pycxx 5.2.2 to implement some extension code and have a
problem relating to inheritance. I have a pure virtual base class and
two concrete derived classes. In the code below, everthing works fine
in that the derived classes can use the base method get, but if I try
and add a method only available to Derived2, eg, get2, I get a
compiler error on the call to

add_varargs_met hod("get2",&Der ived2::get2, "get2()\n") ;

in Derived::init_t ype.

inheritance.cxx :73: error: no matching function for call to `
Py::PythonExten sion<Base>::add _varargs_method (const char[5], Py::Object
(Derived2::*)(c onst Py::Tuple&), const char[8])'
/usr/local/include/python2.3/CXX/Extensions.hxx: 574: error: candidates are:
static void Py::PythonExten sion<T>::add_va rargs_method(co nst char*,
Py::Object (T::*)(const Py::Tuple&), const char*) [with T = Base]
inheritance.cxx : In function `void initinheritance ()':
inheritance.cxx :124: warning: unused variable `inheritance_mo dule*inheritanc e'
error: command 'gcc' failed with exit status 1

How should I structure the code so that I can have inherited base
methods but also allow derived classes to have their own methods?

If I try defining Derived2 as

class Derived1: public Py::PythonExten sion<Derived1>, public Base

so that it gets it's own add_varargs_met hod I get into trouble because
both of the base classes share many functions so I get multiple
inheritance errors.

Complete example follows...
#include <iostream>
#include <cmath>
#include <utility>
#include "CXX/Extensions.hxx"

class Base : public Py::PythonExten sion<Base> {
public:
virtual Py::Object get(const Py::Tuple &args)=0;

static void init_type(void) ;

};

// a mutable float
class Derived1: public Base {
public:
Derived1(double val) : _val(val) {}
static void init_type(void) ;

Py::Object get(const Py::Tuple & args) {
return Py::Float(_val );
}

private:
double _val;
};
// binary operations on lazy values
class Derived2: public Base {
public:
Derived2(Base* b) : _b(b) {}

static void init_type(void) ;
Py::Object get(const Py::Tuple & args) {
return _b->get(args);
}

Py::Object get2(const Py::Tuple & args) {
return _b->get(args);
}
private:
Base* _b;
};
void
Base::init_type ()
{
behaviors().nam e("Base");
behaviors().doc ("My base class");
add_varargs_met hod("get", &Base::get, "get()\n");
}

void
Derived1::init_ type()
{
behaviors().nam e("Derived1") ;
behaviors().doc ("Derived 1");
}

void
Derived2::init_ type()
{
behaviors().nam e("Derived2") ;
behaviors().doc ("Derived 2");
add_varargs_met hod("get2", &Derived2::get2 , "get2()\n") ;
}

// the extension module
class inheritance_mod ule : public Py::ExtensionMo dule<inheritanc e_module>

{
public:
inheritance_mod ule()
: Py::ExtensionMo dule<inheritanc e_module>( "inheritanc e" )
{
Base::init_type ();
Derived1::init_ type();
Derived2::init_ type();

add_varargs_met hod("Derived1", &inheritance_mo dule::new_deriv ed1,
"Derived1(x )");
add_varargs_met hod("Derived2", &inheritance_mo dule::new_deriv ed2,
"Derived2(b )");
initialize( "The inheritance module" );
}

virtual ~inheritance_mo dule() {}

private:

Py::Object inheritance_mod ule::new_derive d1 (const Py::Tuple &args)
{
args.verify_len gth(1);
double val = Py::Float(args[0]);
return Py::Object( new Derived1(val) );
}
Py::Object inheritance_mod ule::new_derive d2 (const Py::Tuple &args)
{
args.verify_len gth(1);
if (!Base::check(a rgs[0]))
throw Py::TypeError(" Derived2(b) expecting a base instance");

Base* b = static_cast<Bas e*>(args[0].ptr());
return Py::Object( new Derived2(b) );
}
};

extern "C"
DL_EXPORT(void)
initinheritance (void)
{
static inheritance_mod ule* inheritance = new inheritance_mod ule;

};