Mead's Guide to Modern C++
(An Introduction)

Overview Right Angle Brackets (N1757) Deprecated register keyword (P0001R1) Binary Literals (N3472) Single-Quote As a Digit Separator (N3781) Explicit Conversion Operators Uniform Initialization Initializer Lists (N2672) Range-Based For Loops (N2930) nullptr (N2431) Strongly Typed Enums (N2347) auto Deductions (N1984) Forward Declarations Of Enums (N2764) Raw and Unicode String Literals (N2442) Non-static Data Member Initializers (N2756)

Trailing Return Types (N3276) __func__ Predefined Identifier (N2340) Delegating Constructors (N1986) noexcept Generalized constexpr (N2235) Template Aliases (N2258) Lambdas (N2927) Long Long data type (N1811) Defaulted and Deleted functions (N2346) Structured Bindings (P0144R2) Generalized Attributes (N2761) Stricter Expression Evaluation Order (P0145R3) std::array References

Overview

The topics presented should be understandable by anyone that has programmed in C++ for a few months. I am not going to cover topics that I consider more "advanced" such as move semantics, rvalue references, universal references, perfect forwarding, deduction guides, fold expressions, variadic templates, or template type deduction vs. auto type deduction. I consider the topics covered here to be used by Everyday C++ Programmers™. I'm also not covering the additions to the STL (e.g. concurrency, regular expressions, smart pointers).

I present the topics in no particular order. However, some may need to be looked at before others, as they may have some dependencies.

To build these examples, you may need to tell the compiler which "standard" to use. Most of the examples only require a C++11-compliant compiler, but some of them use features from a later standard, (e.g. C++14, C++17, C++20, etc.) To specify the version with g++ and clang++, use the -std=XXX compiler option where XXX is the version. For Microsoft's compiler, cl, use /std:XXX. Examples:

g++ -std=c++11 foo.cpp
clang++ -std=c++14 foo.cpp
g++ -std=c++17 foo.cpp
cl /std:c++17 foo.cpp

This is the list of included files to compile all of the examples:

#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <deque>
#include <initializer_list>
#include <iostream>
#include <list>
#include <set>
#include <string>
#include <tuple>
#include <typeinfo>
#include <vector>

using namespace std;

All of the code examples should compile and run (unless they are purposely showing improper use), so you can copy and paste them into your sandbox and play with them to answer all of your questions like "Can I do this?" and "What happens if I do that?"

But hey, enough of my yakkin'; whaddaya say? Let's boogie!

Right Angle Brackets (N1757)

vector<list<int>> vl;  // Error in C++03 because >> is the right shift operator!
vector<list<int> > vl; // This was the "fix" in C++03

Error from g++:

 error: spurious '>>', use '>' to terminate a template argument list
   std::vector<std::list>> vl;

error: a space is required between consecutive right angle brackets (use '> >')
  std::vector<std::list>> vl;
                       ^~
                       > >

Deprecated register keyword (P0001R1)

register int i = 10; // deprecated in C++11

warning: 'register' storage class specifier is deprecated and incompatible with C++17 [-Wdeprecated-register]
  register int i = 10;
  ^~~~~~~~~
1 warning generated.

error: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  register int i = 10;
  ^~~~~~~~~
1 error generated.

int register = 10; // use register as a variable name

error: expected unqualified-id
  int register = 10;
               ^

I wrote a discussion about some of the storage classes in C here.

Binary Literals (N3472)

  // All values are equivalent, decimal 17
int i1 = 17;      // decimal
int i2 = 021;     // octal (leading zero)
int i3 = 0x11;    // hexadecimal (leading 0x or OX)
int i4 = 0b10001; // C++14 binary (leading Ob or OB)

  // All lines output 17 (decimal)
cout << "i1 is " << i1 << endl;
cout << "i2 is " << i2 << endl;
cout << "i3 is " << i3 << endl;
cout << "i4 is " << i4 << endl;

  // Overriding the default decimal base
cout << oct << showbase << i1 << endl; // 021
cout << hex << showbase << i1 << endl; // 0x11

  // Unfortunately, there currently is no built-in way to print in binary
cout << bin << showbase << i1 << endl; // The bin manipulator doesn't exist!!

For an easy way to print an integer in binary, you can use a std::bitset. This is a templated class that takes a non-type (value) template parameter that represents the number of bits. The class overloads operator<< to display the ones and zeros:

cout << bitset<5>(i1) << endl;  // output: 10001
cout << bitset<8>(i1) << endl;  // output: 00010001
cout << bitset<16>(i1) << endl; // output: 0000000000010001
cout << bitset<32>(i1) << endl; // output: 00000000000000000000000000010001
cout << bitset<47>(i1) << endl; // output: 00000000000000000000000000000000000000000010001

#include <bitset>

Single-Quote As a Digit Separator (N3781)

long long a = 10000000000; // Hold on, let me count the zeros...

long long b = 10,000,000,000; // Easy! 10 billion

long long b = 10'000'000'000; // Still easy to read

long long b;
b = 10000000000; 
b = 10'000'000'000; 
b = 100'0000'0000;
b = 1'0000'000000;
b = 100'00'00'00'00;
b = 1'0'0'0'0'0'0'0'0'0'0;

This delimiter will work with any number base:

int i1 = 1'234'789;   // decimal
int i2 = 01'234'567;  // octal
int i3 = 0x1'abc'def; // hexadecimal
int i4 = 0b1'000'101; // binary

float f = 3.14'999'999F;          // float
double d1 = 1'234.7'200'009;      // double
double d2 = 1.234'567e+123;       // double (e-notation)
double d3 = 1.2'3'4'5'6'7e+1'2'3; // crazy!!

• This feature was added in C++14, so the compiler needs to be more compliant than just C++11.
• Although it looks like you can put quotes anywhere, there are rules to follow.
• You can't have two adjacent quotes.
• You can't have a quote next to a decimal point.
• You can't have a quote next to the e.
• You can't have a quote next to the x or b in hex/binary representations.
• In other words, the single quotes must be placed between two digits.
• IMHO, this is one of those seemingly-trivial things that should have been part of the language decades ago.
• To see how different cultures use different delimiters, check this out.

Explict Conversion Operators (N2437)

C++ has had conversion constructors forever. A conversion constructor is essentially a one-argument constructor. This constructor, then, converts the argument into an object of the class' type. Hence, the term, conversion constructor. Quick example:

class Foo3
{
  public:
    // Conversion constructor
    Foo3(int x) : x_(x)
    {
    }
  private:
    int x_;
};

void fn1(const Foo3& f)
{
  // Do something with f
}

Foo3 f(42); // Construct a Foo3 object from an integer (conversion constructor)
f = 43;     // The conversion constructor is called implicitly
fn1(45);    // The conversion constructor is called implicitly

To prevent these automatic and silent conversions, you simply mark the conversion constructor as explicit:

// Explicit conversion constructor
explicit Foo3(int x) : x_(x)
{
}

error: no viable overloaded '='
  f = 43;     // The conversion constructor is called implicitly
  ~ ^ ~~
note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const Foo3' for 1st argument
class Foo3
      ^
error: no matching function for call to 'fn1'
  fn1(43);    // The conversion constructor is called implicitly
  ^~~
note: candidate function not viable: no known conversion from 'int' to 'const Foo3' for 1st argument
void fn1(const Foo3& f)
     ^
2 errors generated.

f = Foo3(43);  // OK, explicit cast
fn1(Foo3(43)); // OK, explicit cast

Foo3 f(42); // Construct a Foo3 object from an integer

int i = f;                   // Error: Can't assign a Foo3 to an integer
int j = (int)f;              // Error: Still can't do it (compiler doesn't know how)
int k = int(f);              // Nope
int n = static_cast<int>(f); // Nope

Adding a conversion operator to the Foo3 class:

class Foo3
{
  public:
    // Conversion constructor
    explicit Foo3(int x) : x_(x)
    {
    }

    // Conversion operator
    operator int() const
    {
      return x_;
    }

  private:
    int x_;
};

// Conversion operator
explicit operator int() const
{
  return x_;
}

int i = f; // Error: Can't implicitly convert a Foo3 to integer

int j = (int)f;              // OK, explicit C-style cast
int k = int(f);              // OK, explicit C++-style cast
int n = static_cast<int>(f); // OK, explicit C++ named cast

void prints(const string& str)
{
  cout << str << endl;
}

Foo3 f(42); // Construct a Foo3 object from an integer
prints(f);  // Error: No conversion from Foo3 to string

// You can mark this explicit, if necessary
operator std::string() const
{
  return std::to_string(x_); // to_string is new in C++11
}

Foo3 f(42); // Construct a Foo3 object from an integer
prints(f);  // OK, now prints 42

• Having the compiler automatically and silently convert between types is a double-edged sword.
1. It makes it convenient for the programmer.
2. However, it can perform unintended conversions.
• Marking the conversion operators explicit doesn't prevent conversions, it just requires the programmer to be explicit about it.

Uniform Initialization (uniform-init a.k.a. Brace Initialization)

This is actually part of Initializer Lists (N2672) described below, but I wanted to demonstrate the simplest uses before the more complicated ones.

1. Simple built-in scalar types:

   int a = 1; // Copy initialization ("assignment" operator)
   int b(3);  // Direct initialization (parentheses)
   

2. Arrays:

     // Use "assignment" operator and braces to initialize the arrays
   int array1[] = {1, 2, 3};                       
   const char *array2[] = {"one", "two", "three"};
   

3. Structs (POD types):

   struct Point
   {
     double x;
     double y;
   };
   
     // Use "assignment" operator and braces to initialize the struct
   Point p = {1.0, 2.0};
   

4. Classes or structs (with private members)

   class Foo
   {
     public: 
       Foo(int v1, int v2) : a_(v1) // This is initialization (member initializer list)
       {
         b_ = v2; // This is assignment
       }
     private:
       int a_;
       int b_;
   };
   
   Foo f(1, 2); // a_ will be initialized by the constructor
   

  // Simple initialization
double d1 = 3.14;   // C++98 (copy initialization)
double d2 = {3.14}; // C++98 (brace initialization, was almost never used)
double d3(3.14);    // C++98 (direct initialization)
double d4{3.14};    // C++11 (brace initialization)

int i1 = 3.14;   // Clang warns, g++ is silent (even with -Wall, need -Wconversion)
int i2(3.14);    // Clang warns, g++ is silent (even with -Wall, need -Wconversion)
int i3{3.14};    // Clang error, g++ error
int i4 = {3.14}; // Clang error, g++ error (new behavior)

int i5 = 1;    // OK
double d5 = 2; // OK
double d6{1};  // OK, literal is known at compile-time
double d7{i5}; // Clang error, g++ warning,
int i6{d5};    // Clang error, g++ warning,

int ii1;         // Undefined (assume local inside of a function)
int ii2();       // Function prototype! a.k.a "the most vexing parse" (Clang warns)
int ii3{};       // 0 (New)
int ii4 = {};    // 0
int ii5 = int(); // 0
int ii6 = int{}; // 0 (New)

"Prefer the {}-initializer syntax for declarations with a named type."

There is a nice consequence of this new syntax. It's called aggregate initialization and it allows you to initialize an aggregate data structure (array or POD structure) using default initialization.

Recall that we could always do this:

struct Point
{
  double x;
  double y;
};

Point p = {1.0, 2.0}; // Use "assignment" operator and braces to initialize the struct

Point p {1.0, 2.0}; // Use braces to initialize the struct

Point p {}; // x and y are both 0.0

Point p; // x and y are both undefined

The aggregate data type must either be an array or a class, struct, union that meets these criteria:

• No user-defined non-default constructor
• No private or protected non-static data members
• No virtual functions
• No virtual, private, or protected base classes

struct S1
{
  public: 
    void print()
    {
      cout << "s is " << s << ", i is " << i << ", d is " << d << endl;      
    }
      // All are public
    string s;
    int i;
    double d;
};

S1 s1;                  // Undefined values for built-in types int and double (string is initialized to "")
S1 s2 = {"", 10, 3.14}; // Initialize all members (public)
S1 s3 = {};             // All members default-initialized {"", 0, 0.0}
S1 s4 {"", 10, 3.14};   // (C++11) Using uniform-initialization
S1 s5 {};               // (C++11) Using uniform-initialization {"", 0, 0.0}

s1.print(); // s is , i is 166494208, d is 3.11218e-317
s2.print(); // s is , i is 10, d is 3.14
s3.print(); // s is , i is 0, d is 0
s4.print(); // s is , i is 10, d is 3.14
s5.print(); // s is , i is 0, d is 0

struct S2
{
  public:
    void print()
    {
      cout << "s is " << s << ", i is " << i << ", d is " << d << endl;      
    }
  private:
    string s;
    int i;
    double d;
};

S2 s6;      // Undefined values for built-in types int and double
S2 s8 = {}; // All members default-initialized {"", 0, 0.0}
S2 s10 {};  // (C++11) all members default-initialized {"", 0, 0.0}

S2 s11 = {"", 10, 3.14}; // This is still illegal (private)

s6.print();  // s is , i is 166494208, d is 3.11218e-317
s8.print();  // s is , i is 0, d is 0
s10.print(); // s is , i is 0, d is 0

Technically, S2 is not a POD because it has private data. However, now using uniform-initialization, you can default-initialize them without a constructor. This may seem like a small advantage, and it probably is. The one other thing that is potentially more useful is that, since C++17, PODs can inherit from certain base classes (not shown here). This was not possible before C++11.

Links:

• Variable Initialization The difference between default initialization, direct initialization, copy initialization, and list initialization. Also, the difference between using ( ) and using { } for initialization.
• Uniform initialization syntax and semantics at Stroustrup's site.
• Extension to aggregate initialization This was added to C++17.

Initializer Lists (N2672)

Member Array Initialization

class Foo2
{
  public:
    Foo2()
    {
        // C++98/03 can't initialize a member array. Must use a loop and "assign" values.
      for (int i = 0; i < 3; i++)
        array_[i] = i + 1;
    }
  private:
    int array_[3]; // How to initialize?
};

class Foo2
{
  public:
    Foo2() : array_{1, 2, 3} // member array initialization (MUST use braces)
    {
      // empty body
    }
  private:
    int array_[3];
};

Foo2() : array_( {1, 2, 3} ) // Incorrect

class Foo2
{
  public:
    Foo2()
    {
      // empty body
    }
  private:
    int array_[3] = {1, 2, 3}; // member array initialization (equal sign is optional)
};

error: array bound cannot be deduced from an in-class initializer
    int array_[] = {1, 2, 3}; // member array initialization (equal sign is optional)
                 ^

error: too many initializers for 'int [0]'
     int array_[] = {1, 2, 3}; // member array initialization (equal sign is optional)
                            ^

  // size and capacity is 0
vector<int> v0;

  // Add elements
v0.push_back(1);
v0.push_back(2);
v0.push_back(3);
v0.push_back(4);
v0.push_back(5);

  // Size is 5, capacity is implementation-dependent (it's 8 with clang)
cout << "size: " << v0.size() << ", capacity: " << v0.capacity() << endl;

  // Initialize vector with initializer list syntax
vector<int> v1{1, 2, 3, 4, 5};

  // Size and capacity are both 5
cout << "size: " << v1.size() << ", capacity: " << v1.capacity() << endl;

list<int> list1 {5, 4, 3, 2, 1};
deque<int> deque1 {3, 4, 5, 1, 2};
set<int> set1 {5, 4, 3, 2, 1};

5  4  3  2  1  
3  4  5  1  2  
1  2  3  4  5  

Functions taking initializer lists

A couple of functions to use:

// Function taking a vector
void fn1(const std::vector<int>& v)
{
  cout << "vector: ";
  print5(v);
}

// Function taking an initializer_list
void fn2(const std::initializer_list<int>& lst)
{
  cout << "init list: ";
  print5(lst);
}

fn1({1, 2, 3});               // conversion constructor for vector
fn1(vector<int>{1, 2, 3, 4}); // pass vector (temporary)
fn2({1, 2, 3, 4, 5});         // pass initializer_list
fn1(1, 2, 3, 4, 5);           // Error
fn2(1, 2, 3, 4, 5);           // Error

vector: 1  2  3  
vector: 1  2  3  4  
init list: 1  2  3  4  5  

cpp14.cpp:357:3: error: no matching function for call to 'fn1'
  fn1(1, 2, 3);
  ^~~
cpp14.cpp:244:6: note: candidate function not viable: requires single argument 'v', 
                 but 3 arguments were provided
void fn1(const std::vector& v)
     ^
cpp14.cpp:358:3: error: no matching function for call to 'fn2'
  fn2(1, 2, 3);
  ^~~
cpp14.cpp:250:6: note: candidate function not viable: requires single argument 'lst', 
                       but 3 arguments were provided
void fn2(const std::initializer_list& lst)
     ^

• Since there is a (conversion) constructor for the vector class that takes an initializer_list, the first call will work by implicitly constructing a vector.
• The second call explicitly constructs an anonymous vector object from the initializer_list and then passes that.
• The third call exactly matches the function that takes an initializer_list.
• You could have overloaded fn1 instead of creating a second function with a different name. Beware, of course, that overloading can lead to ambiguities.

How would we add support for initializer lists to, say, our own Vector class?

1. First, we would have to include the header file that supports initializer lists (in Vector.h):

   #include <initializer_list>
   

2. And then add a new constructor to the header file:

   Vector(const std::initializer_list<int>& list);
   

3. Then in the .cpp file we would implement it:

   Vector::Vector(const std::initializer_list<int>& list) 
      : array_(0), size_(0), capacity_(0)
   {
       // Get the number of elements in the intializer list
     size_t size = list.size();
   
       // The initializer list could be empty
     if (size)
     {
         // Just grow the internal array once (optimization)
       grow(size);
   
         // Iterate over the initializer list, pushing each element to the back
       std::initializer_list<int>::const_iterator it = list.begin();
       while (it != list.end())
         push_back(*it++);
     }
   }
   

4. And then test it out with some driver code:

   Vector v {1, 2, 3, 4, 5};
   Print(v);
   

   Output:

   1  2  3  4  5  (size=5, capacity=5, allocs=1)
   

Links:

• Variable Initialization The difference between default initialization, direct initialization, copy initialization, and list initialization. Also, the difference between using ( ) and using { } for initialization. If you are going to use braces and initializer lists, this is a must read.
• Initializer lists at Stroustrup's site.

Range-Based For Loops (N2930)

template<typename InputIt, typename Op> Op for_each(InputIt first, InputIt last, Op op);

  // Initialize int array (20 bytes)
int a[] = {1, 2, 3, 4, 5};

  // Print out each element: 1 2 3 4 5
int size = sizeof(a) / sizeof(*a);
for (int i = 0; i < size; i++)
  cout << a[i] << " ";
cout << endl;

  // Using a range-based for: 1 2 3 4 5
for (int i : a)
  cout << i << " ";
cout << endl;

  // Multiply each element by 10 (reference)
for (int& i : a)
  i *= 10;

  // Display: 10 20 30 40 50
for (int i : a)
  cout << i << " ";
cout << endl;

  // Assume some array of large objects
const BigObject BigObjectArray[] = {. . .};

  // Don't want to copy large objects, but don't want to modify either
for (const BigObject& b : BigObjectArray)
  ProcessBigObject(b);

Although I'm showing you how to use the range-based for with static arrays (for simplicity now), you will probably rarely do this because of the limitations of static arrays. Range-based for was primarily developed for containers (specifically STL containers). Also, static arrays are now used rarely because of the far superior std::array container (see below) that has been added to the STL.

list<int> lst {1, 2, 3, 4, 5}; // Using C++11 initializer lists

  // Using C++98/03 iterators with for loop: 1 2 3 4 5
for (list<int>::iterator it = lst.begin(); it != lst.end(); ++it)
  cout << *it << " ";
cout << endl;

  // Using auto with iterators and for loop: 1 2 3 4 5
for (auto it = lst.begin(); it != lst.end(); ++it)
  cout << *it << " ";
cout << endl;

  // Using range-based for loop: 1 2 3 4 5
for (int i : lst)
  cout << i << " ";
cout << endl;

Suppose we had a vector that already had values in it and we wanted to add a few more "random-like" values. This is how we might do it before:

  // Create a vector with some integers
vector<int> v {1, 2, 3, 4};

  // Do a bunch of stuff with the vector...

  // OLD WAY: Add some "random values" (verbose)
v.push_back(7);
v.push_back(11);
v.push_back(18);
v.push_back(-5);
v.push_back(0);
v.push_back(42);

  // Create a vector with some integers
vector<int> v {1, 2, 3, 4};

  // Do a bunch of stuff with the vector...

  // NEW WAY: Add some random values (concise)
for (int i : {7, 11, 18, -5, 0, 42})
  v.push_back(i);

• Range-based for loops require that the type being iterated over understands the concept of a range
• Basically, any type that supports begin(), end(), and operator++ will work.
• Built-in arrays now have corresponding global begin() and end() functions that will allow them to behave just like the standard containers (e.g. begin(array))
• Limitations:
• Only works with for, not while or do...while.
• You must process the entire range (i.e. can't skip elements). For example, you can't do this (easily):

    // Print every other element:
  for (int i = 0; i < len; i += 2)
    cout << a[i] << " ";
  

  (There is discussion in the C++ standards committee that is considering this for a future version.)

• Range-based for loops have limited use with static arrays and can't be used at all with dynamic arrays.
• This means you can't use it with pointers (i.e. you can't pass a static array to a function and use that):

  void fn(int *array)
  {
      // Won't work, array is a pointer
    for (int i : array)
      cout << i;
  }
  
  error: invalid range expression of type 'int *'; no viable 'begin' function available
    for (int i : array)
               ^ ~~~~~
  

• Because of these limitations, this technique is rarely used with static arrays. (Built-in static arrays are also used less these days because std::array is a better replacement.)
• This technique was primarily invented for use with STL containers.
• std::initializer_list will also work.
• Range-for at Stroustrup's site.

nullptr (N2431)

#define NULL ((void *)0) // C
#define NULL 0           // C++98

void foo(int)
{
  cout << "foo(int)" << endl;
}

void foo(int *)
{
  cout << "foo(int *)" << endl;
}

foo(0);       // foo(int)
foo(nullptr); // foo(int*), C++11
foo((int*)0); // foo(int*)

foo(NULL); // possibly ambiguous, depending on how NULL is defined

error: call to 'foo' is ambiguous
  foo(NULL); // possibly ambiguous, depending on how NULL is defined
  ^~~
note: candidate function
void foo(int)
     ^
candidate function
void foo(int *)
     ^
1 error generated.

• The nullptr can be used to compare to any pointer type.
• It can also be converted to bool, so this still works:

  char *p = nullptr;
  . . .
  if (p)
    . . .
  

• This can also help prevent ambiguities in template functions where the template parameter T may treat a 0 as an integer, instead of a null pointer.
• See this for an example of ambiguity with overloaded functions taking pointers.
• nullptr -- a null pointer literal at Stroustrup's site.

Strongly Typed Enums (N2347)

There are actually 3 things that have changed with respect to enumerations in C++11. In no particular order:

1. Create a new kind of enum that is strongly typed: enum class
2. Allow the programmer to choose the underlying type (i.e. sizeof) used to represent the enum.
3. Allow access to the enum via the scope resolution operator.

enum ColorSpace {Red, Green, Blue};     // Represent graphics colors

ColorSpace cs = Green; // Set color to green (integer 1)

cs = 1; // ERROR: no conversion from integer

int i = Green; // OK, implicit conversion to integer, C++03 only

enum ColorSpace {Red, Green, Blue};     // Represent graphics colors
enum TrafficLight {Red, Yellow, Green}; // Represent traffic signals

error: redefinition of enumerator 'Red'
  enum ColorSpace {Red, Green, Blue};     // Represent graphics colors
                   ^
note: previous definition is here
  enum TrafficLight {Red, Yellow, Green}; // Represent traffic signals
                     ^
error: redefinition of enumerator 'Green'
  enum ColorSpace {Red, Green, Blue};     // Represent graphics colors
                        ^
note: previous definition is here
  enum TrafficLight {Red, Yellow, Green}; // Represent traffic signals
                                  ^

enum ColorSpace {csRed, csGreen, csBlue};     // Represent graphics colors
enum TrafficLight {tlRed, tlYellow, tlGreen}; // Represent traffic signals

ColorSpace color = csGreen;   // OK 
TrafficLight light = tlGreen; // OK

Then there is the issue with this:

sizeof(ColorSpace)

Fortunately, C++11 solves these shortcomings with a feature call enumeration classes:

  // Elements are no longer ambiguous
enum class ColorSpace {Red, Green, Blue};     // Represent graphics colors
enum class TrafficLight {Red, Yellow, Green}; // Represent traffic signals

  // Clear, unambiguous, self-documenting
ColorSpace cs = ColorSpace::Green;
TrafficLight tl = TrafficLight::Green;

int i = Color::Green; // No conversion to int in C++11

If you leave off the class, you can still use the scope resolution operator. This was an enhancement made to the original enum specification:

enum TrafficLight {Red, Yellow, Green}; // Represent traffic signals

TrafficLight tl = TrafficLight::Green; // Optional qualifier (recommended)
TrafficLight tl2 = Green;              // Same as TrafficLight::Green

C++11 also lets you choose the representation of the enumeration:

enum class TrafficLight : char {Red, Yellow, Green};  // Represent traffic signals
enum class ColorSpace : short {Red, Green, Blue};     // Represent graphics colors
enum class Twister : long {Red, Green, Blue, Yellow}; // Represent the game colors
enum class Checkers {Red, Black};                     // Represent the game colors

  // Sizes shown are using the LP64 data model  
cout << sizeof(TrafficLight) << endl; // 1
cout << sizeof(ColorSpace) << endl;   // 2
cout << sizeof(Twister) << endl;      // 8
cout << sizeof(Checkers) << endl;     // 4 (default type is int)

• When you have a choice, use the scoped enumerations (enum classes) to avoid any ambiguities.
• You can use both the class keyword and the underlying type, in any combination:
  1. No class, no type (default, C++03):

       // Existing behavior, underlying type is compiler-dependent
     enum Color {Red, Yellow, Green};
     
     cout << sizeof(Color) << endl; // 4 (defaults to int)
     cout << Color::Green << endl;  // 2 (may be qualified, new in C++11)
     cout << Green << endl;         // 2 (may be unqualified)
     

• The rest are new in C++11:
2. No class, with type:

     // Specify underlying type
   enum Color : char {Red, Yellow, Green};
   
   cout << sizeof(Color) << endl; // 1
   cout << Color::Green << endl;  // 2 (may be qualified)
   cout << Green << endl;         // 2 (may be unqualified)
   

3. With class, no type (default):

     // Enumeration class (distinct type)
   enum class Color {Red, Yellow, Green};
   
   cout << sizeof(Color) << endl;     // 4 (defaults to int)
   cout << int(Color::Green) << endl; // 2 (Must be qualified, must cast, no operator<< for Color)
   cout << Green << endl;             // Illegal, must be qualified
   

4. With class and type:

     // Enumeration class (distinct type), specifying underlying type
   enum class Color : long {Red, Yellow, Green};
   
   cout << sizeof(Color) << endl;     // 8
   cout << int(Color::Green) << endl; // 2 (Must be qualified, must cast, no operator<< for Color)
   cout << Green << endl;             // Illegal, must be qualified
   

• You should probably let the compiler choose the underlying representation, unless you have a good reason to override it (e.g. large arrays of enums and memory is very constrained.)
• enum class -- scoped and strongly typed enums at Stroustrup's site.

enum class ColorSpace : short; // Represent graphics colors (forward declaration)

// Other code ...

enum class ColorSpace : short {Red, Green, Blue}; // Actual definition is here

• Obviously, the forward declaration must match that definition (i.e. underlying type) or it's an error.
• Use when the compiler needs to know the size of the underlying type (for memory layout), but doesn't need to know the actual names or values of the members.
• Only works with scoped enumerations (i.e. enum class).
• Read all of the gory details about it here.

auto Deductions (N1984)

auto i = 10;    // int
auto d = 10.0;  // double
auto f = 10.0F; // float

cout << typeid(i).name() << endl; // i
cout << typeid(d).name() << endl; // d
cout << typeid(f).name() << endl; // f

const auto ii = 10;    // const int
auto& ri = ii;         // int&
const auto& cri = ii; // const int&

auto i1 = 1;   // int, as expected
auto i2 = {1}; // initializer_list<int>, probably not what you want
auto i3 {1};   // int, before C++14 it was initializer_list<int>
auto i4(1);    // int

cout << typeid(i1).name() << endl; // i
cout << typeid(i2).name() << endl; // St16initializer_listIiE
cout << typeid(i3).name() << endl; // i
cout << typeid(i4).name() << endl; // i

vector<int> v1;

auto x1 = v1.crbegin();
cout << typeid(x1).name() << endl;

vector<int>::const_reverse_iterator x2 = v1.crbegin();
cout << typeid(x2).name() << endl;

St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEE
St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEE

  // vector<int>
auto v2(v1);
cout << "   auto v2(v1) is " << typeid(v2).name() << endl;

  // vector<int>
auto v3 = v1;
cout << "  auto v3 = v1 is " << typeid(v3).name() << endl;

  // vector<int>  
auto v4{v1};
cout << "   auto v4{v1} is " << typeid(v4).name() << endl;

  // initializer_list<vector<int>>
auto v5 = {v1};
cout << "auto v5 = {v1} is " << typeid(v5).name() << endl;

  // vector<int> (no auto)
vector<int> v6 = {v1};
cout << "     v6 = {v1} is " << typeid(v6).name() << endl;

   auto v2(v1) is St6vectorIiSaIiEE
  auto v3 = v1 is St6vectorIiSaIiEE
   auto v4{v1} is St6vectorIiSaIiEE
auto v5 = {v1} is St16initializer_listISt6vectorIiSaIiEEE
     v6 = {v1} is St6vectorIiSaIiEE

template <typename T>
void print5a(const T& container)
{
  for (typename T::const_iterator iter = container.begin(); iter != container.end(); ++iter)
    std::cout << *iter << "  ";
  std::cout << std::endl;
}

template <typename T>
void print5b(const T& container)
{
  for (auto iter = container.begin(); iter != container.end(); ++iter)
    std::cout << *iter << "  ";
  std::cout << std::endl;
}

template <typename T>
void print5(const T& container)
{
  for (auto e : container)
    std::cout << e << "  ";
  std::cout << std::endl;
}

auto i = 5, j = 7, *pi = &i; // OK
auto k = 100, d = 3.1415;    // error: inconsistent deduction for auto

vector<int> v1 {1, 2, 3};
for (auto iter = v1.begin(), end = v1.end(); iter != end; ++iter)
  cout << *iter << endl;

• Before C++11, the auto keyword was used as a storage specifier. However, it really went unused for decades so is unlikely to prove problematic with existing code.
• As with template deduction, the compiler has detailed and sometimes complex rules as to how auto will be applied. You should only use it when you are sure as to what the compiler is going to decide the type should be.
• The auto keyword is really meant for long and difficult types (think templates and lambda functions). Although it works for all types, it has little benefit with simple types (e.g. int, double, etc.).
• Using the auto keyword out of laziness actually requires the programmer to do more work. What does SomeFunc return?

  auto x = SomeFunc(); // You must read the documentation or header file.
  

  It's abuses like this that cause extra work for programmers.
• As Herb Sutter says "Treat a new C++ feature like you would treat a loaded automatic weapon in a crowded room: never use it just because it looks nifty. Wait until you understand the consequences."
• More info on multiple auto Declarations (N1737).

Raw and Unicode String Literals (N2442)

    "('(?:[^\\\\']|\\\\.)*'|\"(?:[^\\\\\"]|\\\\.)*\")|"

Are the high-lighted five backslashes correct or not? Even experts become easily confused. Here is the same line as a raw string literal:

    R"(('(?:[^\\']|\\.)*'|"(?:[^\\"]|\\.)*")|)"

This is a mistake that every Windows programmer has made and had to deal with:

std::string text_editor("c:\windows\system32\notepad.exe");

error: unknown escape sequence '\w' [-Werror,-Wunknown-escape-sequence]
  std::string text_editor("c:\windows\system32\notepad.exe");
                             ^~
error: unknown escape sequence '\s' [-Werror,-Wunknown-escape-sequence]
  std::string text_editor("c:\windows\system32\notepad.exe");
                                     ^~
2 errors generated.

This is the proper way:

std::string text_editor("c:\\windows\\system32\\notepad.exe");

std::string text_editor(R"(c:\windows\system32\notepad.exe)");

To construct a raw string:

1. A raw string must start with R" (capital 'R' only, not lowercase 'r') and a double-quote character.
2. The R" is then followed by a PREFIX which consists of 0 to 16 characters. Most characters are allowed.
3. The (optional) PREFIX must be followed by a left parenthesis.
4. After the left parenthesis, the actual characters of the string will follow and no interpretation is done, i.e. backslashes do not escape anything and double-quotes do not terminate the raw string but are part of it.
5. The raw string is terminated by a right parenthesis followed by the same PREFIX that was specified in #2.
6. Finally, a double-quote character terminates the entire sequence.

hello
he"ll"o
hel)lo
h\tello\n
R"(

cpp14.cpp:562:29: error: missing terminating '"' character [-Werror,-Winvalid-pp-token]
  const char *s6 = R"(R"()")";     // ERROR
                            ^
cpp14.cpp:562:28: error: expected ';' at end of declaration
  const char *s6 = R"(R"()")";     // ERROR
                           ^
                           ;
2 errors generated.

R"()"

R"(R")")"
     ^^

Any character (or set of characters) will do:

const char *s7 = R"x(R"()")x";   // R"()"

Non-static Data Member Initializers (N2756)

With C++11 and later, you can now initialize members directly in the class definition. This is a welcomed addition that other languages (such as Java and D) have had already. The concept is easy to understand, so let's look at an example.

// Global function
int getnumber()
{
  return 42;
}

class A
{
  public:
    A() : b{7, 8, 9} // initialized by member initializer list
    {
        // Assignment, not initialization (OK, c is non-const)
      for (int i = 0; i < 3; i++)
        c[i] = i;
    }

    A(int x) : i(x), b{x, x, x}
    {
      // c is left uninitialized
    }

    void print()
    {
      cout << i << endl;
      cout << j << endl;
      cout << k << endl;
      cout << d << endl;
      for (auto it : v)
        cout << it << " ";
      cout << endl;
      for (auto it : a)
        cout << it << " ";
      cout << endl;
      for (auto it : b)
        cout << it << " ";
      cout << endl;
      for (auto it : c)
        cout << it << " ";
      cout << endl;
    }

  private:
    int i = 5;             // Member initialization
    int i2 {6};            // Member initialization (New in C++11)
    int i3 = {7};          // Member initialization
    int i4(8);             // This syntax won't work here. *See note below

    int j = getnumber();   // Member initialization (calls member function)
    int k = ::getnumber(); // Member initialization (calls global function)
    double d = 3.14;       // Member initialization

    vector<int> v{1, 2, 3};   // Member initialization (vector constructor)

    const int a[3] {0, 0, 0}; // const can be initialized here
    const int b[3];           //   or using the member initializer list in the constructor
    int c[3];                 // Non-const can be assigned in the constructor

    // private member function
    int getnumber()
    {
      return 32;
    }
};

• ^*According to Stroustrup's The C++ Programming Language, 4th Edition, section 17.4.4 - "For pretty obscure technical reasons related to parsing and name lookup, the {} and = initializer notations can be used for in-class member initializers, but the () cannot."
• The benefit of this is more obvious when you have multiple constructors that all need to initialize the private members.
• N2756 Non-static data member initializers
• In-class member initializers from Stroustrup's web site.

Trailing Return Types (N3276)

I'm going to introduce some new syntax using trivial examples. However, these techniques should never be used for trivial functions, as they cause more problems than they solve. Actually, they don't solve anything, they just create problems. But, before I show you the advanced reasons for using these techniques, I want you to understand what's going on.

int Add(int a, int b)
{
  return a + b;
}

auto Add(int a, int b) -> int
{
  return a + b;
}

foo(int, int, int) -> long;
foo(const char *) -> std::string;

The primary reason for this was to help deduce returns from templated functions:

template <typename T, typename U>
auto Add(T a, U b) -> decltype(a + b)
{
  return a + b;
}

int i1 = 5, i2 = 6;
double d1 = 2.72, d2 = 3.14;

cout << Add(i1, i2) << endl; // return type is int
cout << Add(d1, d2) << endl; // return type is double
cout << Add(i1, d2) << endl; // return type is double

template <typename T, typename U>
decltype(a + b) Add(T a, U b)
{
  return a + b;
}

error: use of undeclared identifier 'a'
decltype(a + b) Add(T a, U b) ->
         ^
error: use of undeclared identifier 'b'
decltype(a + b) Add(T a, U b) ->
             ^

auto Add(int a, int b)
{
  return a + b;
}

template <typename T, typename U>
auto Add(T a, U b)
{
  return a + b; // The compiler figures out the return type
}

template <typename T, typename U>
auto max(T a, U b)
{
  if (a > b)
    return a;
  else
    return b; // a and b can be different types
}

cout << max(1, 2.0) << endl; // Call max with different types

error: 'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement
    return b;
    ^

• The primary motivation for this was to help template functions deduce different return types. (It just happens to work with non-template functions, as well.)
• Another motivation was for lambda expressions, where deducing the return types can be quite complex.
• Using auto for functions that have a fixed return type, introduces problems:
• Putting the prototype in a header is meaningless:

auto SomeFunc(); // Not enough information for the compiler.

• It's useless to a programmer as well as there isn't enough information. Now the programmer is forced to find the documentation and read it. Good luck with that! (The source code may not even be available, either.)
• Speaking of documentation, automatic documentation generators (e.g. Doxygen) won't be able to figure out the return type either, so even if there were documentation, it wouldn't have that information.
• Should I go on?
• Bottom line: If you're writing template functions with templated return types or writing lambda functions, you can use it. Otherwise, don't. Just. Don't.

__func__ Predefined Identifier (N2340)

void SomeFunction()
{
  cout << "Function name is: " << __FUNCTION__ << endl; // Old non-standard extension
}

Function name is: SomeFunction

cout << "In function: " << __func__ << endl; // The name of the function
cout << "    in file: " << __FILE__ << endl; // The name of the C++ file
cout << "    at line: " << __LINE__ << endl; // The current line number
cout << "         on: " << __DATE__ << endl; // The current date
cout << "         at: " << __TIME__ << endl; // The current time

In function: f13
    in file: cpp14.cpp
    at line: 991
         on: Apr 16 2018
         at: 14:01:20

It is unfortunate that all of the other similar techniques use all uppercase names. This is due to the fact that __func__ is implemented by the compiler and the others are expanded by the pre-processor. To "prove" this, I just compiled the code with the -E option (show the pre-processed code):

cout << "In function: " << __func__ << endl;
cout << "    in file: " << "cpp14.cpp" << endl;
cout << "    at line: " << 991 << endl;
cout << "         on: " << "Apr 16 2018" << endl;
cout << "         at: " << "14:03:40" << endl;

The purpose of __func__ is to help with diagnostic messages at runtime. You can easily build up an informative error message with the aid of these features:

cout << "An out-of-range error has occurred in file " << __FILE__
     << " at line " << __LINE__
     << " (in function " << __func__ << ").\n"
     << "The software was last compiled on " << __DATE__
     << " at " << __TIME__ << ".\n";

An out-of-range error has occurred in file cpp14.cpp at line 997 (in function f13).
The software was last compiled on Apr 16 2018 at 14:05:14.

• No name decorating (mangling) is done on the names.
• Overloaded functions and templated functions just print out the function name. There is no way to disambiguate them.
• Lambdas expand to:

  operator()
  

  which makes sense (if you understand lambda expressions).

Delegating Constructors (N1986)

Constructors are generally the place to initialize members of the class. It's not uncommon to have more than one constructor, so this "initialization code" needed to be duplicated in several places. Or, better yet, this "duplicated" code was factored out into a separate init(...) method that was then called from each constructor:

class C1
{
  public:
      // Default constructor
    C1() 
    {
      init(); // Do other setup code...
    }

      // Single-argument conversion constructor
    C1(double x) : d_(x)
    {
      init(); // Do other setup code...
    }

      // Non-default constructor
    C1(int a, int b, int c, double d) : a_(a), b_(b), c_(c), d_(d)
    {
      init(); // Do other setup code...
    }

  private:
    int a_, b_, c_;
    double d_;

    void init()
    {
       // Do a lot of setup stuff
    }
};

With delegating constructors, we can just call the "main" constructor that will do all of the initialization:

class C2
{
  public:
      // Default constructor
    C2() : C2(0, 0, 0, 0.0) // delegate to other constructor
    {
    }

      // Single-argument conversion constructor
    C2(double x) : C2(0, 0, 0, x) // delegate to other constructor
    {
    }

      // Non-default constructor
    C2(int a, int b, int c, double d) : a_(a), b_(b), c_(c), d_(d) // maybe more initialization here...
    {
      // Do a lot of setup stuff
    }

  private:
    int a_, b_, c_;
    double d_;
};

• If you call another constructor (delegate), that's all you can do. You can't do any other initialization:

  C2() : C2(0, 0, 0, 0.0), a_(0) // Can't do both
  {
  }
  

  Error from Clang:

  error: an initializer for a delegating constructor must appear alone
      C2() : C2(0, 0, 0, 0.0), a_(0) // Can't do both
             ^~~~~~~~~~~~~~~~  ~~~~~
  1 error generated.
  

• In this small example there may be little to be gained by using a delegate constructor. You have to imagine that the class (and corresponding constructors) is more complex than this simple, contrived example pretends to be. However, the points made should be clear.

noexcept ()

int lookup(const vector<int>& v, int index) throw(std::out_of_range)
{
  return v.at(index); // This method does range checking
}

throw (std::out_of_range)

This is sample code that calls the function above:

vector<int> v {10, 20, 30};
try
{
  cout << lookup(v, 2) << endl; // Prints 30
  cout << lookup(v, 5) << endl; // Throws a std::out_of_range exception
}
catch (const std::out_of_range& ex)
{
  cout << ex.what() << endl; // Display details about the exception
}

30
vector::_M_range_check: __n (which is 5) >= this->size() (which is 3)

// foo1 will throw no exceptions
int foo1() throw();

// foo2 will only throw std::out_of_range or std:bad_alloc
int foo2() throw (std::out_of_range, std::bad_alloc);

// foo3 may thrown any exception
int foo3();

1. foo1 - An empty exception specification may not throw any exception.
2. foo2 - A non-empty exception specification may only throw the exceptions listed.
3. foo3 - A missing exception specification may throw any exception.

// Function will not throw an exception
void foobar1() noexcept(true)
{
  // do something safe
}

// Function may throw an exception
void foobar2() noexcept(false)
{
  // do something possibly unsafe
}

// foobar3 may throw an exception only if foobar2 may throw an exception
void foobar3() noexcept(noexcept(foobar2()))  
{
  foobar2(); // call possibly unsafe function
}

// foobar4 will not throw an exception (protects unsafe call to foobar2)
void foobar4() noexcept(true)  
{
  try
  {
    foobar2(); // call possibly unsafe function
  }
  catch (.../* whatever foobar2 throws */)
  {
    // do something with the exception
  }

  // safely continue excecuting...
}

cout << boolalpha;
cout << "  noexcept(true)? " << noexcept(true) << endl;
cout << " noexcept(false)? " << noexcept(false) << endl;
cout << "foobar1 noexcept? " << noexcept(foobar1()) << endl;
cout << "foobar2 noexcept? " << noexcept(foobar2()) << endl;
cout << "foobar3 noexcept? " << noexcept(foobar3()) << endl;
cout << "foobar4 noexcept? " << noexcept(foobar4()) << endl;

  noexcept(true)? true
 noexcept(false)? true
foobar1 noexcept? true
foobar2 noexcept? false
foobar3 noexcept? false
foobar4 noexcept? true

void foobar() noexcept(true) // explicit
void foobar() noexcept       // implicit

Q: "Do you want me to not turn the lights off?"
A: Yes, please do not turn them off.

Q: "Do you want me to turn the lights off?"
A: No, please do not turn them off.

Notes:

• Destructors are now noexcept by default unless a member or base class has a destructor marked as noexcept(false).
• C++11 (and later) refers to the old style throw(...) as dynamic exception specifications and the newer one as just exception specifications.
• If you are using certain STL containers and you want the significant increase in performance via move constructor/assignment, you must mark those methods as noexcept or copying will be done instead. According to the clang documentation:
  • "Move constructors of all the types used with STL containers, for example, need to be declared noexcept. Otherwise STL will choose copy constructors instead. The same is valid for move assignment operations."
• Unlike the old-style dynamic exception specifications, you can't overload on the new exception specifications. This is illegal:

  void foobar() noexcept(true)
  void foobar() noexcept(false) // redefinition
  

Generalized constexpr (N2235)

const int i = getvalue1(); // Sets i at runtime. Must be initialized because it's const
int array[i];              // Illegal, i isn't known at compile time. 

Here are 4 functions for the examples below:

constexpr int ipower(int base, int exponent) { int p = 1; for (int i = 0; i < exponent; i++) p *= base; return p; }		constexpr int squared(int x) { return x * x; }
int getvalue1() { return 10; }		constexpr int getvalue2() { return 20; }

int a1[getvalue1()];            // Illegal, getvalue1() isn't known at compile-time
int a2[getvalue2()];            // OK, constant expression

const int v1 = getvalue1();     // OK, but v1 isn't known at compile-time (not constexpr)
int a3[v1];                     // Illegal

const int v2 = getvalue2();     // OK, but v2 is not constexpr
int a4[v2];                     // Illegal

constexpr int v3 = getvalue1(); // Illegal, can't initialize v3 with non-constexpr

constexpr int v4 = getvalue2(); // OK
int a5[v4];                     // OK

int a6[squared(5)];             // OK
cout << sizeof(a6) << endl;     // prints 100 (25 * 4)

int a7[squared(getvalue1())];   // Illegal, getvalue1 is not constexpr
int a8[squared(getvalue2())];   // OK
cout << sizeof(a8) << endl;     // prints 1600 (400 * 4)

int a9[ipower(2, 3)];            // OK
cout << sizeof(a9) << endl;     // prints 32 (8 * 4)

• Functions that are specified as constexpr must be seen by the compiler and will be inlined at the call.
• This means that constexpr functions are usually implemented in header files. (They are implicitly inlined).
• Member functions (including constructors and trivial destructors, with some restrictions) can be constexpr.
• The original C++11 specifications for constexpr required functions to contain exactly one line:

  return some-expression;
  

  But C++14 allows the function to be more complex. How complex? The standard says something along the lines of "The functions must be sufficiently simple...". This implies that if the functions themselves call other functions, those functions must also be declared constexpr.
• Declaring an object as constexpr implies const

  constexpr int v4 = getvalue2(); // OK
  v4 = 5;                         // Illegal, v4 is implicitly const 
  

• Some other compile-time constant expressions required by the compiler include:
  • array bounds
  • expressions in case-statements
  • initialization of enumerators in enumeration definitions
  • values specified for non-type template parameters
• There is a lot more to know about constexpr and you can read more about it here: Stroustrup's C++11FAQ and Generalized Constant Expressions

Template Aliases (N2258)

typedef unsigned char BYTE;
typedef short int FAST_INT;
typedef float CURRENCY;
typedef unsigned char * PCHAR;

BYTE next, previous;    // For scanning bytes in memory
CURRENCY tax, discount; // To calculate total price
PCHAR inbuf, outbuf;    // To manipulate strings

using BYTE = unsigned char;
using FAST_INT = short int;
using CURRENCY = float;
using PCHAR = unsigned char *;

typedef vector<int> MyVectorI;    // MyVectorI is an alias for vector of int
typedef vector<string> MyVectorS; // MyVectorS is an alias for vector of string
typedef vector<double> MyVectorD; // MyVectorD is an alias for vector of double

MyVectorI mvi; // vector of int
MyVectorS mvs; // vector of string
MyVectorD mvd; // vector of double

template <typename T>
typedef vector<T> MyVectorOfT;

error: a typedef cannot be a template
typedef vector MyVectorOfT;
                  ^
1 error generated.

template <typename T>
using MyVector = vector<T>; // MyVector is an alias for a vector anything

MyVector<int> vi2;    // vector of int
MyVector<string> vs2; // vector of string
MyVector<double> vd2; // vector of double

template <typename T>
using MyVectorT = vector<list<T>>; // MyVectorT is an alias for a vector of list of anything

MyVectorT<int> vli;    // vector of list of int
MyVectorT<string> vls; // vector of list string
MyVectorT<double> vli; // vector of list of double

template <typename T, typename Alloc = std::allocator<T>>
using MyIter = typename vector<list<T, Alloc>>::iterator;

MyIter<string> it1;       // An iterator on a vector of lists of string and the default allocator
MyIter<Foo, MyAlloc> it2; // An iterator on a vector of lists of Foo and custom allocator

Notes:

• template alias at Stroustrup's site.

Lambdas (N2927)

Long Long Data Type (N1811)

There are two situations where I think this type will be useful:

1. The long long type allows implementations to use more than 64-bits, possibly 128-bits, for an integral type.
2. It allows Microsoft's code to work with the rest of the world. Microsoft's Windows OS is currently the only popular 64-bit system that still uses 32-bits for long integers. Programmers on Windows should use long long if they want a 64-bit data type. (64-bit data models shows the sizes of data types on common systems.)

Type	Bytes	Also called	Range of values (Binary)	Range of values (Decimal)
signed long int	8	long long int signed long	-263 to 263 - 1	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
unsigned long int	8	unsigned long	0 to 264 - 1	0 to 18,446,744,073,709,551,615
signed long int	4	long long int signed long	-231 to 231 - 1	-2,147,483,648 to 2,147,483,647
unsigned long int	4	unsigned long	0 to 232 - 1	0 to 4,294,967,295

long long ll = 12345LL;            // LL for (signed) long long
unsigned long long ull = 12345ULL; // ULL for unsigned long long

cin >> ll;
cin >> ull;

cout << ll << endl;
cout << ull << endl;

scanf("%lli", &ll);    // Can also use %lld
scanf("%llu", &ull);

printf("%lli\n", ll);  // Can also use %lld
printf("%llu\n", ull);

Default and Deleted Functions (N2346)

Default Functions:

In C++, when you create a class, by default you get these member functions for free:

1. A default constructor (that does nothing)
2. A destructor (that does nothing)
3. A copy constructor (that does memberwise copy)
4. A copy assignment operator (that does memberwise assignment)

class Foo4
{
  public:
    friend ostream& operator<<(ostream& os, const Foo4& rhs);
  private:
    int a = rand() % 10;
    int b = rand() % 10;
};

ostream& operator<<(ostream& os, const Foo4& rhs)
{
  os << rhs.a << ", " << rhs.b;
  return os;
}

void f23()
{
  Foo4 f1;     // default constructor (compiler-generated)
  Foo4 f2;     // default constructor (compiler-generated)
  Foo4 f3(f1); // copy constructor (compiler-generated)

  cout << "f1: " << f1 << endl; // f1: 3, 6
  cout << "f2: " << f2 << endl; // f2: 7, 5
  cout << "f3: " << f3 << endl; // f3: 3, 6

  f1 = f2;     // copy assignment (compiler-generated)
  cout << "f1: " << f1 << endl; // f1: 7, 5

} // destructor (compiler-generated) called for f1, f2, f3

class Foo4
{
  public:
    Foo4(int i, int j) : a(i), b(j) {} // non-default constructor
    friend ostream& operator<<(ostream& os, const Foo4& rhs);
  private:
    int a = rand() % 10;
    int b = rand() % 10;
};

Foo4 f1;     // default constructor

error: no matching constructor for initialization of 'Foo4'
  Foo4 f1;     // default constructor

Foo4 f4(1, 2); // non-default constructor
cout << "f4: " << f4 << endl; // f4: 1, 2

class Foo4
{
  public:
    Foo4() {} // default constructor (programmer-implemented, does nothing)
    Foo4(int i, int j) : a(i), b(j) {}
    ...
};

With C++11, you can just instruct the compiler to generate the default constructor instead of the programmer. You do this by appending = default to the default constructor's declaration:

class Foo4
{
  public:
    Foo4() = default; // compiler will generate this
    Foo4(int i, int j) : a(i), b(j) {}
    ...
};

Another place where you might want to use this technique is with virtual destructors. By default, compiler-generated destructors are not virtual. If you're planning on using your class as a base class, you will likely need your destructor to be virtual, even if your destructor does nothing at all. In pre-C++11 days, the programmer would have to implement an empty destructor so that it could be marked virtual:

class Foo4
{
  public:
    virtual ~Foo4() {} // empty destructor to get virtual behavior
    ...
};

class Foo4
{
  public:
    virtual ~Foo4() = default // compiler will generate the virtual destructor
    ...
};

Deleted Functions

With the discussion of default functions above, the point was to force the compiler to generate some methods that otherwise would not have been generated. But, what if we want the opposite behavior? Meaning, you don't want the compiler to generate certain functions for you? With classes, the function that comes to mind is the copy constructor.

Most of the time, you need to be able to make copies of objects. However, there are situations where you don't want to allow the user to make copies. In old C++, the way that the programmer made sure that no copies were made was to declare the copy constructor in the private section of the class:

class Foo4
{
  public:
    ...
  private:
    Foo4(const Foo4& rhs); // copy constructor, do not implement!
    int a = rand() % 10;
    int b = rand() % 10;
};

Foo4 f3(f1); // call copy constructor

error: calling a private constructor of class 'Foo4'
  Foo4 f3(f1); // copy constructor (compiler-generated)
       ^

class Foo4
{
  public:
    Foo4(const Foo4& rhs) = delete; // copy constructor won't be generated
    ...
};

error: call to deleted constructor of 'Foo4'
  Foo4 f3(f1); // copy constructor (compiler-generated)
       ^  ~~
note: 'Foo4' has been explicitly marked deleted here
    Foo4(const Foo4&) = delete;
    ^

friend ostream& operator<<(ostream os, const Foo4& rhs);

error: call to deleted constructor of 'ostream' (aka 'basic_ostream')
  cout << "f1: " << f1 << endl; // f1: 3, 6
  ^~~~~~~~~~~~~~

Preventing copies has been a popular reason to put the copy constructor declaration in the private section, and now you can just mark it as deleted. But, = delete doesn't need to be used in a class. Any function can be marked deleted. At first glance, that seems absurd. If you don't want a user to call a certain non-member function, then don't create it!

However, consider this function:

bool isEven(long value)
{
  if (value % 2)
    return false;
  else
    return true;
}

long j = 8;
float f = 8.0F;
double d = 8.0;
cout << boolalpha <<  isEven(j) << endl; // long, OK (true)
cout << boolalpha <<  isEven(f) << endl; // float to long, OK (true)
cout << boolalpha <<  isEven(d) << endl; // double to long, (true)

bool isEven(float) = delete;  // declaration only
bool isEven(double) = delete; // declaration only

 error: use of deleted function 'bool isEven(float)'
   cout << boolalpha <<  isEven(f) << endl; // float to long, OK
                                 ^
note: declared here
 bool isEven(float) = delete;
      ^
 error: use of deleted function 'bool isEven(double)'
   cout << boolalpha <<  isEven(d) << endl; // double to long, OK
                                 ^
note: declared here
 bool isEven(double) = delete;
      ^

Information from Stroustrup's site.

First, let's compare the syntax of std::array with the built-in static array. You can also assume that I have a function that can print a static array and another function that can print out a std::array. I'll show you how to implement those later.

To use std::array, you must include this:

#include <array>

array<double, 5> ar; // ar represents a static array of 5 doubles, e.g. double ar[5];

Just like with built-in arrays, without proper initialization, we get undefined values:

array<int, 3> a1; // undefined values: 32615, 1876, 3
int s1[3];        // undefined values: -891498544, 32767, 6299136

array<int, 3> a2{}; // default initialized to 0 (default constructor)
int s2[3] = {};     // default initialized to 0 (Not legal in C, use {0})

array<int, 3> a3{1, 2, 3}; // OK
int s3[3] = {1, 2, 3};     // OK

array<int, 3> a4{1, 2, 3, 4}; // ERROR: too many initializers
int s4[3] = {1, 2, 3, 4};     // ERROR: too many initializers

array<int> a5{1, 2, 3, 4}; // ERROR: no size specified (compiler won't help here) 
int s5[] = {1, 2, 3, 4};   // OK: compiler sets size to 4 from initializers

In function 'void f1()':
error: wrong number of template arguments (1, should be 2)
   array a5{1, 2, 3, 4}; // ERROR: no size specified
            ^

array<int, 3> a4{1, 2}; // Too few initializers, rest are 0
int s4[3] = {1, 2};     // Too few initializers, rest are 0

Ok, so now that we've got all of the syntax out of the way you're probably saying, "So what?!? This doesn't give us anything more than what the built-in arrays give us." And you would be right.

In fact, built-in arrays actually give us more than what we have now because we can't do this with std::array:

int s5[] = {1, 2, 3, 4};    // The compiler will figure out the size.
std::array ar {1, 2, 3, 4}; // Error! Must specify type and size

  // New in C++17. Class Template Argument Deduction
  // ar is deduced as std::array<int, 4>
std::array ar {1, 2, 3, 4}; 

array<int> ar5 {1, 2, 3}; // ERROR, too few template arguments

array         ar1 {1, 2, 3}; // OK, size is 3, values: 1,2,3
array<int, 3> ar2 {1, 2, 3}; // OK, size is 3, values: 1,2,3
array<int, 5> ar3 {1, 2, 3}; // OK, size is 5, values: 1,2,3,0,0
array<int, 5> ar4;           // OK, size is 5, values are all undefined
array<int, 5> ar5 {};        // OK, size is 5, values: 0,0,0,0,0
array<int, 2> ar6 {1, 2, 3}; // ERROR, too many initializers
array<int>    ar7 {1, 2, 3}; // ERROR, too few template arguments
array         ar8;           // ERROR, can't deduce template parameters

BTW, class argument template deduction can be a pretty complex thing, but you don't have to understand any of it to use it correctly with std::array. For more information, follow these links. But be aware, it is not for the faint-of-heart!

Template argument deduction for class templates (P0091R3).
Filling holes in Class Template Argument Deduction (P1021R5).

Ok, so the first improvement we have over built-in arrays is that a std::array knows its size. This means that we can query the array at any time in the program to find out the size. This is especially useful when we pass the std::array to a function. With built-in arrays, we can only pass a pointer to the first element to the function. We have to pass a second parameter (the size) to the function and this can be a source of bugs if the incorrect size is passed. We don't have to do this with std::array.

Here's the classic function to print any array of integers:

void print(const int *arr, int size)
{
  for (int i = 0; i < size; i++)
    std::cout << arr[i] << std::endl;
}

void print3ints1(const std::array<int, 3>& arr)
{
  for (int i = 0; i < 3; i++)
    std::cout << arr[i] << std::endl;
}

void print3ints2(const std::array<int, 3>& arr)
{
  for (size_t i = 0; i < arr.size(); i++)
    std::cout << arr[i] << std::endl;
}

void print3ints3(const std::array<int, 3>& arr)
{
  for (int i : arr)
    std::cout << i << std::endl;
}

array<int, 2> a7{1, 2};             // array of 2 ints
array<double, 3> a8{1.1, 2.2, 3.3}; // array of 3 doubles

void print2ints(const std::array<int, 2>& arr)
{
  for (int i : arr)
    std::cout << i << std::endl;
}

void print4doubles(const std::array<double, 4>& arr)
{
  for (double d : arr)
    std::cout << d << std::endl;
}

template <typename T, size_t size>
void print(const std::array<T, size>& arr)
{
  for (const T& t : arr)
    std::cout << t << std::endl;
}

• The std::array knows its size - With built-in arrays, we always had to store the size in some other variable and pass it as a separate argument to a function (and hope that the value is accurate). Since std::array is a class, its size is known to each object. Just call the size() method. (The size may not even be stored in the object!)
• Bounds checking - Because it knows its size, bounds checking can be performed when using the at method (similar to std::vector). The subscript operator is supported, of course, but does not do any bounds-checking.
• Has begin() and end() members to work well with the standard algorithms (e.g. sort)
• You can assign one std::array to another. With a built-in array, assignment is illegal. You must perform some kind of looping to copy one element at a time.
• You can return a std::array from a function. With a built-in array, you can only return a pointer to the first element.
• A std::array doesn't decay into a pointer like built-in arrays do, which is a well-known source of confusion, especially with novice programmers. (However, if you need it, you can get the pointer with something like this: &array[0]).
• Keep in mind that there is no overhead at all when using a std::array in place of a built-in array, so you are not incurring any performance penalty.

• The size of the std::array is known at compile time, so there is zero runtime overhead to create one. std::vector, on the other hand, must be dynamically allocated at runtime, which may incur a significant overhead.
• A std::vector has additional members which require more memory. A std::array contains only the static array itself.
• A std::vector can grow and shrink at runtime to accommodate more/less elements. The size of a std::array is fixed and can't grow or shrink.
• A std::array requires the type being stored to have a default constructor (if not given explicit initializers). A std::vector does not.
• Because the size of a std::array must be known at compile time, it's less flexible than a std::vector (but more efficient). Note that there is no push_back, insert, or erase/remove methods because the array cannot grow or shrink.

• If you know the size (number of elements) that will be stored at compile time and that number will not change at runtime, use a std::array.
• If you don't know the number of elements at compile time, or the size will change at runtime, use a std::vector.

Structured Bindings (P0144R2)

Note: This was added in C++ 17 so, depending on the version of your compiler, you may need to use std=c++17 for these examples to work.

First, let's look at how we would do things without structured bindings. Suppose we have this very simple structure:

struct Student
{
  int age;
  double gpa;
};

Output:

  42, 3.14

Although this is all fine and good, it can become tedious to do this a lot, especially if there are several members of the structure. Enter structured bindings:

  // x is an int and gets the value 42
  // y is a double and gets the value 3.14
  // x and y are copies of the structure members
auto [x, y] = student;
cout << "x is " << x << ", y is " << y << endl;
cout << "student.age is " << student.age << ", student.gpa is " << student.gpa << endl;

x is 42, y is 3.14
student.age is 42, student.gpa is 3.14

int [x, y] = struct2ints; // assume the structure only contains 2 integers

error: structured binding declaration cannot have type 'int'
   int [x, y] = struct2ints; // assume the structure only contains 2 integers
       ^~~~~~
note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'

This is another reason why the auto keyword was (re)introduced into the language. The syntax would be unnecessarily complicated if each structure member had a different type, as is the case with most structures.

  // Modifying x and y does not affect s.age or s.gpa in any way
x = 10;
y = 3.75;

cout << "x is " << x << ", y is " << y << endl;
cout << "student.age is " << student.age << ", student.gpa is " << student.gpa << endl;

x is 10, y is 3.75
student.age is 42, student.gpa is 3.14

  // rx and ry are references
auto& [rx, ry] = student;

rx = 10;            // Modifies rx and s.age (they refer to the same object)
student.gpa = 3.75; // Modifies s.gpa and ry (they refer to the same object)

cout << "rx is " << rx << ", ry is " << ry << endl;
cout << "student.age is " << student.age << ", student.gpa is " << student.gpa << endl;

rx is 10, ry is 3.75
student.age is 10, student.gpa is 3.75

cout << "         Address of rx is " << &rx << endl;
cout << "Address of student.age is " << &student.age << endl;
cout << "         Address of ry is " << &ry << endl;
cout << "Address of student.gpa is " << &student.gpa << endl;

         Address of rx is 0x7fff8bb5c860
Address of student.age is 0x7fff8bb5c860
         Address of ry is 0x7fff8bb5c868
Address of student.gpa is 0x7fff8bb5c868

auto [x] = student;       // Error, not enough variables
auto [i, j, k] = student; // Error, too many variables

error: only 1 name provided for structured binding
   auto [x] = student;
        ^~~
note: while 'Student' decomposes into 2 elements

error: 3 names provided for structured binding
   auto [i, j, k] = student;
        ^~~~~~~~~
note: while 'Student' decomposes into 2 elements

Structured bindings provide a cleaner syntax to accomplish that:

A function that needs to return a structure:

Student create_student(int age, double gpa)
{
  return Student {age, gpa};
}

  // age is 42, gpa is 3.14
auto [age, gpa] = create_student(42, 3.14);

Using structured bindings with static arrays

This is fairly straight-forward:

  // sizeof(array) is known at compile-time
int array[] {1, 2, 3};

  // a is 1, b is 2, c is 3
auto [a, b, c] = array;

However, this limitation is easily worked-around by using std::array instead of a static array:

std::array<int, 3> foo(const std::array<int, 4>& array)
{
    // The variables contain copies of the 4 elements in array
  auto [a, b, c, d] = array;

    // Create an array with the first 3 elements above and return it
  return std::array<int, 3> {a, b, c};
}

std::array<int, 3> retval = foo(std::array{1, 2, 3, 4});

  // x is 1, y is 2, z is 3
auto [x, y, z] = retval;

Also, notice how in function foo above there is no warning for the unused, but set value of d. This is because it may (often) be the case that you don't need all of the variables, yet you still must bind something to each element.

I don't believe the standard says anything about the warnings being emitted, but both g++ and clang++ do not emit a warning. See section 3.8 of this document p0144r2.pdf for more insight.

Personally, I'd like to see this be allowed in the future:

  // sizeof(array) is known at compile-time
int array[] {1, 2, 3};

  // Only extract the first two elements (ignore the third element) 
auto [a, b] = array;

  // sizeof(array) is known at compile-time
int array[] {1, 2, 3};

  // Only extract the first and third element (ignore the second)
auto [a, ,b] = array;

There are many other things you can do with structure bindings (e.g. bit-fields, user-defined types, etc.) that are also beyond the scope of this introduction. Search the web for more details.

Using structured bindings with tuples

We've already had the ability to return multiple values from a function via a structure of some sort. However, the need to create names/definitions for all of the various structures that we would want to return will become tedious, not to mention polluting the namespace with many single-use structures. The solution is now to use tuples. An example will help clarify.

Suppose we want to calculate the quadratic formula:

There are various ways to address all of these concerns, e.g., returning error codes, passing pointers (to be used as out parameters), throwing exceptions, etc. We are going to solve the problems with tuples and structured bindings together.

First, here is the function that will take 3 inputs (a, b, c) and calculate the values using the quadratic formula:

// Error codes for quadratic formula
enum MATHERR {ERR_NONE, ERR_NEGSQRT, ERR_DIVZERO};

// A function that takes 3 doubles and returns a tuple (struct) that consists of
// the two calculated values (roots) and a (possible) error code
std::tuple<double, double, MATHERR> quadratic(double a, double b, double c)
{
    // Prevent dividing by zero
  if (a == 0)
    return {0.0, 0.0, ERR_DIVZERO}; // Construct tuple with error code and return it

    //  b^2 - 4ac
  double discriminant = b * b - 4 * a * c;

    // Prevent taking the square root of a negative number
  if (discriminant < 0)
    return {0.0, 0.0, ERR_NEGSQRT}; // Construct tuple with error code and return it

    // All safe operations now
  double pos_numerator = -b + std::sqrt(discriminant);
  double neg_numerator = -b - std::sqrt(discriminant);
  double denominator = 2 * a;

    // Return 3 pieces of information, no errors
  return {pos_numerator / denominator, neg_numerator / denominator, ERR_NONE};
}

void f36()
{
    // Setup some test values
  double a = -3.1;
  double b = 5.2;
  double c = 1.3;

  cout << "Applying quadratic formula to a, b, c (" 
       << a << ", " << b << ", " << c << ")" << endl;

    // Call the function and retrieve 3 results
  auto [root1, root2, errcode] = quadratic(a, b, c);

    // Check if there were any errors
  if (errcode == ERR_NONE)
    cout << "Roots are: " << root1 << ", " << root2 << endl;
  else if (errcode == ERR_DIVZERO)
    cout << "Divide by zero." << endl;
  else if (errcode == ERR_NEGSQRT)
    cout << "Sqrt of negative." << endl;
  else
    cout << "Unknown error." << endl; // shouldn't happen
}

Applying quadratic formula to a, b, c (-3.1, 5.2, 1.3)
Roots are: -0.220908, 1.89833

Applying quadratic formula to a, b, c (1, 2, 3)
Sqrt of negative.

Applying quadratic formula to a, b, c (0, 2, 3)
Divide by zero.

Applying quadratic formula to a, b, c (1, 4, 3)
Roots are: -1, -3

void f37()
{
    // Setup some values
  double a = -3.1;
  double b = 5.2;
  double c = 1.3;

  cout << "Applying quadratic formula to a, b, c (" 
       << a << ", " << b << ", " << c << ")" << endl;

    // Switch on the error code using select statement initialization (P0305R1)
  switch (auto [root1, root2, errcode] = quadratic(a, b, c); errcode)
  {
    case ERR_NONE:
      cout << "Roots are: " << root1 << ", " << root2 << endl;
      break;
    case ERR_DIVZERO:
      cout << "Divide by zero." << endl;
      break;
    case ERR_NEGSQRT:
      cout << "Sqrt of negative." << endl;
      break;
    default:
      cout << "Unknown error." << endl;
  }
}

Generalized Attributes (N2761)

The concept of attributes has been around for a while, but has never been standardized. This means that each compiler had its own way of doing things. One compiler's syntax may be incompatible with another compiler's syntax. Now, C++ has standardized (some of) them to make writing portable code much easier.

Example #1: Ignoring the return value from a function. (Preventing simple mistakes.)

Many of you probably remember using printf to send text output to the display when programming in C (and C++). However, how many of you have ever used the return value from printf? I'd argue that many people don't even know what is returned. History has shown me that most students either a) don't know it returns anything or b) think that printf returns an error code of some sort. Actually, it returns the number of characters that were printed. In almost every use of printf, we don't care about the return value, so we simply ignore it, and this is all fine, safe, and legal.

However, for some functions, if you ignore the return value, the results can be catastrophic. Take for example malloc, which dynamically allocates memory and returns a pointer to that memory. If you ignore the returned pointer, then you have a memory leak. There is absolutely no way around that:

Correct usage (safe)	Incorrect usage (unsafe)
char *p = (char*)malloc(128); // allocate 128 bytes // use the memory ... free(p); // release the memory	malloc(128); // allocate 128 bytes // Can't use the memory // Can't free the memory (leak)

warning: ignoring return value of 'void* malloc(size_t)', declared
         with attribute warn_unused_result [-Wunused-result]
  537 |   malloc(128); // allocate 128 bytes
      |   ~~~~~~^~~~~

Here's a concrete example: Anyone who has every written a linked-list structure knows that they often have to dynamically allocate memory for the nodes in the list and may create a helper function to do so:

Node structure	Helper function
// Node for a singly linked list struct Node { int data; // arbitrary data in the node Node *next; // next node in the list };	// helper function to create a Node (no error handling) Node *MakeNode(int value) { Node *node = new Node; // allocate memory node->data = value; // assign the data node->next = nullptr; // set next to NULL return node; // return memory to the caller }

Typical use (safe):	Incorrect use (unsafe):
// call helper to allocate node Node *p = MakeNode(42); // ... delete p; // done with the node	// call helper to allocate node // but ignore the returned value // (memory leak) MakeNode(42);

// helper function to create a Node (no error handling)
[[nodiscard]] Node *MakeNode(int value)
{
  Node *node = new Node; // allocate memory
  node->data = value;    // assign the data
  node->next = nullptr;  // set next to NULL

  return node; // return memory to the caller
}

MakeNode(42); // Ignore important return value  

warning: ignoring return value of 'Node* MakeNode(int)', declared with attribute nodiscard [-Wunused-result]
   MakeNode(42);
   ~~~~~~~~^~~~
note: declared here
 [[nodiscard]] Node *MakeNode(int value)
                     ^~~~~~~~

Example #2: Falling through a case in a switch statement. (Suppressing unwanted warnings.)

Many new C++ programmers forget to add a break statement in their switch statements and some compilers will warn about that because this is generally not what they wanted. However, sometimes it is exactly what the programmer intended and now there is an attribute that will suppress that warning:

Warnings emitted:	Warnings suppressed:
switch (year) { case 1: freshman++; case 2: sophomore++; printf("Found lower division student.\n"); break; case 3: junior++; case 4: senior++; printf("Found upper division student\n"); break; default: printf("Invalid year\n"); break; }	switch (year) { case 1: freshman++; [[ fallthrough ]]; // suppress fall through warning case 2: sophomore++; printf("Found lower division student.\n"); break; case 3: junior++; [[ fallthrough ]]; // suppress fall through warning case 4: senior++; printf("Found upper division student\n"); break; default: printf("Invalid year\n"); break; }

warning: this statement may fall through [-Wimplicit-fallthrough=]
       freshman++;
       ~~~~~~~~^~
note: here
     case 2:
     ^~~~
warning: this statement may fall through [-Wimplicit-fallthrough=]
       junior++;
       ~~~~~~^~
note: here
     case 4:
     ^~~~

switch (year)
{
  case 1: // No warning
  case 2: 
    lower++;
    printf("Found lower division student.\n");
    break;
  case 3: // No warning
  case 4: 
    upper++;
    printf("Found upper division student\n");
    break;
  default:
    printf("Invalid year\n");
    break;
}

These two attributes are just two of several that been added since C++11. This should give you some insight into what they can be used for. I suspect that we will see many more to come in the not-so-distant future.

Read more about attributes below:

• Attribute specifier sequence — Shows the list of standard attributes.
• General Attributes for C++ (N2761) — The detailed standards document.

Stricter Expression Evaluation Order (P0145R3)

For example, given the program below, the results are unspecified. Different compilers may give different results.

int f1() { cout << "f1" << endl; return 1; } int f2() { cout << "f2" << endl; return 2; } int f3() { cout << "f3" << endl; return 3; }

int main() { // add only int x = f1() + f2() + f3(); cout << "x is " << x << endl; // add and multiply int y = f1() + f2() * f3(); cout << "y is " << y << endl; return 0; }

Compiler #1: f1 f2 f3 x is 6 f1 f2 f3 y is 7

Compiler #2: f1 f2 f3 x is 6 f2 f3 f1 y is 7

With C++17, some operators are now required to evaluate their operands in a specified order, resulting in deterministic output from all compilers. One of those operators is the insertion (a.ka. output) operator: <<.

For example, given the functions above and this code:

int main() { // What is the output? cout << f1() << f2() << f3() << endl; return 0; }

Output #1: f3 f2 f1 123

Output #2: f1 1f2 2f3 3

Now, with C++17, all compilers will output like output #2. Incidentally, the compilers that I tested gave these outputs:

Compiler/Output #1	Compiler/Output #2
GNU g++ 4.8, 5, and 6 MS VS 12 MS VS 14 MS VS 19 (with default: c++14)	GNU g++ 7, 8, and 9 Clang 3.5, 3.8, 8 MS VS 19 (with /std:c++17)

int main() { try { cout << "Value is: " << somefn() << endl; } catch (int) { cout << "Exception thrown" << endl; } return 0; }

// This function may throw an exception int somefn() { // Do something here ... // If something goes wrong... throw 5; // Everything is fine return 5; }

Value is: 5

Output from pre-C++17 compiler:

Exception thrown

Output from C++17-compliant compiler:

Value is: Exception thrown

Notes:

• Order of evaluation - More details about it at cppreference.com.

Compiler support for C++:

• Clang's support for C++98, C++11, C++14, and C++1z.
• GCC's support for C++11 ,C++14, C++17, C++20, C++23, All.
• Microsoft's support for Modern C++.
• Additional compiler support for all modern versions.

• This is a quick-start book for experienced C++ programmers. It's only about 180 pages, so it really is just a brief overview. However, if you know C++, it's a good place to start. However, when I got this book a couple of years ago, there were a lot of typos in it, which could confuse new programmers.

  A Tour of C++: The C++11 standard allows programmers to express ideas more clearly, simply, and directly, and to write faster, more efficient code. Bjarne Stroustrup, the designer and original implementer of C++, thoroughly covers the details of this language and its use in his definitive reference, The C++ Programming Language, Fourth Edition.

• Written by Scott Meyers, this is a detailed-oriented book on some of the new (and difficult to understand) features in C++. Scott is very likely one of the most knowlegable C++ developers around and his books are always highly-rated. A must read for anyone that really wants all of the gory details.

  Effective Modern C++: Coming to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce (e.g., auto type declarations, move semantics, lambda expressions, and concurrency support). The challenge is learning to use those features effectively—so that your software is correct, efficient, maintainable, and portable. That's where this practical book comes in. It describes how to write truly great software using C++11 and C++14, i.e. using modern C++.

• Also written by Scott Meyers, this is a PDF of the new features of C++. They are probably best when you are reading them while Scott is speaking. But, they are very well written, and you can easily follow the examples without Scott being there. Because it's a PDF only (electronic), it is still being updated.

  Overview of the New C++ (C++11/14): This PDF document consists of Scott Meyers' extensively annotated presentation materials for his training course on C++11 and C++14. This intensively technical seminar introduces the most important new features in C++11 and C++14 and explains how to get the most out of them. All of Scott Meyers' books can be found at his website.

• Written by Nicolai Josuttis who is also one of the most prominent authors of modern C++ books. It's available in electronic format (including PDF) with lifetime free upgrades and is very reasonably priced.

  C++17 - The Complete Guide (Nicolai Josuttis): This book presents all the new language and library features in C++17. It covers the motivation and context of each new feature with examples and background information. The focus is on how these features impact day-to-day programming, what it means to combine them, and how to benefit from this in practice.

• C++11FAQ at Stroustrup's site.
• In closing, I will defer again to the experts. In this case, Herb Sutter:

  Write What You Know, and Know What You Write Advice From the C++ Experts: My best advice? Don't get fancy. Treat a new C++ feature like you would treat a loaded automatic weapon in a crowded room: never use it just because it looks nifty. Wait until you understand the consequences, don't get cute, write what you know, and know what you write.
  
  The article is a little out-dated, but most of the advice is still excellent, especially for new programmers that like to use language features that they don't really understand yet.