😄 📯 🔽 C ++ 20 को बंडल किया गया है, C ++ 23 को प्रारंभ किया गया है। कोलोन में बैठक के परिणाम 🍶 🧕 👳🏿

दूसरे दिन कोलोन में अंतर्राष्ट्रीय मानकीकरण समिति C ++ की बैठक थी। पिछली बार, C ++ 20 में फ़ीचर फ़्रीज़ को अपनाया गया था, इसलिए समिति को केवल पहले से स्वीकृत चीज़ों के सुधार पर चर्चा करनी चाहिए, और C ++ 23 में पहले से ही नई सुविधाओं को जोड़ना चाहिए ...

... लेकिन ऐसा नहीं था!

उन्होंने std के साथ क्या किया :: flat_map; क्या डरावने कीवर्ड co_return, co_await और co_yield बने रहेंगे; क्या आपने समाप्त करने का प्रबंधन किया :: प्रारूप; C ++ 20 में किस तरह के अनुबंध होंगे? यह सब आपको कटौती के तहत इंतजार कर रहा है।

विकास कार्य समूह

सोमवार

दिन व्यस्त था - हमने कैमलकेस के बजाय साँप_केस में सभी अवधारणाओं का नाम बदलने का फैसला किया। इसके अलावा, P1607 प्रस्ताव, जो अनुबंधों के वाक्यविन्यास और व्यवहार को अधिक समझ में आता है (लेकिन मैक्रोज़ की आवश्यकता भी है) को व्यापक रूप से आवाज दी गई थी ।

मंगलवार

कोरटिन्स ने चर्चा की। Coroutine के लिए कीवर्ड से co_ ड्रॉप करने के हमारे प्रस्ताव सहित, सब कुछ अस्वीकृत कर दिया। अफसोस।

बुधवार

अचानक हमें एहसास हुआ कि किसी ने भी प्रस्ताव P1607 को सोमवार को मंजूरी नहीं दी, व्यवहार में इसे लगभग 30 मिनट के लिए चर्चा की गई, जबकि अनुबंधों पर मौजूदा निर्णय को कई वर्षों के लिए सम्मानित किया गया था।

एक लंबी चर्चा के बाद, उन्होंने तय किया कि अनुबंध सैद्धांतिक रूप से C ++ 20 के लिए तैयार नहीं हैं। और उन्हें मानक से हटा दिया।

गुरुवार का दिन

C ++ 23 के लिए चर्चा की गई चीजें। मुख्य बलों को त्रुटि से निपटने में नए तंत्र पर ध्यान केंद्रित किया गया था। विषय पर दोनों सामान्य विचार थे और नए थ्रो अपवाद निर्दिष्ट के लिए विशिष्ट प्रस्ताव।

लाइब्रेरी वर्किंग ग्रुप

समिति में एक उपसमूह एलडब्ल्यूजी है। मानक पुस्तकालय में कार्यक्षमता जोड़ने वाले किसी भी दस्तावेज को इस उपसमूह में समीक्षा से गुजरना चाहिए।

एलडब्ल्यूजी का औसत प्रवाह प्रति सप्ताह ~ 30 दस्तावेज है। कोलोन में, 50 से अधिक दस्तावेजों पर विचार करना आवश्यक था, जिनमें से लगभग आधे बेहद प्रभावशाली आकार थे, उदाहरण के लिए:
* std :: flat_map
* std :: jthread
* मानक पुस्तकालय के लिए ऑपरेटर <=>
* नई तुल्यकालन आदिम
+ पेपर ईडब्ल्यूजी से स्नेक_केस में अवधारणाओं का नाम बदलने के लिए आया था।

पहले से अनुमोदित में से कौन सी C ++ 20 में खींचने में कामयाब रहा

constexpr में अब प्रत्येक चर को शून्य-प्रारंभ करना आवश्यक नहीं है । Int i {} के साथ डाउन; long live int i।

अब निर्माणकर्ता और विध्वंसक के लिए आवश्यकता का उपयोग किया जा सकता है। तदनुसार, अब कक्षा में कई विध्वंसक हो सकते हैं:

#include <type_traits>

template<typename T>
struct Optional {
    // ...
    ~Optional() requires(std::is_trivially_destructible_v<T>) = default;
    ~Optional() requires(!std::is_trivially_destructible_v<T>) {
        if (inited_) reinterpret_cast<T&>(data_).~T();
    }
private:
    bool inited_{false};
    std::aligned_storage_t<sizeof(T), alignof(T)> data_;
};

[[nodiscard]] . , :

template <class F>
[[nodiscard("Without storing the result the code executes synchronously")]] future async(F&& );

auto test() {
    // ...

    // warning: Without storing the result the code executes synchronously
    async([huge_data](){
        std::cerr << huge_data;
    });
}

using enum:

enum class rgba_channel { kRed, kGreen, kBlue, kAlpha};

std::string_view to_string(rgba_channel channel) {
  using enum rgba_channel;
  switch (channel) {
    case kRed:   return "red";
    case kGreen: return "green";
    case kBlue:  return "blue";
    case kAlpha: return "alpha";
  }
}

Deduction guides :

template <typename T>
struct S {
    T x;
    T y;
};

S t{'4', '2'}; // Deduces `S<char>`

__asm constexpr ( !)

. :

void f(int(&)[]); // p.s.:        
int arr[1];

f(arr);          // OK

C++20

constinit :

int count_invocations() {
    //   ,   
    //   `counter`  .
    //
    //   -  ,  
    //         
    // `counter`   .
    static constinit std::atomic<int> counter{0};

    return ++counter;
}

.
volatile deprecated. .

[[nodiscard]] , :

struct [[nodiscard]] my_scopeguard { /* ... */ };
struct my_unique {
    [[nodiscard]] my_unique(int fd) { /* ... */ } //    
    /* ... */
};

void sample() {
    my_scopeguard(); // warning
    void(my_scopeguard()); // cast  void, warning  
    my_unique(42); // warning
}

Class Template Argument Deduction
std::vector placement new constexpr
<bit> . , / /, — .

<format> , chrono locale float:

constexpr auto birthday = 28d/April/1989;
string s = format("At {0:%d} of {0:%B}, {0:%Y} someone was born", birthday);
assert(s == "At 28 of April, 1989 someone was born");

constexpr bind, invoke, reference_wrapper
<numbers>

wait notify. conditional_variable:

#include <atomic>

enum class States {
    kInitial, kProcessing, kPosting,
};

// !  !
std::atomic<States> state{States::kInitial};

void state_machine_do_posting() {
    for (;;) {
        States expected_state = States::kProcessing;

        //        kProcessing
        state.wait(expected_state);

        if (!state.compare_exchange_strong(expected_state, States::kPosting)) {
            continue;
        }

        // do something
    }
}

snake_case
operator != operator ==. , operator <=>

std::*stringstream std::basic_stringbuf :

std::string to_string(const MyType& v) {
    std::string buf;
    constexpr std::size_t kMaxSize = 32;
    buf.reserve(kMaxSize);

    //  C++20  ,  C++20 —   
    std::ostringstream oss{std::move(buf)};
    oss << "MyType{" << v << '}';

    //  C++20  ,  C++20 — 
    return std::move(oss).str();
}

std::jthread:

#include <thread>

void sample() {
    bool ready = false;
    std::mutex ready_mutex;
    std::condition_variable_any ready_cv; //   `_any`!

    std::jthread t([&ready, &ready_mutex, &ready_cv] (std::stop_token st) {
        while (!st.stop_requested()) {
          /* ... */
          {
            std::unique_lock lock{ready_mutex};

            //    ready == true,  stop_token.request_stop(),
            //  jthread.request_stop().
            ready_cv.wait_until(lock, [&ready] { return ready; }, st);
          }
          /* ... */
        }
    });

    /* ... */

    //  `t`  request_stop()       .
}

type_traits , .

antoshkka C++14 CppCon. , . … , .

, . , type_traits :

Over dinner at CppCon, Marshall Clow and I discussed a bit of code that relied on two types being layout-compatible. As it happened, the types weren’t layout-compatible after all. I opined that there should be a way to statically assert layout-compatibility, so that the error would be caught at compile time, rather than dinner time. Marshall replied, “Write a proposal.” This is that proposal.
std::source_location, , .
unordered . .

, std::stacktrace, std::flat_map, std::flat_set C++20 :(

++23

, Boost.Process , /, , , 2d , , JIT C++ .

. std::filesystem::path_view. path_view , .

21

, , , , , , . , , std::format Inf/NaN; jthread; pair, tuple, string, array.

SG1 Concurrency concurrent_unordered_map. visit value , :

concurrent_unordered_map<int, std::string> conc_map;
conc_map.visit(42, [](std::string& value) { // ,  ....
    //    OK.  OK        value.
    std::cerr << value; 

    //    OK.  OK        value.
    value += "Hello"; 
});

.
, :

concurrent_unordered_map<int, std::atomic<int>> conc_map;
conc_map.visit(42, [](std::atomic<int>& value) { // ,  ....
    //  OK
    ++ value; 
});

SG6 Numerics — Numerics TS , wide_integer .

C++ Piter, .

21 ISO 9 ( , ). C++20 C++23.

C ++ 20 को बंडल किया गया है, C ++ 23 को प्रारंभ किया गया है। कोलोन में बैठक के परिणाम