Как заставить все производные классы реализовать виртуальный метод?

Используя любопытно повторяющиеся шаблоны, вы можете добиться чего-то очень похожего:

template<typename T>
class Cloneable : public T, public Dep
{
private:
    Cloneable<T>() : T() { }
public:
    static Cloneable<T>* Create() { return new Cloneable<T>(); }
    Cloneable<T>* clone() { return new Cloneable<T>(*this); }
};

Вместо наследования от Dep и создания экземпляра через new MyType используйте Cloneable<MyType>::Create. Поскольку Cloneable<MyType> является производным от MyType, вы можете использовать экземпляр так же, как и любой MyType, за исключением того, что теперь он гарантированно содержит Dep::clone.

Кроме того, ваш Master не должен принимать экземпляр типа Dep, но должен обеспечивать, чтобы он был Cloneable<T>. (Замените исходную функцию простым шаблоном функции, который обеспечивает это.) Это гарантирует, что любой Dep внутри мастера имеет правильно реализованную функцию clone.

Поскольку у Cloneable<MyType> нет открытого конструктора, его нельзя наследовать, однако ваш фактический MyType можно в дальнейшем наследовать и использовать так же, как и раньше.

C++ не предоставляет способа предотвратить наследование класса от вашего класса, и нет способа заставить конкретный класс в иерархии наследования реализовать метод. Единственное правило заключается в том, что где-то в иерархии наследования над определенным классом (не обязательно в конце) все виртуальные функции должны иметь реализацию, чтобы этот класс мог создавать экземпляры.

Например, A может наследоваться от Def и реализовать все его [чистые] виртуальные методы. Тогда, если B наследуется от A, ему не нужно ничего реализовывать. Нет никакого способа предотвратить это.

Так что ответ - нет, нет никакого способа обеспечить это.

TPTB запретил все RTTI или только dynamic_cast<>()? Если вы можете использовать RTTI, вы можете обеспечить существование метода в качестве постусловия его вызова:

#include <typeinfo>
#include <cassert>
#include <iostream>
#include <stdexcept>

class Base {
protected:
  virtual Base* do_create() = 0;
  virtual ~Base() {}
public:
  Base* create() {
    Base *that = this->do_create();
    if( typeid(*this) != typeid(*that) ) {
      throw(std::logic_error(std::string() +
                             "Type: " +
                             typeid(*this).name() +
                             " != " +
                             typeid(*that).name()));
    }
    return that;
  }
};

class Derive1 : public Base {
protected:
  Base* do_create() { return new Derive1(*this); }
};

class Derive2 : public Derive1 {};

void f(Base*p) { std::cout << typeid(*p).name() << "\n"; }
int main() {
  Derive1 d1;
  Base *pD1 = d1.create(); // will succeed with correct semantics
  Derive2 d2;
  Base *pD2 = d2.create(); // will throw exception due to missing Derive2::do_create()
}

Если вы управляете базовым классом AbstractDep, вы можете принудительно создать конкретные конечные классы с помощью шаблона класса WithCloning. Затем этот лист можно запечатать, чтобы он не мог быть унаследован. Или, точнее, экземпляры производного класса не могут быть созданы.

class AbstractDep
{
template< class Type > friend class WithCloning;
private:
    enum FooFoo {};
    virtual FooFoo toBeImplementedByLeafClass() = 0;

public:
    virtual AbstractDep* clone() const = 0;
};

template< class Type > class WithCloning;

class Sealed
{
template< class Type > friend class WithCloning;
private:
    Sealed() {}
};

template< class Type >
class WithCloning
    : public Type
    , public virtual Sealed
{
private:
    AbstractDep::FooFoo toBeImplementedByLeafClass()
    {
        return AbstractDep::FooFoo();
    }

public:
    virtual WithCloning* clone() const
    {
        return new WithCloning( *this );
    }
};

typedef WithCloning<AbstractDep>            Dep;


class AbstractDerivedDep
    : public AbstractDep
{
// AbstractDep::FooFoo toBeImplementedByLeafClass(); // !Not compile.
public:
};

typedef WithCloning<AbstractDerivedDep>     DDep;


struct Foo: Dep {};       // !Does not compile if instantiated.

int main()
{
    Dep     d;
    //Foo     f;
}

Если классы требуют большего, чем конструкция по умолчанию, то большинство из них можно решить дополнительно.

Одним из решений является пересылка пакета аргументов из конструктора WithCloning (в моем блоге есть пример реализации C++98, и C++0x поддерживает его напрямую).

Подводя итог, для создания экземпляра класс должен быть WithCloning.

Ура и чт.,

когда вы говорите, что они неизвестны, я предполагаю, что они все еще наследуют от общего базового класса/интерфейса, верно?

единственное, что, как мне кажется, можно использовать для принудительного добавления виртуального базового класса

virtual Base* clone() {
    assert( 1==0 ); //needs to be overriden
}

поэтому вы вынуждены переопределить, но это обнаруживается только во время выполнения при попытке вызвать клон для экземпляра класса, в котором отсутствует переопределение

даже если вам не разрешено использовать dynamic_cast или RTTI, вы все равно можете включить его для целей отладки локально в вашей сборке, если это поможет вам найти typeid классов-нарушителей.

похоже, вы знакомы с шаблоном клонирования, но я тихо опубликую его здесь, и мы можем забыть о нем: http://www.cplusplus.com/forum/articles/18757/