CRTP to avoid dynamic polymorphism

by

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 functions that look like these:

template <class T> // T is deduced at compile-time
void bar(base<T> & obj) {
  obj.foo(); // will do static dispatch
}

struct not_derived_from_base { }; // notice, not derived from base

// ...
my_type my_instance;
your_type your_instance;
not_derived_from_base invalid_instance;
bar(my_instance); // will call my_instance.foo()
bar(your_instance); // will call your_instance.foo()
bar(invalid_instance); // compile error, cannot deduce correct overload

So combining the structure/interface definition and the compile-time type deduction in your functions allows you to do static dispatch instead of dynamic dispatch. This is the essence of static polymorphism.

More Related Contents:

  1. What is the curiously recurring template pattern (CRTP)?
  2. C++ static polymorphism (CRTP) and using typedefs from derived classes
  3. C++ Virtual template method
  4. How to achieve “virtual template function” in C++
  5. Practical Uses for the “Curiously Recurring Template Pattern”
  6. invalid use of incomplete type
  7. Template definitions outside class body
  8. Difference of keywords ‘typename’ and ‘class’ in templates?
  9. C++ templates that accept only certain types
  10. Function passed as template argument
  11. How to easily map c++ enums to strings
  12. templates: parent class member variables not visible in inherited class
  13. Template within template: why “`>>’ should be `> >’ within a nested template argument list”
  14. Nested templates with dependent scope
  15. Limiting range of value types in C++
  16. Parameter pack must be at the end of the parameter list… When and why?
  17. Deducing first template argument with other template parameters defaulted
  18. C++ inherit from multiple base classes with the same virtual function name
  19. C++ parameter pack, constrained to have instances of a single type?
  20. Two phase name lookup for C++ templates – Why?
  21. Template instantiation details of GCC and MS compilers
  22. How can I expand call to variadic template base classes?
  23. Template Metaprogramming – Difference Between Using Enum Hack and Static Const
  24. Pointers to virtual member functions. How does it work?
  25. Local type as template arguments in C++ [duplicate]
  26. Default values in templates with template arguments ( C++ )
  27. Obtain container type from (its) iterator type in C++ (STL)
  28. Template type deduction in C++ for Class vs Function?
  29. How does std::forward receive the correct argument?
  30. Can I get polymorphic behavior without using virtual functions?

Leave a Comment