Tom

In C++03, only const static members of integral type can be initialised directly in the class. C++11 allows members to be initialised in-class. class Test { public: const static int x = 0; // C++03 int y = 0; // C++11 only }; We can also initialise objects e.g. strings: class Test { public: std::string … Read more

The C++11 standard introduced two new smart pointers, unique_ptr and shared_ptr. These new classes are very helpful for managing dynamically allocated memory. The difference between these two smart pointers is that unique_ptr implies exclusive ownership to a block of memory, whereas shared_ptr allows for multiple ownership. Both these smart pointers are defined in the memory … Read more

Lambda expressions allow you to define anonymous functions in your C++ code. A good way to demonstrate lambda expressions in practice is to show how they can be used in conjunction with some of the algorithms in the standard library. For example, here is how we would sort a list of integers in C++03: bool … Read more

In the previous post on Rvalue References, we introduced lvalues, rvalues and temporary objects. The purpose of that post was to lay the groundwork for a discussion on move semantics, an important feature which was introduced in the C++11 standard. We again consider the example of a Vector class for 3D geometry. The definition file … Read more

Rvalues and Lvalues The terms lvalue and rvalue do not typically come up often for most programmers. Occasionally you might see a compiler error message about rvalues. Other than that, it is not something you generally have to worry about. If we consider the simple assignment: a = b there is an obvious symmetry; a … Read more

In some situations, it’s useful to provide more than one way to initialise an object. When we choose to provide more than one constructor, we want to avoid having to duplicate code. Consider the following example of a simple 2D vector class, which can be initialised either by passing in two doubles, or a double … Read more

The C++ standard library comes with a host of useful container classes. However, using these classes means becoming familiar with the language of templates. Simply iterating through a collection requires the use of some quite verbose syntax. For example, suppose we have a vector of integers: std::vector<int> intArray; In C++03, the contents of the vector … Read more

In C++03, auto specifies that a variable has automatic storage duration. This means that the variable is destroyed when it falls out of scope. This contrasts with static variables which persist for the lifetime of the program. Since the default storage duration is auto, the specifier is usually omitted. In C++11, the auto keyword has … Read more

In C++03, there is no concept of null built in to the language. For anyone familiar with C# or Java, this is quite surprising. Prior to C++11, the NULL literal was typically used to overcome this omission. However, there are some downsides to using NULL: The NULL literal is implementation-defined so it could, for example, … Read more