Geekly articles weekly

C ++ 20 est intégré, C ++ 23 est démarré. Résultats de la réunion à Cologne

L'autre jour, il y a eu une réunion du comité international de normalisation C ++ à Cologne. La derniÚre fois, le gel des fonctionnalités a été adopté en C ++ 20, donc le comité ne devrait discuter que des corrections de choses déjà acceptées, et ajouter de nouveaux éléments déjà en C ++ 23 ...

... mais ce n'Ă©tait pas le cas!



Qu'ont-ils fait avec std :: flat_map; Les mots-clés effrayants co_return, co_await et co_yield resteront-ils; avez-vous réussi à terminer std :: format; Quels types de contrats seront en C ++ 20? Tout cela vous attend sous la coupe.

Groupe de travail sur l'Ă©volution


Lundi


La journée était chargée - nous avons décidé de renommer tous les concepts dans snake_case au lieu de CamelCase. En outre, la proposition P1607 , qui change la syntaxe et le comportement des contrats en un langage plus compréhensible (mais nécessitant également des macros), a été largement exprimée .

Mardi


Les corutines ont discuté. Tout rejeté, y compris notre proposition de supprimer co_ des mots clés pour coroutine . Hélas.

Mercredi


Soudain, nous avons réalisé que personne n'avait approuvé la proposition P1607 approuvée lundi dans la pratique, elle a été discutée pendant environ 30 minutes, alors que la décision existante sur les contrats était affinée depuis de nombreuses années.

AprĂšs une longue discussion, ils ont dĂ©cidĂ© que les contrats n'Ă©taient en principe pas prĂȘts pour C ++ 20. Et les a retirĂ©s de la norme.

Jeudi vendredi


Discuté de choses pour C ++ 23. Les principales forces se sont concentrées sur de nouveaux mécanismes de gestion des erreurs. Il y avait à la fois des réflexions générales sur le sujet et des propositions spécifiques pour un nouveau spécificateur d'exception de levée .

Groupe de travail de la bibliothĂšque


Le comitĂ© a un sous-groupe LWG. Tout document ajoutant des fonctionnalitĂ©s Ă  la bibliothĂšque standard doit ĂȘtre examinĂ© dans ce sous-groupe.

Le dĂ©bit moyen de LWG est d'environ 30 documents par semaine. À Cologne, il a fallu prendre en compte plus de 50 documents, dont environ la moitiĂ© Ă©taient de taille extrĂȘmement impressionnante, par exemple:
* std :: flat_map
* std :: jthread
* opérateur <=> pour la bibliothÚque standard
* Nouvelles primitives de synchronisation
+ Le papier est venu d'EWG pour renommer les concepts dans snake_case.

Laquelle des versions précédemment approuvées a réussi à faire glisser vers C ++ 20


  • dans constexpr, il n'est plus nĂ©cessaire d'initialiser Ă  zĂ©ro chaque variable . A bas avec int i {}; vive int i;.
  • require peut dĂ©sormais ĂȘtre utilisĂ© pour les constructeurs et les destructeurs. En consĂ©quence, maintenant dans la classe il peut y avoir plusieurs destructeurs:

    #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.

Source: https://habr.com/ru/post/fr458938/

More articles:


All Articles