crtp

I'm getting compilation errors when trying to call the base class constructor in derived initialization list when using a template template parameter with CRTP. Problem can be replicated with this snippet of code: template <template<class> class Derived, class T> struct base { }; template <class T> struct derived : public base<derived, T> { derived() : base<derived, T>() { } }; The offending error messsage: bug.cpp:10:16: error: template argument for template template parameter must be a class template or type alias template : base<derived, T>() ^ bug.cpp:10:11: error: expected class member or

Using CRTP sometimes I write a code like this: // this was written first struct Foo : Base<Foo, ...> { ... }; // this was copy-pasted from Foo some days later struct Bar : Base<Foo, ...> { ... }; And it's very difficult to understand what goes wrong, until I trace code in debugger and see that Bar's members aren't used in Base . How to reveal this error at compile time? (I use MSVC2010, so I can use some C++0x features and MSVC language extensions) In C++0x you have a simple solution. I don't know whether it is implemented in MSVC10 however. template <typename T> struct base { private: ~base()

I'm trying to use a typedef from a subclass in my project, I've isolated my problem in the example below. Does anyone know where I'm going wrong? template<typename Subclass> class A { public: //Why doesn't it like this? void action(typename Subclass::mytype var) { (static_cast<Subclass*>(this))->do_action(var); } }; class B : public A<B> { public: typedef int mytype; B() {} void do_action(mytype var) { // Do stuff } }; int main(int argc, char** argv) { B myInstance; return 0; } This is the output I get: sean@SEAN-PC:~/Documents/LucadeStudios/experiments$ g++ -o test test.cpp test.cpp: In

How can I use CRTP in C++ to avoid the overhead of virtual member functions? There are two ways. The first one is by specifying the interface statically for the structure of types: template <class Derived> struct base { void foo() { static_cast<Derived *>(this)->foo(); }; }; struct my_type : base<my_type> { void foo(); // required to compile. }; struct your_type : base<your_type> { void foo(); // required to compile. }; The second one is by avoiding the use of the reference-to-base or pointer-to-base idiom and do the wiring at compile-time. Using the above definition, you can have template