Indeed, C++20 unfortunately makes this code infinitely recursive. Here’s a reduced example: struct F { /*implicit*/ F(int t_) : t(t_) {} // member: #1 bool operator==(F const& o) const { return t == o.t; } // non-member: #2 friend bool operator==(const int& y, const F& x) { return x == y; } private: int t; … Read more
You’re right that the main reason was removed. There are still the don’t use new guidelines and that it is less typing reasons (don’t have to repeat the type or use the word new). Admittedly those aren’t strong arguments but I really like not seeing new in my code. Also don’t forget about consistency. You … Read more
Copy elision was permitted to happen under a number of circumstances. However, even if it was permitted, the code still had to be able to work as if the copy were not elided. Namely, there had to be an accessible copy and/or move constructor. Guaranteed copy elision redefines a number of C++ concepts, such that … Read more
The structured bindings proposal contains a dedicated section answering your question (P0144R2): 3.8 Should there be a way to explicitly ignore components? The motivation would be to silence compiler warnings about unused names. We think the answer should be “not yet.” This is not motivated by use cases (silencing compiler warnings is a motivation, but … Read more
Modern CMake propose an interface for this purpose target_compile_features. Documentation is here: Requiring Language Standards Use it like this: target_compile_features(${TARGET_NAME} PRIVATE cxx_std_17)
The reason for this is given in n3512 string_ref: a non-owning reference to a string, revision 2 by Jeffrey Yasskin: I also omitted operator+(basic_string, basic_string_ref) because LLVM returns a lightweight object from this overload and only performs the concatenation lazily. If we define this overload, we’ll have a hard time introducing that lightweight concatenation later. … Read more
The Filesystem TS is nothing to do with C++1z support, it is a completely separate specification not part of the C++1z working draft. GCC’s implementation (in GCC 5.3 and later) is even available in C++11 mode. You just need to link with -lstdc++fs to use it. (The relevant library, libstdc++fs.a, is a static library, so … Read more
Core issue 2313 changed the standard so that structured bindings are never names of variables, making them never capturable. P0588R1’s reformulation of lambda capture wording makes this prohibition explicit: If a lambda-expression […] captures a structured binding (explicitly or implicitly), the program is ill-formed. Note that this wording is supposedly a placeholder while the committee … Read more
The program is ill-formed (clang is right) per [dcl.spec.auto]/9: If the name of an entity with an undeduced placeholder type appears in an expression, the program is ill-formed. Once a non-discarded return statement has been seen in a function, however, the return type deduced from that statement can be used in the rest of the … Read more
Use std::exchange: if (static bool do_once = true; std::exchange(do_once, false)) You can make it shorter reversing the truth value: if (static bool do_once; !std::exchange(do_once, true)) But if you are using this a lot, don’t be fancy and create a wrapper instead: struct Once { bool b = true; explicit operator bool() { return std::exchange(b, false); … Read more