Wie kann eine Richtlinienklasse eine virtuelle Funktion implementieren?

Question

Ich versuche, eine von der Richtlinie basierende Klasse zu entwerfen, in der eine bestimmte Schnittstelle von der Richtlinie selbst implementiert wird. Daher stammt die Klasse aus der Richtlinie, die selbst eine Vorlage ist (ich habe diese Art von Denken aus Alexandrescus Buch erhalten):

#include <iostream>
#include <vector>

class TestInterface {
public:
  virtual void test() = 0;
};

class TestImpl1 {
public:
  void test() {std::cerr << "Impl1" << std::endl;}
};

template<class TestPolicy>
class Foo : public TestInterface, TestPolicy {

};

Dann in der main() Funktion, rufe ich auf test() Auf (möglicherweise) verschiedenen Objekten, die alle dieselbe Schnittstelle implementieren:

int main() {
  std::vector<TestInterface*> foos;
  foos.push_back(new Foo<TestImpl1>());
  foos[0]->test();
  delete foos[0];
  return 0;
}

Es kompiliert jedoch nicht, weil

the following virtual functions are pure within ‘Foo<TestImpl1>’:
  virtual void TestInterface::test()

ich dachte TestInterface::test() wird implementiert, weil wir abgeleitet werden TestImpl1?

Answer 1

Um dies zu bearbeiten, muss die Richtlinienklasse aus der Schnittstellenklasse erben:

class TestInterface {
public:
  virtual void test() = 0;
};

template< class Interface >
class TestImpl1 : public Interface {
public:
  void test() {std::cerr << "Impl1" << std::endl;}
};

template<class TestPolicy>
class Foo : public TestPolicy<TestInterface> {
  // ...
};

Answer 2

Sie können auch einen Boost :: MPL -Ansatz ausprobieren:

Halten Sie Ihr Testinterface und Ihr Testimpl so, wie sie sind:

#include <boost/mpl/inherit.hpp>

using namespace  boost::mpl;

template <class TestPolicy>
class Foo: public inherit2< TestPolicy, inherit2< TestInterface , empty_base >::type >::type
{
...
}

sollte arbeiten