C++ Standards

• 1st: C++98
• 2nd: C++03
• 3rd: C++11

C++11

Formerly known as C++0x. But they failed to complete the standard before 2010. :(

Rvalue references and move constructors

A new non-const reference type called an rvalue reference, identified by T&&

Why?

How to swap two number?

void swap(int &a, int &b)
{
  int temp = a;
  a = b;
  b = temp;
}
						

What about swap two string?

The swap function can be time-consuming when coming to class

void naiveswap(string &a, string &b)
{
  string temp = a;
  a = b;
  b = temp;
}
						

Memory allocated, object copy...

Why can't we only swap the char* of the objects?

std::move

Turns a lvalue into a rvalue

void ProcessValue(int& i) {
  std::cout << "LValue processed: " << i << std::endl;
}

void ProcessValue(int&& i) {
  std::cout << "RValue processed: " << i << std::endl;
}

int main() {
  int a = 0;
  ProcessValue(a);
  ProcessValue(std::move(a));
}
						

LValue processed: 0
RValue processed: 0
						

The new swap

class Movable
{
  Movable (Movable&&); //move constructor
  Movable&& operator=(Movable&&); //move assignment operator
};
						

template <class T> swap(T &a, T &b)
{
  T tmp(std::move(a)); // move a to tmp
  a = std::move(b);    // move b to a
  b = std::move(tmp);  // move tmp to b
}
						

Perfect Forwarding

A common need

template <typename T> void forward_value(const T &val) {
  process_value(val);
}
template <typename T> void forward_value(T &val) {
  process_value(val);
}

int a = 0;
const int &b = 1;
forward_value(a); // int&
forward_value(b); // const int&
forward_value(2); // int&
						

So we must overload lots of functions :(

Perfect Forwarding

template <typename T> void forward_value(T &&val) {
  process_value(val);
}

int a = 0;
const int &b = 1;
forward_value(a); // int&
forward_value(b); // const int&
forward_value(2); // int&&
						

Designed to reduce the amount of code the programmer has to write

Constant Expressions: constexpr

A new keyword to guarantee that a function or object constructor is a compile-time constant.

Example

What will happen when running the code?

int get_five() {return 5;}
int some_value[get_five() + 7];
						

Compile error!

Now, we can use constexpr:

constexpr int get_five() {return 5;}
int some_value[get_five() + 7];
						

Initializer lists

In C, you can quick initialize a struct like this:

struct Object {
    float first;
    int second;
};
 
Object scalar = {0.43f, 10}; //One Object, with first=0.43f and second=10
Object anArray[] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; //An array of three Objects
						

What about C++ class (e.g. std::Vector)?

Example:

vector<string> v = { "xyzzy", "plugh", "abracadabra" };
						

This can be very very useful!

How to?

Define a new constructor:

class SequenceClass {
public:
    SequenceClass(std::initializer_list<int> list);
};
						

Then...

SequenceClass some_var = {1, 4, 5, 6};
						

Uniform initialization

How to initialize a class?

Obj var(foo);
Obj *ptr = new Obj(foo);
						

But in initializer lists we use curly brace {}, not parenthesis ()

They are not uniform...

Introduce the curly brace

struct BasicStruct {
    int x;
    double y;
};

struct AltStruct {
    AltStruct(int x, double y) : x_{x}, y_{y} {}

private:
    int x_;
    double y_;
};

BasicStruct var1{5, 3.2};
AltStruct var2{2, 4.3};
						

Even some amazing format

struct IdString {
    std::string name;
    int identifier;
};

IdString get_string() {
    return {"foo", 42}; //Note the lack of explicit type.
}
						

Type inference

If we travelling a std container like vector:

for (std::vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr)
						

Use auto to shorten the code:

for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr)
						

Determine the type of an expression

int some_int;
decltype(some_int) other_integer_variable = 5;
						

Lambda functions

It looks like:

[capture](parameters)->return-type {body}
						

Example:

int main()
{
  char s[]="Hello World!";
  int Uppercase = 0; //modified by the lambda
  for_each(s, s+sizeof(s), [&Uppercase] (char c) {
    if (isupper(c))
      Uppercase++;
  });
  cout<< Uppercase<<" uppercase letters in: "<< s<<endl;
}
						

Alternative function syntax

What's wrong with this code?

template<class Lhs, class Rhs>
decltype(lhs+rhs) adding_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;}
						

lhs and rhs have not yet been defined!

Workaround

template<class Lhs, class Rhs>
auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}
						

Explicit overrides

In C++03, it is possible to accidentally create a new virtual function, when one intended to override a base class function. For example:

struct Base {
    virtual void some_func(float);
};

struct Derived : Base {
    virtual void some_func(int);
};
						

C++11 provides syntax to solve this problem.

struct Base {
    virtual void some_func(float);
};

struct Derived : Base {
    // error!
    virtual void some_func(int) override;
};
						

Final

Prevent inheriting from classes

struct Base1 final { };

struct Derived1 : Base1 { }; // Error!
						

Preventing overriding methods in derived classes

struct Base2 {
    virtual void f() final;
};

struct Derived2 : Base2 {
    void f(); // Error!
};
						

Explicitly defaulted and deleted special member functions

default:

struct SomeType {
    SomeType() = default; //The default constructor is explicitly stated.
    SomeType(OtherType value);
};
						

Explicitly defaulted and deleted special member functions

delete:

struct NonCopyable {
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable & operator=(const NonCopyable&) = delete;
};
						

struct NoInt {
    void f(double i);
    void f(int) = delete;
};