C++11中的一些新特性

C++11中的一些新特性


1. auto关键字
auto关键字可以在编译期自动推导变量的类型，例如：
  auto x = 7;
  for (auto i = v.begin(); i != v.end(); ++i){
    cout << *i << endl;
  }


2. for关键字
C++11为for语句提供了类似Java中for或者C#和PHP中foreach的用法：
  void f(vector<double> &v){
    for (auto &x : v){ 
      cout << x << endl; 
    }
  }
  for (const auto x : { 1, 2, 3, 4 }){ 
    cout << x << endl; 
  }


3. 构造函数和析构函数的控制参数
在C++98中，如果你想禁止一个类的构造函数被调用，你需要将其声明为private成员。C++11提供了一个新特性，你可以再声明构造函数时加上delete来避免构造函数被调用：
  class X {
    X& operator=(const X&) = delete;
    X(const X&) = delete;
    ~X() = delete;
  };
  class Y {
    Y& operator=(const Y&) = default;
    Y(const Y&) = default;
  };
例子中default的意思是使用编译器自动合成的构造/西沟函数。


4. 常量表达式
常量表达式可以在很多地方取代宏：
  enum Flags { good = 0, fail = 1, bad = 2, eof = 4 };
  constexpr int operator|(Flags lhs, Flags rhs){ return Flags(int(f1) | int(f2)); }
  void f(Flags x){
    switch (x){
      case bad: ... break;
      case eof: ... break;
      case bad | eof: ... break;
      default: ... break;
    }
  }
  constexpr int x = bad | eof; 
  Flags f, constexpr x = bad | f; // error constexpr必须在编译器可以被计算


5. 表达式类型
  typedef decltype(x * y) ResultType;


6. 初始化列表
C++11提供了一个新的，统一的初始化列表{}：
  vector<double> v = { 1, 2, 3.45 };
  list<pair<string, string> languages = {
    { "Nygaard", "Simula" },
    { "Richards", "BCPL" },
    { "Ritchie", "C" },
  };
  std::initializer_list<T>
  void f(initializer_list<int> v){
    for (auto x : v){ cout << x << endl; }
  }
  f({1, 2});
  f({});
使用{}初始化时，不会做降低精度的类型转换（narrow）。
  int a[3] = { 1, 2, 3 };


7. 委托构造函数
  class X {
    X(int x){ cout << x << endl; }
    X() :X(10){}
    X(string s) :X(lexical_cast<int>(s)){}
  };


8. 类内初始化
  class X {
    int a = 7;
  };


9. 继承构造函数
  struct B {
    B(){}
  };
  struct D : B {
    using B:B;
  };


10. 编译期断言
  static_assert(expression, string)


11. 空指针
  nullpter


12. 返回值后置声明
用于无法确定函数返回值类型的场景，不再手动指定返回值类型，而是让编译器自动推导出类型：
  template<class T, class U>
  auto mul(T x, U y) -> decltype(x * y){
    return x * y;
  }


13. 模板别名
  template<N>
  using int_exact = typename int_exact_traits<N>::type;
  using P = [](double) -> void;


14. 可变参数模板
  template<typename T, typename... Args>
  void printf(const char *s, T value, Args... args){
    while (s && *s){
      if (*s == '%' && *++s != '%'){
        cout << value;
        return printf(++s, args...);
      }
      cout << *s++;
    }
    throw runtime error("extra arguments");
  }


15. 右指引用
右值是在计算表达式过程中产生的非持久（临时）对象。
  X &&t = f();
  T tmp = move(a);


16. 原始字符串
  string s = R"(\w\\\w)";


17. 自定义字面值
  constexpr complex<double> operator "" i(long double d){
    return {0,d};
  }
  auto z = 2 + 1i;
  string operator""s(const char *p, size_n){
    return string (p, n);
  }
  f("Hello\n"s);


18. 语句块属性
  void f [[noreturn]] (){  throw "error"; }
  for [[omp::parallel()]] (int i = 0; i < v.size(); ++i){ ... }


19. lambda表达式
  vector<int> v = { 50, -10, 20, -30 };
  sort(v.begin(), v.end(), [](int a, int b){ return abs(a) < abs(b); });
  int count = 0;
  int v[10];
  generate(v, v + 10, [&count](){ return ++count; });
  vector<X> v;
  sort(v.begin(), v.end(), [](const X& a, const X& b){ return a.v < b.v; });


20. 显式内存布局
  alignas(double) unsigned char c[1024];
  alignas(16) char[100];
  constexpr int n = alignof(int);


21. 覆盖控制
  struct B {
    virtual void f() const final; // 不能被覆盖
  };


22 可变参数宏（对C99的支持）
  #define report(test, ...) ((test)?puts(#test):printf(__VA_ARGS__))


23. 新容器
  <array>
  std::array<int, 6> a = { 1, 2, 3 };
  int *p = a.data();
  <forward_list>
  unordered_map
  unordered_set
  unordered_multimap
  unordered_multiset
  <tuple>
  std::tuple<string, int> t2("ok", 123);
  auto t = make_tuple(string("ok"), 10, 1.234);
  string s = get<0>(t);
  int x = get<1>(t);


24. 函数对象
  <functional>
  int f(int, char, double);
  auto frev = bind(f, _3, _2, _1);
  int x = frev(1.2, 'c', 7);
  auto f = bind<int>(f, 7, 'c', _1);
  int x = f(1.2);


25. 线程
  <thread>
  void foo(){ cout << "ok" << endl; }
  thread t(foo);
  t.join();


26. 正则表达式<regex>


27. 原子值<atomic>


28. 新时间库<chrono>