In his post may the FORs be with you, Michael mentioned that it’s best to avoid handwritten loops at all. This is not self explanatory for a lot of people, and while many arguments can be put forth to support the use of algorithms, in this post let’s stick with one: readabilty.
Continue reading “May the FORs leave you alone”
A little while ago while I was surfing the web I stumbled on a blog of a C++ programmer. Sadly, I was unable to retrace my steps, so I will have to reconstruct what I found there from memory. The programmer was faced with the task of multiplying two matrices with each other. The result is yet another matrix. Efficiency and ease of use were important criteria. Here is the relevant part of the code:
matrix & matrix::operator* (matrix const & other) const
// snip: ... assert matrix sizes are compatible ...
matrix * result = new matrix(rows(), other.columns());
// snip: ... compute and store matrix elements ...
Let us put on our CSI C++ hat for a while.
Continue reading “I like to std::move it”
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”
Everyone who has read Scott Meyer’s books knows: it is a good idea to make your code easy to use correctly and difficult to use incorrectly. In this light, we may be able to improve on the
ifs we routinely use to check our functions’ preconditions.
The basic idea is to remove all the
ifs that check for error conditions at the beginning of your function’s body by providing type parameters that already give sufficiently strong guarantees.
Continue reading “Expressing preconditions with invariants of parameter types”
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
auto value = std::make_shared<Value>("a", "few", "arguments");
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”
Most computer programs rely on resources provided by the operating system or another software. The most common resource is memory, closely followed by files on the local file system. Be it a chunk of memory or a database connection, resources should be dealt with gently; return them once you no longer need them.
Many text books and university courses on C++ familiarize the programmer with low-level functions such as new and delete. These mechanisms are inconvenient and error-prone since you need to make sure that you release the resource no matter which execution path your program takes. Less obvious paths, for example exceptions in the control flow, tend to be forgotten.
Continue reading “Resource management”