c++ 17介绍

Whatever we do, we should preserve C++’s fundamental strengths:
• A direct map to hardware (initially from C)
• Zero-overhead abstraction (initially from Simula)
Depart from these and the language is no longer C++.

• Modules：不出意外，这个呼声太高了。不但是编译速度，就连最基础的One Definition Rule的各种规则都能搞死人。最新的2篇modules提案：
  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4465.pdfhttp://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4466.pdf说起来简单，实现起来麻烦。目前提案者正在Visual C++中实现这些提案。因为这个呼声很高，有理由相信进入c++17的可能性很大。虽然目前进展还不是很快的感觉。看proposal目前还有一些小的design decision没有明确下来，例如是否需要interface这个关键字之类的。
  
  有了modules写出来的代码是什么样子呢，大概是这个样子，
  
  

  import std.vector;
  import std.string;
  import std.iostream;
  import std.iterator;
  

  
  怎样写module呢？
  
  

  //abc.cpp （文件名无需和module名重合）
  module abc;
  struct internal {  };
  int internal_f() {  }
  export namespace abc 
  {
    class abc { };
  }
  

  
  注意C++的module仅仅只是编译范畴的，并不是二进制范畴的。效率为王。

• Contracts：经过11年被洗礼之后，这次加进来问题应该不大了。最新的提案：
  
  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4415.pdf
  
  出来时间比较久了，大家也都知道是干嘛的，也有刘雨培童鞋说过最新提案，我就不多说了，其实Contracts简化后也是蛮复杂的，但基本上即使你从没接触过，读懂别人写的代码的难度也不大。
• A type-safe union：也就是variant，基本上是在往functional-programming上靠。
  
  Stroustrup桑还给了一个链接，13年他的一个学生（？）的论文，一个c++的pattern matching库，蛮坑的。我觉得不进行大改善，这个pattern matching库进入c++的标准可能性不大。
  
  好奇的童鞋们不用找了，我拷个最简单的例子出来。有了variant之后，这个match库可以match类型+值。不过仅仅是库而不是语言层面的支持，真是不伦不类啊。
  
  

  int factorial(int n) {
    int m;
    Match(n) {
      Case (1) return 0;
      Case (m) return m*factorial(m-1);
      Case (_) throw std::invalid_argument(""); 
    } EndMatch
  }
  

• 基础网络库：这个太需要了，没有基础网络库，其他任何网络相关的操作都是空中楼阁。
  
  基于boost::asio的最新提案，
  
  http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4478.html
  
  boost::asio的async模型基本是callback。但这个proposal其实并不是简单的boost::asio直接拷贝过来，除了基本的asio之外，还基于future和co-routine加了不少料。
  
  例如，基于future的async模型，
  
  

  std::future<std::size_t> fut =
    socket.async_read_some(buffer(buffer_space), use_future);
  
  // ...
  
  std::size_t length = fut.get();
  

  复杂一点还可以这样，
  
  

  socket.async_read_some(buffer(buffer_space), use_future).then([](std::size_t) {});
  

  
  例如，基于co-routine的async模型（例子是stackful的，stackless需要语言层面支持）。
  
  

  void coro_connection(tcp::socket& socket, yield_context yield)
  {
    try
    {
      std::vector<char> buffer_space(1024);
      for (;;)
      {
        std::size_t length = socket.async_read_some(buffer(buffer_space), yield);
        uppercase(buffer_space.begin(), buffer_space.begin() + length);
        async_write(socket, buffer(buffer_space, length), yield);
      }
    }
    catch (std::system_error& e)
    {
      // ...
    }
  }
  

  基本上可以看出网络库是一个async模型的大杂烩，只要你有，我就支持。
  
  最后，这个proposal还加了一些高级的库（无需关注底层细节）。
  
  

  tcp::iostream s("www.boost.org", "http");
  
  s << "GET / HTTP/1.0\r\n";
  s << "Host: www.boost.org\r\n";
  s << "Accept: */*\r\n";
  s << "Connection: close\r\n\r\n";
  
  std::string header;
  while (std::getline(s, header) && header != "\r")
    std::cout << header << "\n";
  std::cout << s.rdbuf();
  

• SIMD vector：数学计算啊，游戏啊，没什么好说的，研究这方面的自然懂，不研究的这个概念也没啥复杂的。下面这个提案提出一个matrix 类，乘法等操作利用simd搞计算。
  
  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4492.pdf
• Improved Future: 基本上都是微软根据.Net经验提出来的。就比如网络库的.then，就是基于此。你可以async_read( ).then().then().then()，等等。具体看proposal吧，蛮简单易懂的。
  
  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3857.pdf
• Co-routines：主体也是微软搞出来的提案，基本和.net一样的语法。在VC++上已经有实现。本来这东西就分stackful还是stackless。微软应该是比较倾向于stackless的，google一人也提出了stackful和stackless的语法可以统一的一个提案。具体还未定。很可能是都支持，用户可自由选择的。其实微软的提案还是比较吸引人。关键字：await，yield
  
  https://isocpp.org/files/papers/N4402.pdf
  
  我要多说一些，因为蛮有意思，
  
  复制一下微软的design goal：
  
  * Highly scalable (to billions of concurrent coroutines)
  * Highly efficient resume and suspend operations comparable in cost to a function call overhead
  * Seamless interaction with existing facilities with no overhead
  * Open ended coroutine machinery allowing library designers to develop coroutine libraries exposing various high-level semantics, such as generators, goroutines, tasks and more
  * Usable in environments where exception are forbidden or not available
  
  就看他的design goal就很想敢用了
  
  写出来的代码什么样子呢？await和yield关键字其实.net, python啊，java啊之类的也都有，没什么好解释的，要说下generator和goroutine，你没看错，是类Go语言的goroutine支持。
  
  generator:
  

  generator<int> fib(int n) {
    int a = 0;
    int b = 1;
    while (n-- > 0) {
      yield a;
      auto next = a + b;
      a = b;
      b = next;
    }
  }
  

  goroutine:
  

  goroutine pusher(channel<int>& left, channel<int>& right)
  {
    for(;;) {
      auto val = await left.pull();
      await right.push(val + 1);
    }
  }
  int main() {
    static const int N = 1000 * 1000;
    std::vector<channel<int>> c(N + 1);
    for(int i = 0; i < N; ++i)
      goroutine::go(pusher(c[i], c[i + 1]));
    c.front().sync_push(0);
    std::cout << c.back().sync_pull() << std::endl;
  }
  

  
  
  
• Trasactional Memory: 底部支持，没什么好说的。基本是板上钉钉。
• Parallel STL
  
  基本上就是并行实现的stl，可以选择模式，例如sort
  
  

  sort(begin(v), end(v)); //无并行
  sort(seq, begin(v), end(v)); //无并行
  sort(pal, begin(v), end(v)); //并行
  sort(par_vec, begin(v), end(v)); //并行矢量化
  execution_policy exec=seq; //动态决定
  if (v.size() > 1000) exec = par;
  sort(exec, begin(v), end(v));
  

• Concepts: 不说了
• Ranges: 也有童鞋说过了，不说了。总体来说ranges就是一对数[i, j),或者一对iterator。需要对STL库进行添加支持针对Ranges的操作。例如你可以sort(v),而无需sort(begin(v), end(v))
• Default comparisons：就是说会自动生成operator >, ==之类的。对用户自定义move或者copy的不会自动生成。
• Uniform call syntex：也有童鞋说过了。
  
  目前这个提案大概是确认了：如果f(x,y),那么就先找函数，如果函数没有，再找x.f(y)。而x.f(y)相反，找不到类x的f函数，再去找 f(x,y)函数。也有另外一个选择，就是x.f(y)和f(x,y)所有符合的全部放到一起然后做overloading resolution。这样可能会破坏现有的代码。还有2年时间可以讨论选哪种。
  
  
• Operator dot： 没什么可说的
• array_view和string_view: 蛮有意思的东西。
  
  假设你有一个字符串“abcde, xyz"，目前来说，如果你实现一个函数，从逗号分割这个字符串，你会得到2个字符串"abcd", "xyz"。但如果有了string_view，你会得到2个string_view，每个string_view里面是一个(start, size)对，这样就节省了多个字符串拷贝。
  
  array_view可以更有意思，
  

  auto M = 32;
  auto N = 64;
  auto v = vector<float>(M * N);
  auto av = array_view<float, 2>({M, N}, v);
  

  你要问为啥不直接 vector<vector<float>>，因为这样无法保证内存连续分配啊。
  
  
• stack_array：还没有proposal
• optional，和variant类似吧。目前没有proposal，除非pattern matching被加到c++17中去了，否则不太可能17里实现。