c++ standard practice: virtual interface classes vs. templates

by

You’re basically right, dynamic polymorphism (inheritance, virtuals) is generally the right choice when the type should be allowed to change at runtime (for example in plugin architectures). Static polymorphism (templates) is a better choice if the type should only change at compile-time.

The only potential downsides to templates are that 1) they generally have to be defined in the headers (which means more code gets #included), and this often leads to slower compile-times.

But design-wise, I can’t see any problems in using templates when possible.

Which complies more with standard c++
style?

Depends on what “standard C++ style” is. The C++ standard library uses a bit of everything. The STL uses templates for everything, the slightly older IOStreams library uses inheritance and virtual functions, and the library functions inherited from C uses neither, of course.

These days, templates are by far the most popular choice though, and I’d have to say that is the most “standard” approach.

More Related Contents:

  1. Templates polymorphism
  2. mixing templates with polymorphism
  3. C++ template typedef
  4. initializer_list and move semantics
  5. int vs const int& [closed]
  6. C++ template constructor
  7. static_assert fails compilation even though template function is called nowhere
  8. trailing return type using decltype with a variadic template function
  9. CRTP to avoid dynamic polymorphism
  10. Checking for NULL pointer in C/C++ [closed]
  11. How to force a static member to be initialized?
  12. Passing a variable as a template argument
  13. C++17 class template partial deduction
  14. How can I declare a member vector of the same class?
  15. C++ preprocessor: avoid code repetition of member variable list
  16. How does the standard library implement std::swap?
  17. Template specialization of a single method from a templated class
  18. Template class with template container
  19. Expansion with variadic templates [duplicate]
  20. Variadic deduction guide not taken by g++, taken by clang++ – who is correct?
  21. C++ overloaded function as template argument
  22. C++ template, linking error [duplicate]
  23. Default parameters with C++ constructors [closed]
  24. C++ Template Metaprogramming – Is it possible to output the generated code?
  25. Making a C++ class a Monitor (in the concurrent sense)
  26. Why the initializer of std::function has to be CopyConstructible?
  27. using SFINAE for template class specialisation
  28. Double dispatch/multimethods in C++
  29. What is the difference between if (NULL == pointer) vs if (pointer == NULL)?
  30. Template specialization based on inherit class

Leave a Comment