I am not an expert in C++(11). I may or may not be able to answer technical questions.

The code examples are designed to highlight specific language features, and may not always represent best code practices or sensible program design.

If you are using Boost, you may already know much of what follows.

• What is C++11?
• auto
• Range for loops
• Smart pointers
• Uniform initialization syntax
• λ
• Multiple return values
• Miscellaneous

• C++11 is a C++ standard specification published in 2011
• It replaces C++03 and is itself replaced by C++14 / C++17
• C++11 adds to the core language and the Standard Library

• C++11 is a C++ standard specification published in 2011
• It replaces C++03 and is itself replaced by C++14 / C++17
• C++11 adds to the core language and the Standard Library

• Use GCC 4.7 or later for best results (or Clang)
• Compile with -std=c++11 (-std=c++0x for GCC ≤ 4.6)

1. Make sure you have at least g++-4.7, and if not:
   sudo apt-get install g++-4.9 gcc-4.9
2. If you didn't do it earlier, get the materials:
   git clone https://github.com/nikolausmayer/cpp11presentation
3. In your favourite editor, open the Makefile in the repository’s code folder code/Makefile
4. Add -std=c++11 to CXXFLAGS
5. make to make sure it works. If you had to install a new g++, you might want to use CXX=g++-4.9 make

• The auto keyword is not new, but its meaning has changed
• Before: Storage class specifier (cf. static, extern)
• Now: Automatic type deduction:

  float almostpi = 3.14f;
  std::vector<SomeClass<SomeType> >::iterator it = myvec.begin();

  can become

  auto almostpi = 3.14f;
  auto it = myvec.begin();

• Type deduction happens at compile time
• Important: In general, auto ignores references and const/volatile (there are special cases)

template <typename T1, typename T2>
decltype(t1 + t2) add(T1 t1, T2 t2) {     // (a)
  return t1 + t2;
}
decltype(add(2, 3.14)) v = add(2, 3.14);  // (b)

• (a) t1 and t2 are technically unknown at that point
• (b) This is just cumbersome

template <typename T1, typename T2>
auto add(T1 t1, T2 t2) {
  return t1 + t2;
}

std::vector<std::shared_ptr<myClass> > vec;
std::shared_ptr<myClass> myClass_ptr{0};
myClass_ptr = std::make_shared<myClass>(...);
vec.push_back(myClass_ptr);

if (myClass_ptr) {...}

std::shared_ptr<myClass> myClass_ptr{0};

std::shared_ptr<myClass> myClass_ptr = 0;

std::shared_ptr<myClass> myClass_ptr = {0};

class myClass;

void Func() {
  int foo(myClass());
}

• An int variable
• A prototype for a function that takes a myClass and returns an int
• A prototype for a function that takes a function that returns a myClass, and returns an int
• Undefined behaviour

class myClass;

void Func() {
  int foo{myClass{}};
}

int a(5.2);  // ok, a==5
int a{5.2};  // error!

int main() {
  std::vector<float> numbers;
  ...
  auto multiplier = [&numbers](float factor) -> void {
    for (auto& elem: numbers) elem *= factor;
  };
  multiplier(3.0f);
}

• captures the variable numbers by reference,
• takes a float argument factor,
• returns void (remember trailing return?),
• and multiplies each element in numbers by factor.

[](){}();

#if __cplusplus > 199711L
  std::cout << "Compiled using C++11 or later\n";
#else
  std::cout << "Compiled using C++03 or earlier\n";
#endif

#ifdef HAS_MOVE_SEMANTICS

std::vector<std::vector<int>> vec;

error: '>>' should be '> >' within a nested template argument list

std::vector<std::vector<int> > vec;

int stupid_division(int a, int b) {
  assert(b != 0);
  return (a / b);
}

template <int N>
class Filter {
  ...
}

template <int N>
class Filter {
  Filter() {
    if (N<=1) throw std::runtime_error("Filter invalid for N<=1");
  }
  ...
}

template <int N>
class Filter {
  Filter() {
    static_assert(N>1, "Filter invalid for N<1");
  }
  ...
}

template <typename T>
T very_small_value() {
  return (T)0.00001;
}

template <typename T>
T very_small_value() {
  throw std::runtime_error("Bad type");
  return (T)0.00001;
}
template float very_small_value<float>()  { return 0.00001f; }
template double very_small_value<double>() { return 0.00001; }
...

template <typename T>
T very_small_value() {
  return (T)0.00001;
}

template <typename T>
T very_small_value() {
  static_assert(std::is_floating_point<T>::value,
                "very_small_value only works for float types");
  return (T)0.00001;
}

Standard C++ 7.2/5:
  The underlying type of an enumeration is an integral type 
  that can represent all the enumerator values defined in the 
  enumeration.

enum boyfriend_type { rich, nice, cool };
enum CERN_magnet_status { warm, cool, supercool };

error: redeclaration of ‘cool’
note: previous declaration ‘boyfriend_type cool’

type_values = {int: 1, float: 2}

std::map<std::typeinfo, int> type_values;
type_values[typeid(int)] = 1;

template <typename T>
struct type_values { static const int value = 0; }

template struct type_values<int> { static const int value = 1; }

std::map<std::typeinfo, int> type_values;
type_values[typeid(int)] = 1;

std::map<std::type_index, int> type_values;
type_values[std::type_index(typeid(int))] = 1;

• no type declarations ➞ auto
• automatic memory management ➞ smart pointers
• not free ➞ free
• interpreted ➞ not interpreted
• call-by-value ➞ (smart) pointers, references

• C++11 takes away much of the C++ grind
• There is no hard reason not to use it
• On a remotely up-to-date system, it’s just a keyword away
• But please, think before you auto

Sources