May the FORs be with you

Loops are among the basic constructs you find in nearly all programming languages. Of the available variations,  for loops are the most common ones. The word  for is so small that it is not affected by the tax on long keywords and variable names that programming languages seem to be subject of. Thus, you will find  for as a keyword in most of them.

C++11 supports a multitude of styles to write  for loops. Let us have a look at some of these possibilities for a simple example.

Continue reading “May the FORs be with you” »

Mopping up template barf with static_assert

Templates are a mixed blessing for C++ developers. On the one hand, templates avoid code duplication as most impressively demonstrated by the standard template library. The template mechanism, in contrast to preprocessor macros, is aware of the C++ language and part of it. Compilers can produce helpful error messages – and some compilers even do so.

Some compilers, however, fail in providing clear template compilation error messages. If you make a mistake, you are greeted by a bucket load of irritating notes on what went wrong in detail. Since it is down to you to identify the relevant chunks, this is often referred to as template barf.

Continue reading “Mopping up template barf with static_assert” »

Underprivileged unique pointers: retrofitting make_unique

std::shared_ptr<Value> is one of the starlets in C++11′s recently polished standard template library. shared_ptrs work just like normal C-style pointers except that they keep track of how many pointers point to the same object. Once the last shared_ptr pointing to an object goes out of scope, the object pointed at will be deleted. For convenience, the standard library offers the factory function std::make_shared<Value>():

std::make_shared<Value>() creates a new object of type Value, where the arguments given to make_shared() are forwarded to the constructor of Value. The newly created object is immediately wrapped in a std::shared_ptr<Value>, which is then returned to the caller.

Continue reading “Underprivileged unique pointers: retrofitting make_unique” »