Eu me deparei com um problema ao tentar reutilizar o código de diferentes classes. Coloco aqui na esperança de que alguns de vocês possam me ajudar.

Eu tenho um conjunto de classes (B, C) derivado da mesma classe (A) que força a implementação de alguns métodos (foo, run). A classe B implementa esse método, e B e C fornecem outros 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;
    }
};

Agora, o que estou tentando fazer é herdar B e C para que eu possa ter os métodos extras (foobar, bar), mas também não precise implementar o método da classe A (foo) porque ele já está definido em 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();
    }
};

Mas, por alguma razão, o compilador me dá esse erro:

test.cpp: Na função 'int main (int, char **)': test.cpp: 68: 35: error: não é possível alocar um objeto do tipo abstrato 'D <float, double>'

A <float, double> * d = new D <float, double> (); // O que eu preciso fazer

test.cpp: 48: 11: note: porque as seguintes funções virtuais são puras em 'D <float, double>':

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

    ^

test.cpp: 9: 22: note: void A <I, O> :: foo () const [com I = float; O = dobro]

void virtual foo () const = 0; // força a implementação desta função

Este é o código que eu uso para executá-lo:

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;
}

Eu quero usar a função 'run' de um objeto da classe D de um ponteiro para um A. Como todas as funções são virtuais, espero executar a implementação de cada função definida no ponto de herança mais baixo, o que significa que 'B :: run 'será descartado. Como 'D :: run' usa funções de B e C, preciso herdar de ambas as classes.

Espero ter descrito o suficiente e não confundido ninguém. Obrigado pela ajuda!