Me encontré con un problema al intentar reutilizar el código de diferentes clases. Lo publico aquí con la esperanza de que algunos de ustedes puedan ayudarme.

Tengo un conjunto de clases (B, C) derivadas de la misma clase (A) que obliga a la implementación de algunos métodos (foo, run). La clase B implementa este método, y tanto B como C proporcionan otros métodos:

#include<iostream>

template<class I, class O>
class A {
public:
    A() {}
    virtual ~A() {}

    virtual void foo() const = 0;     // force implementation of this function
    virtual void run() const = 0;     // force implementation of this function
};

template<class I, class O>
class B : public A<I,O> {
public:
    B() {}
    virtual ~B() {}

    virtual void foo() const {        // implementation for the Base class
        std::cout << "B's implementation of foo" << std::endl;
    }

    virtual void run() const {        // implementation for the Base class
        std::cout << "B's implementation of run" << std::endl;
    }

    virtual void foobar() const {     // some other function provided by this class
        std::cout << "B's implementation of foobar" << std::endl;
    }
};

template<class I, class O, class M>
class C : public A<I,O> {
public:
    C() {}
    virtual ~C() {}

    virtual void bar(M m) const {     // some other function provided by this class
        std::cout << "C's implementation of bar with: " << m << std::endl;
    }
};

Ahora, lo que intento hacer es heredar de B y C para poder tener los métodos adicionales (foobar, bar), pero tampoco tener que implementar el método de la clase A (foo) porque ya está definido en B :

template<class I, class O>
class D : public B<I,O>, public C<I,O,int> {
public:
    D() {}

    void run() const {
        this->bar(123);
        this->foo();
        this->foobar();
    }
};

Pero por alguna razón, el compilador me da este error:

test.cpp: En la función 'int main (int, char **)': test.cpp: 68: 35: error: no se puede asignar un objeto de tipo abstracto 'D <float, double>'

A <float, double> * d = new D <float, double> (); // lo que necesito hacer

test.cpp: 48: 11: nota: porque las siguientes funciones virtuales son puras dentro de 'D <float, double>':

clase D: público B <I, O>, público C <I, O, int> {

    ^

test.cpp: 9: 22: nota: vacío A <I, O> :: foo () const [con I = float; O = doble]

virtual voo foo () const = 0; // forzar la implementación de esta función

Este es el código que uso para ejecutarlo:

int main(int argc, char **argv)
{

    A<float, double> *b = new B<float, double>();
    b->foo();                                            // prints "B's implementation of foo"
    b->run();                                            // prints "B's implementation of run"

    //A<float, double> *c = new C<float, double, int>(); // obviously fails because C does not implement any of A's functions

    //A<float, double> *d = new D<float, double>;        // line 68: what I need to do
    //d->run();                                          // ***throws the abstract class error

    return 0;
}

Quiero usar la función 'ejecutar' de un objeto de clase D desde un puntero a un A. Como todas las funciones son virtuales, espero ejecutar la implementación de cada función definida en el punto de herencia más bajo, lo que significa que 'B :: ejecutar 'será descartado. Como 'D :: run' usa funciones de B y C, necesito heredar de ambas clases.

Espero haberlo descrito lo suficiente y no haber confundido a nadie. ¡Gracias por la ayuda!