Advanced C++

Features of standard 2011

Máté Cserép

October 2015, Budapest

Already seen

• Null pointers
• Constant expressions (constexpr)
• noexcept specifier
• Deleted constructors
• Default constructors
• Delegated constructors
• Smart pointers (unique_ptr, shared_ptr, weak_ptr)
• Right value references
• Move semantic
• Multithreading
• Variadic templates
• Variable templates (C++14)

Overview

• Automatic type deducation and decltype
• Uniform initialization syntax
• Strongly typed enums
• Traits and their various usages
• Compile-time checking with static_assert 
• User-defined literals
• Lamda expressions, captures

Auto typing

template<class T> void printall(const vector<T>& v)
{
  for (typename vector<T>::const_iterator p = v.begin(); p!=v.end(); ++p) 
     cout << *p << "\n";
}

template<class T> void printall(const vector<T>& v)
{
  for (auto p = v.begin(); p!=v.end(); ++p) 
     cout << *p << "\n";
}

Decltype

void f(const vector<int>& a, vector<float>& b)
{
  typedef decltype(a[0]*b[0]) Tmp;
  for (int i=0; i<b.size(); ++i) {
      Tmp* p = new Tmp(a[i]*b[i]);
      /* ... */
  }
  /* ... */
}

We can deduce the type of an expression:

Enum class

enum Alert { green, yellow, election, red };

Traditional enum:

Enum class

enum Alert { green, yellow, election, red };
enum class TrafficLight { red, yellow, green };

Alert a = 7;                // error (as ever in C++)
Color c = 7;                // error: no int->Color conversion
int a2 = red;               // ok: Alert->int conversion
int a3 = Alert::red;        // error in C++98; ok in C++11
int a4 = blue;              // error: blue not in scope
int a5 = Color::blue;       // error: not Color->int conversion  
Color a6 = Color::blue;     // ok

Conversion:

Enum class

enum class Color_code : char;     // (forward) declaration
void foobar(Color_code* p);       // use of forward declaration
// ... later ...
enum class Color_code : char { red, yellow, green, blue }; // definition

Support of forward declaration:

Static assertion

template <class T>
struct data_structure
{
    static_assert(std::is_default_constructible<T>::value,
                  "Data Structure requires default-constructible elements");
};

struct no_default
{
    no_default() = delete;
};

int main()
{
    data_structure<int> ds_ok;
    data_structure<no_default> ds_error; // compilation error
}

Check constructor existence:

Static assertion

template <class T>
void swap(T& a, T& b) {
    static_assert(std::is_copy_constructible<T>::value,
                  "Swap requires copying");
    static_assert(std::is_move_constructible<T>::value &&
                  std::is_move_assignable<T>::value &&
                  (!std::is_nothrow_move_constructible<T>::value ||
                  !std::is_nothrow_move_assignable<T>::value),
                  "Swap may throw");
    auto c = b;
    b = a;
    a = c;
}

struct no_copy {
    no_copy ( const no_copy& ) = delete;
    no_copy () = default;
};
 
int main() {
    int a, b;
    swap(a, b);
 
    no_copy nc_a, nc_b;
    swap(nc_a, nc_b);  // compilation error
}

Check proper move semantics support:

Lamda expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

auto lamda = [](int n) { cout << n << " "; };
lamda(10);

for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });
cout << endl;
return 0;

[]           lambda-introducer
(int n)   lambda parameter declaration
{ ... }     compound statement

Lamda Expressions

struct LambdaFunctor
{
    void operator() (int n) const { cout << n << " "; }
};

int main()
{
    vector<int> v;
    for(int i = 0; i < 10; ++i)
        v.push_back(i);

    for_each(v.begin(), v.end(), LambdaFunctor());
    cout << endl;
    return 0;
}

Lambda expressions define classes and construct objects.

The previous program is equivalent to:

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

for_each(v.begin(), v.end(),
    [](int n)
    {
        cout << n ;
        if ( n % 2 )
            cout << ":odd ";
        else
            cout << ":even ";
    });
cout << endl;

A lamda expression can contain multiply statements:

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

deque<int> d;
transform(v.begin(), v.end(), front_inserter(d), [](int n) {return n*n;} );
for_each(d.begin(), d.end(), [](int n) { cout << n << " "; });

cout << endl;

If the lambda expression has return value, than the return type is automatically deduced from that expression.

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

deque<double> d;

transform(v.begin(), v.end(), front_inserter(d),
    [](int n) -> double  { return n / 2.0; } );

for_each(d.begin(), d.end(), [](double n) { cout << n << " "; });

cout << endl;

Sometimes it is not easy to deduce the return type or not the desire type is deduced. We can explicitly specify the return type:

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

int x = 0;
int y = 0;
int z = 0;
cin >> x >> y;

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
// [0, 1, 2, 8, 9, 3, 4, 5, 6, 7]

auto lamda = [x,y](int n) { return x < n && n < y; };
cout << sizeof(lamda) << endl;

v.erase(remove_if(v.begin(), v.end(),
                 [x,y](int n) { return x < n && n < y; }),
        v.end());

for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });

cout << endl;

The [] lamda specifier means, that the lambda is stateless, but we can capture local variables.

Lamda Expressions

struct LambdaFunctor
{
public:
    LambdaFunctor(int a, int b) : m_a(a), m_b(b) { }
    bool operator()(int n) const { return m_a < n && n < m_b; }
private:
    int m_a;
    int m_b;
};

int main()
{
  vector<int> v;
  for(int i = 0; i < 10; ++i)
      v.push_back(i);

  cin >> x >> y;
  int x, y;

  v.erase(remove_if(v.begin(),v.end(), LambdaFunctor(x,y)), v.end());
  return 0;
}

Since we passed the x and y parameters by value, it is basically equivalent to the following: 

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i);

int x = 0;
int y = 0;
cin >> x >> y;

v.erase( remove_if(v.begin(),v.end(),
                  [=](int n) { return x < n && n < y; }),
         v.end()
 );

for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });

cout << endl;
return 0;

The [=] is the default-capture lambda introducer.
Captures all locals by value.

Lamda Expressions

vector<int> v;
for(int i = 0; i < 10; ++i)
    v.push_back(i * 2);

const int prev = 0;
for_each(v.begin(), v.end(),
        [&prev](int& r)
        {
          cout << "("  << prev << "," << r << ")" << endl;
          prev = r;
        });

for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });

cout << "prev = " << prev << endl;

How can we capture by reference?

Examples:

[&]                  Capture everything by reference
// [=, &x, &y] Capture everything by value but x and y which by reference
// [&, x, y]      Capture everything by reference but x and y which is by value

Lamda Expressions

struct X {
    int s;
    vector<int> v;
    void print() const     {
        for_each(v.begin(), v.end(), [this](int n) { cout << n*s << " "; });
    }
};

int main() {
    X x;
    x.s = 2;
    for(int i = 0; i < 10; ++i)
        x.v.push_back(i);

    x.print();
    return 0;
}

Capturing the current object in a method:

• The this pointer is always captured by value
• You can implicitly capture this with [=]

Lamda Expressions

int ii = 5;

int main()
{
    vector<int> v;
    for(int i = 0; i < 10; ++i)
        v.push_back(i);

    int x = 0;
    int y = 10;

    auto f = [x, y](int n) { if (x < n-ii && n-ii < y)
                            cout << n << " ";
    };

    for_each(v.begin(), v.end(), f);
    cout << endl;

    ii = 1;

    for_each(v.begin(), v.end(), f);
    cout << endl;
    return 0;
}

Global variables and static data members could be used, but they are not captured!

Lamda Expressions

void doit(const vector<int>& v, const function<void (int)>& f)
{
    f(10);
    for_each(v.begin(), v.end(), f);
    cout << endl;
}

int main()
{
    vector<int> v;
    int i = 0;

    generate_n(back_inserter(v), 10, [&] { return i++; } );

    doit(v, [](int n) { cout << n << " "; });

    const function<void (int)>& ff = [](int n) { cout << n << " "; };
    doit(v, ff);

    return 0;
}

What is the type of a lamda function object?
std::function