司长是什么级别

Meeting Summary

This week, the ISO C++ Committee met in Toronto, Canada to begin work on the next International Standard, C++20, and to continue development of our Technical Specifications. We’re done with C++17 - we expect to send it out for publication at the next meeting.

We added the following features to the C++20 draft:

• Concepts

• Explicit generic lambdas (accessible version):

    [] <typename T> (T t) { /* ... */ }

• ＿VA_OPT＿ (accessible version):

    #define LOG(msg, ...) printf(msg __VA_OPT__(,) __VA_ARGS__)
  
    LOG("hello world")   // => printf("hello world")
    LOG("hello world", ) // => printf("hello world")
    LOG("hello %d", n)   // => printf("hello %d", n)

• Default bit-field initializers (accessible version):

    struct S {int x : 8 = 42;};

• Fixed const-qualified pointers to members (accessible version):

    struct X { void foo() const&; };
    X{}.foo();        // this is okay
    (X{}.*&X::foo)(); // ill-formed in C++17, well-formed in C++2a

• Allow［=, this］ as a lambda capture

• Designated Initializers (accessible version):

    struct A { int x; int y; int z; };
    A b{.x = 1, .z = 2};

• More deduction guides for the standard library (accessible version):

    vector v{vector{1, 2}};
     // Deduces vector<int> instead of vector<vector<int>>

• Endian (accessible version):

    enum class endian
    {
      little = __ORDER_LITTLE_ENDIAN__,
      big    = __ORDER_BIG_ENDIAN__,
      native = __BYTE_ORDER__
    };

• Fixing string conversion fixes (accessible version)

• Improve class template argument deduction in the stdlib:

    mutex m;
    scoped_lock l(adopt_lock, m); // make this work
  
    variant<int, double> v1(3);
    variant v2 = v1; // make this work

• Arrays for make_shared (accessible version):

    shared_ptr<double[]> p = make_shared<double[]>(1024);

We also published THREE Technical Specifications:

• Coroutines v1

• Ranges v1

• Networking v1

Also, we now have a draft of the Modules Technical Specification.

The Road to C++20

This was the first “C++20” meeting. C++17 is currently in Draft International Standard (DIS) balloting and we anticipate that it will be ready for publication at the next meeting (November 2017, in Albuquerque, New Mexico). We didn’t have anything to work on for C++17 at this meeting, and the C++ working paper is now “unlocked” (i.e. we can start accepting changes for the next standard).

After C++11, the committee began made two major changes in how we operate:

• We started using Technical Specifications to release “beta” versions of major features that vendors can optionally implement

• We moved to a three year release cycle

The next planned release will be C++20, and it should be an interesting one, because right now we have a large number of TSes in flight:

• Filesystem v1, merged into C++17

• Parallelism v1, merged into C++17

• Transactional Memory v1, published

• Library Fundamentals v1, merged into C++17

• Concepts v1, merged into C++20

• Concurrency v1, published, parts will be merged into C++20 next meeting

• Library Fundamentals v2, published

• Ranges v1, published

• Networking v1, published

• Coroutines v1, published

• Modules v1, draft released (PDTS)

• Executors v1, in development

• Parallelism v2, in development

• Reflection v1, in development

• Concurrency v2, in early development

• Parallelism v2, in early development

• Library Fundamentals v3, in early development

• Contracts v1

• 2D Graphics v1, in early development

It’s time for them to come home and be merged into the C++ standard. We expect that we’ll be able to integrate some (but not all) of these TSes into C++20.

TL;DR: it looks like C++20 is going to have a large, rich feature set. Concepts and explicit generic lambdas are already in. Also, the Coroutines, Ranges and Networking TSes are published, and a draft of the Modules TS will be released.

?

Last Meeting's Reddit Trip Report.

?

?

A number of C++ committee members will be on reddit to answer questions and discuss the future of C++. Just leave a comment in this thread!