Author Archives: Glennan Carnie

About Glennan Carnie

Glennan is an embedded systems and software engineer with over 20 years experience, mostly in high-integrity systems for the defence and aerospace industry. He specialises in C++, UML, software modelling, Systems Engineering and process development.

Memory consistency made simple(ish)

The C++11 memory consistency model is probably one of the most significant aspects of Modern C++; and yet probably one of the least well-understood.  I think the reason is simple:  it’s really difficult to understand what the problem actually is.

The memory consistency problem is a concurrency problem.  That is, it’s a problem that occurs when we start writing multi-threaded code.  More specifically, it’s a parallelism problem – the real subtleties occur when you have two or more processors executing code.

In the first […]

Posted in C/C++ Programming, Design Issues, General | Tagged , , | 1 Comment

Seeing stars. And dots. And arrows.

This time I want to look at a seemingly trivial concept in C++ programming: accessing class members, either directly or via a pointer.  More than anything it’s an excuse to talk about two of C++’s more obscure operators – .* and

Posted in C/C++ Programming | Tagged , , , , , , , , , | 1 Comment

Becoming a Rule of Zero Hero

“Do, or do not; there is no ‘try’.”

Previously, we’ve looked at The Rule of Zero which, in essence, says: avoid doing your own resource management; use a pre-defined resource-managing type instead.

This is an excellent guideline and can significantly improve the quality of your application code. However, there are some circumstances where you might not get exactly what you were expecting. It’s not that the code will fail; it just might not be as efficient as you thought.

Luckily, the solution is […]

Posted in C/C++ Programming | Tagged , , , , , , , , , , , | 7 Comments

Bitesize Modern C++ : Smart pointers

The dynamic creation and destruction of objects was always one of the bugbears of C. It required the programmer to (manually) control the allocation of memory for the object, handle the object’s initialisation then ensure that the object was safely cleaned-up after use and its memory returned to the heap. Because many C programmers weren’t educated in the potential problems (or were just plain lazy or delinquent in their programming) C got a reputation in some quarters for being an […]

Posted in C/C++ Programming | Tagged , , , , , , , , , , | 3 Comments

Bitesize Modern C++ : std::array

C++98 inherited C’s only built-in container, the array. Arrays of non-class types behave in exactly the same way as they do in C. For class types, when an array is constructed the default constructor is called on each element in the array

Explicitly initialising objects in an array is one of the few times you can explicitly invoke a class’s constructor.

For track[], the non-default constructor is called for first three elements, followed by default (no parameter) constructor for the last two […]

Posted in C/C++ Programming | Tagged , , , , , | Leave a comment

Bitesize Modern C++ : noexcept

We have some basic problems when trying to define error management in C:

There is no “standard” way of reporting errors. Each company / project / programmer has a different approach
Given the basic approaches, you cannot guarantee the error will be acted upon.
There are difficulties with error propagation; particularly with nested calls.

The C++ exception mechanism gives us a facility to deal with run-time errors or fault conditions that make further execution of a program meaningless.

In C++98 it is possible to specify […]

Posted in C/C++ Programming | Tagged , , , , , , | Leave a comment

Bitesize Modern C++ : Override and Final

Override specifier

In C++98 using polymorphic types can sometimes lead to head-scratching results:

On the face of it this code looks sound; indeed it will compile with no errors or warnings. However, when it runs the Base version of op() will be executed!

The reason? Derived’s version of op() is not actually an override of Base::op since int and long are considered different types (it’s actually a conversion between an int and a long, not a promotion)

The compiler is more than happy to […]

Posted in C/C++ Programming | Tagged , , , , , , | Leave a comment

Bitesize Modern C++ : Range-for loops

If you’re using container classes in your C++ code (and you probably should be, even if it’s just std::array) then one of the things you’re going to want to do (a lot) is iterate through the container accessing each member in turn.

Without resorting to STL algorithms we could use a for-loop to iterate through the container.

If the above is baffling to you there are plenty of useful little tutorials on the STL on the Internet (For example, this one)

We could […]

Posted in C/C++ Programming | Tagged , , , , , , , | 5 Comments

Bitesize Modern C++: std::initializer_list

An aggregate type in C++ is a type that can be initialised with a brace-enclosed list of initialisers. C++ contains three basic aggregate types, inherited from C:

arrays
structures
unions

Since one of the design goals of C++ was to emulate the behaviour of built-in types it seems reasonable that you should be able to initialise user-defined aggregate types (containers, etc.) in the same way.

A std::initializer_list is a template class that allows a user-defined type to become an aggregate type.

When initialiser […]

Posted in C/C++ Programming | Tagged , , , , , , | Leave a comment

Bitesize Modern C++: Uniform initialization

C++98 has a frustratingly large number of ways of initialising an object.

(Note: not all these initialisations may be valid at the same time, or at all. We’re interested in the syntax here, not the semantics of the class X)

One of the design goals in C++11 was uniform initialisation syntax. That is, wherever possible, to use a consistent syntax for initialising any object. The aim was to make the language more consistent, therefore easier to learn (for beginners), and leading to […]

Posted in C/C++ Programming | Tagged , , , , , , | 2 Comments