I know the headline to this post is a little bit boring: More Rules for Expressions. Honestly, this post is about code hygiene, because I will mainly write about pointers.

Today's post is about expressions. You should avoid complicated expressions, you should know the precedence rules for arithmetic or logical expressions, and you should know the order of evaluation of expressions. Having the wrong precedence rules for expressions in mind or assuming an evaluation order for expressions which is just wrong or not guaranteed are the main reasons for undefined behaviour. I know that's a lot to digest. Let's start.

In this post, I will finish the rules for declarations. The remaining rules for declarations are not especially sophisticated but important for high code quality.

Let's continue our tour through the rules for expressions and statements in the C++ core guidelines. This post will be about declarations and initialisations. 

I want to make a short detour from my long serious of posts about the C++ Core Guidelines. I read the excellent book "Clean C++" in the last days and I cannot hesitate to write a review. Here is my review.

There are quite a lot of rules in the C++ Core Guidelines dealing with expressions and statements. To be precise, there are more than 50 rules are about declarations, expressions, statements, and arithmetic expressions.

Passing smart pointers is an important topic which is seldom addressed. This ends with the C++ core guidelines because they have six rules for passing std::shared_ptr and std::unique_ptr.

There were a lot of C++ experts who said that smart pointers were the most important feature of C++11. Today, I will write about smart pointers in C++.

The guidelines has six rules for explicit memory allocation and deallocation. Six! Maybe you are surprised because there is a simple rule in modern C++: don't use new and delete. Obviously, the story is not so simple.

I have prepared the pdf bundle. To get it is quite simple.