Skip to Content

Modern C++ for C Programmers: introduction

Posted on

NOTE: If you like this stuff, come work with me over at PowerDNS - aspiring C++ programmers welcome!

2018 is an exciting time to be a programmer, with so many good “full service” programming languages to choose from: C, C++ 2017, Go, Python, Rust and who knows Swift too. Programming languages are complicated beasts - even the simplest languages have specifications that run (or would run) in the hundreds of pages, and once you include everything, no serious language is likely to clock in under a thousand.

With this comes the fact that every programming language has good parts, and frequently even more bad parts. Evangelists tend to talk a lot about the former, and write volumes on the worst parts of other programming languages.

As Bjarne Stroustrup (the inventor of C++) correctly noted “There are only two kinds of languages: the ones people complain about and the ones nobody uses”. Anyone who professes nothing but love for their chosen programming language is likely not being honest. Every language is a set of tradeoffs between speed, simplicity, completeness, expressiveness, safety and probably other aspects.

I’m a big fan of Lua which managed to avoid a ton of complexity by restricting itself severely. What has remained is a powerful programming language that can be interpreted, compiled and embedded with great ease and performance. But it came at a cost - you can really learn Lua in 20 minutes, but that really is all there is too.

At the other end of the spectrum is modern C++ (2017 era) which decided to attempt to be all things to all people: fast, powerful, complete and highly expressive. The cost has been obvious: there is huge complexity if you use all the features.

In this and subsequent posts, I hope to convince C programmers to give ‘2017 era C++’ (which is entirely unlike 2003 C++) another good look. To do so, I want to show that within C++ hides a simple language that still offers you many good things without immediately requiring you to tackle all 1400 pages of ‘The C++ Programming Language’. In other words, I claim there is great benefit already when only using a judicious selection of the best parts of C++.

My goal is that when you go look for a new language to learn (say, Go or Rust), you will hopefully consider modern C++ as well.

On this series

In this series of posts, I target C++ 2014, for which compilers are widely available. An occasional C++ 2017 feature may slip in. This series will touch on immediately useful parts of C++ that C programmers can benefit from without going “whole hog” C++. The goal is to enable developers to benefit from C++ “one line at a time”.

Specifically, I will not cover:

  • Multiple inheritance
  • Template metaprogramming
  • C++ iostreams (except for standard output, for the rest, there is stdio)
  • C++ locales (use the C ones)
  • User-defined literals
  • “Exotics”.

Source code of the snippets shown in this series can be found on GitHub.

Table of contents

  • Part 1
    • Relation between C and C++
    • Why C++ sort is faster than C qsort
    • Strings
  • Part 2
    • Namespaces
    • Classes
    • Resource Acquisition Is Initialization
    • Smart pointers
    • Threads, atomics
    • Locking
    • Error handling, exceptions
  • Part 3
    • Inheritance & Polymorphism
    • References & Pointers
    • Templates
    • A worked example: high-speed source code indexer
  • Part 4
    • Lambdas
    • Improving our source code indexer
    • Containers & Algorithms
      • Finding & Searching
    • Futher standard & non-standard containers
    • Boost.MultiIndex
  • Part 5
    • Memory management
    • Copy elision / Return Value Optimization
    • Smart Pointers, std::unique_ptr
    • std::move: transferring objects
    • Placement new
    • General memory management advice
  • Part 6
    • static_assert: compile time checks
    • constexpr: compile time execution
    • numeric_limits: information about floating point and integers
    • iostreams: the optional C++ I/O system
    • Measuring time
    • Scoped or Class Enums
    • Regular expressions
    • Initializer lists
    • Default parameters, function overloading
    • std::optional
    • Recommended book list