c++20

This might be a stupid question, but I am confused. I had a feeling that an immediate ( consteval ) function has to be executed during compile time and we simply cannot see its body in the binary. This article clearly supports my feeling: This has the implication that the [immediate] function is only seen at compile time. Symbols are not emitted for the function, you cannot take the address of such a function, and tools such as debuggers will not be able to show them. In this matter, immediate functions are similar to macros. The similar strong claim might be found in Herb Sutter's publication

Context While I was reading Consistent comparison , I have noticed a peculiar usage of the verb to compare : There’s a new three-way comparison operator, <=> . The expression a <=> b returns an object that compares <0 if a < b , compares >0 if a > b , and compares ==0 if a and b are equal/equivalent. Another example found on the internet (emphasis mine): It returns a value that compares less than zero on failure. Otherwise, the returned value can be used as the first argument on a later call to get. One last example , found in a on GitHub (emphasis mine): // Perform a circular 16 bit compare.

I'm interested in studying the recently accepted contract programming for C++20 for learning and investigation purpose. As I'm looking around for compiler support, I'm disappointed to not find any. Both gcc and clang are quite clear they do not support this feature within their --std=c++2a mode. Since the approval is pretty recent, I'm not too surprised that current compilers do not support the exact semantic proposed. What is more surprising to me though is that there is absolutely nothing, not even a compiler-specific extension which would mimic, even in a limited way, the same feature. I

The cppreference shows that there are different rules for lambda closure type constructors. Default Construction - Until C++14 ClosureType() = delete; (until C++14) Closure types are not Default Constructible. Closure types have a deleted (until C++14)no (since C++14) default constructor. Default Construction - Since C++14 Closure types have no (since C++14) default constructor. Default Construction - Since C++20 If no captures are specified, the closure type has a defaulted default constructor. Otherwise, it has no default constructor (this includes the case when there is a capture-default,

This question is about C++20's [[likely]] / [[unlikely]] feature, not compiler-defined macros. This documents ( cppreference ) only gave an example on applying them to a switch-case statement. This switch-case example compiles perfectly with my compiler (g++-7.2) so I assume the compiler has implemented this feature, though it's not yet officially introduced in current C++ standards. But when I use them like this: if (condition) [[likely]] { ... } else { ... } , I got a warning: "warning: attributes at the beginning of statement are ignored [-Wattributes]". So how should I use these attributes

I was reading the cppreference page on Constraints and noticed this example: // example constraint from the standard library (ranges TS) template <class T, class U = T> concept bool Swappable = requires(T t, U u) { swap(std::forward<T>(t), std::forward<U>(u)); swap(std::forward<U>(u), std::forward<T>(t)); }; I'm puzzled why they're using std::forward . Some attempt to support reference types in the template parameters? Don't we want to call swap with lvalues, and wouldn't the forward expressions be rvalues when T and U are scalar (non-reference) types? For example, I would expect this program