¿Cómo evitar errores al usar CRTP?

Usando CRTP a veces escribo un código como este:

// this was written first struct Foo : Base { ... }; // this was copy-pasted from Foo some days later struct Bar : Base { ... }; 

Y es muy difícil entender qué va mal, hasta que rastreé el código en el depurador y veo que los miembros de Bar no se usan en Base .

¿Cómo revelar este error en tiempo de comstackción?

(Uso MSVC2010, entonces puedo usar algunas características de C ++ 0x y extensiones de lenguaje MSVC)

En C ++ 0x tienes una solución simple. No sé si está implementado en MSVC10 sin embargo.

 template  struct base { private: ~base() {} friend T; }; // Doesn't compile (base class destructor is private) struct foo : base { ... }; 

Puedes usar algo como esto:

 template class Base { protected: // derived classes must call this constructor Base(T *self) { } }; class Foo : public Base { public: // OK: Foo derives from Base Foo() : Base(this) { } }; class Moo : public Base { public: // error: constructor doesn't accept Moo* Moo() : Base(this) { } }; class Bar : public Base { public: // error: type 'Base' is not a direct base of 'Bar' Bar() : Base(this) { } }; 
 template struct Base { typedef T derived_t; }; struct Foo : Base { void check_base() { Base::derived_t(*this); } // OK }; struct Bar : Base { void check_base() { Base::derived_t(*this); } // error }; 

Este código se basa en la respuesta de Amnon , pero el código de comprobación no contiene el nombre de la clase derivada, por lo que puedo copiarlo y pegarlo sin cambios.

No hay forma de saber el tipo de derivación. Podrías hacer cumplir ese Foo derivado de Base , pero no puedes exigir que ninguna otra clase también derive de eso.

Puedo usar una macro

 #define SOMENAMESPACE_BASE(type, arg1, arg2) type : Base 

pero no quiero usar macros si existe una mejor solución.