My journey through programming at compile time began in the last posts with template metaprogramming. Today, I jumped from C++98 to C++11. This is a jump to the type-traits library which is template metaprogramming in a standardized way.
Today, I will continue my introduction to programming at compile time. The last post started with template metaprogramming. Here is where I pick up today and finish.
Yes, you read it correctly. Today, I write about template metaprogramming, programming with types and not values.
In my concurrency class, I use more than 60 programs. Most of the programs consist of a single source file. I’m quite curious if the static code analysis tool CppDepend can find any issues in my sources. Let me try it out.
Variadic templates are a typical feature of C++: from the user’s perspective, they are easy to use, but from the implementor’s perspective, they look pretty scary. Today’s post is mainly about the implementor’s perspective.
Due to the C++ core guidelines, “Templates are the backbone of C++’s support for generic programming and class hierarchies the backbone of its support for object-oriented programming. The two language mechanisms can be combined effectively, but a few design pitfalls must be avoided.” Let me see what this means.
My post for today is just loosely coupled to the rules of the C++ core guidelines because they do provide not much content. Inspired by the guidelines, today’s post concerns a generic isSmaller function.
Template definitions deal with guidelines that are specific to a template implementation. This means, in particular, these rules focus on how a template definition depends on its context.
There is, in particular, one rule left to template interfaces which are quite interesting: T.47: Avoid highly visible unconstrained templates with common names. Admittedly, the rule T47 is often the reason for unexpected behavior because the wrong function is called.
The topic for today is quite important when you create your type: Regular and SemiRegular types.