No outro dia, houve uma reunião do comitê internacional de padronização C ++ em Colônia. Na última vez em que o congelamento de recursos foi adotado no C ++ 20, o comitê deve discutir apenas as correções de itens já aceitos e adicionar novos itens já no C ++ 23 ...
... mas não foi assim!
O que eles fizeram com std :: flat_map; As palavras-chave assustadoras co_return, co_await e co_yield permanecerão; você conseguiu terminar o formato std ::; Que tipo de contrato haverá em C ++ 20? Tudo isso espera por você sob o corte.
Grupo de Trabalho Evolução
Segunda-feira
O dia estava ocupado - decidimos renomear todos os conceitos em snake_case em vez de CamelCase. Além disso, a proposta
P1607 , que altera a sintaxe e o comportamento dos contratos para uma mais compreensível (mas também requer macros), foi
amplamente divulgada .
Terça-feira
Corutins discutiu. Rejeitou tudo, incluindo nossa proposta de
eliminar co_ das palavras-chave da corotina . Infelizmente.
Quarta-feira
De repente, percebemos que ninguém aprovou a proposta
P1607 aprovada na segunda-feira na prática, ela foi discutida por cerca de 30 minutos, enquanto a decisão existente sobre os contratos foi aprimorada por muitos anos.
Após uma longa discussão, eles decidiram que, em princípio, os contratos não estavam prontos para o C ++ 20. E os removeu do padrão.
Quinta-feira sexta-feira
Discutimos assuntos para C ++ 23. As principais forças estavam focadas em novos mecanismos no tratamento de erros. Havia
pensamentos gerais sobre o tópico e propostas específicas para um
novo especificador de exceção de lances .
Grupo de trabalho da biblioteca
O comitê possui um subgrupo LWG. Qualquer documento que adicione funcionalidade à biblioteca padrão deve passar por uma revisão neste subgrupo.
O rendimento médio do LWG é de ~ 30 documentos por semana. Em Colônia, foi necessário considerar mais de 50 documentos, entre os quais cerca da metade eram de tamanhos extremamente impressionantes, por exemplo:
*
std :: flat_map*
std :: jthread*
operador <=> para a biblioteca padrão*
Novas primitivas de sincronização+ O artigo veio do EWG para renomear conceitos no snake_case.
Qual dos aprovados anteriormente conseguiu arrastar para C ++ 20
- no constexpr, agora não é necessário inicializar zero cada variável . Abaixo int i {}; viva int i;.
- agora pode ser usado para construtores e destruidores. Portanto, agora na classe pode haver vários destruidores:
#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.