c++20

In pre-Range TS code, I might do something like the following to get a (potentially modifiable) reference to a ForwardIterator's value: auto &val = *it; This would also be used in range-based for loops over such iterators: for(auto &val : some_range) However, in C++20 and Range TS-based code, I'm seeing a lot of auto&& usage in these locations. I understand what auto&& is doing from a language standpoint. What I don't understand is why it's being used in these places, when auto& ought to work just fine? Most code of this nature isn't forwarding the reference, so why is it using a forwarding

Yakk - Adam Nevraumont said : Non-type template parameters of type void* are not allowed in at least some versions of the standard. Is this true? If it is true, in which versions of the standard are non-type template parameters of type void* not allowed? (Note: as noted in a comment to answer another comment , this is about non-type template parameters , not template type arguments , which can be any valid type-id per [temp.arg.type] , including void* . TL;DR Template parameters of type void* are valid since C++20. They are invalid prior to C++20. C++20 C++20 relaxed the restrictions on the

Consider the following code: #include <cctype> #include <functional> #include <iostream> int main() { std::invoke(std::boolalpha, std::cout); // #1 using ctype_func = int(*)(int); char c = std::invoke(static_cast<ctype_func>(std::tolower), 'A'); // #2 std::cout << c << "\n"; } Here, the two calls to std::invoke are labeled for future reference. The expected output is: a Is the expected output guaranteed in C++20? (Note: there are two functions called tolower — one in <cctype> and the other in <locale> . The explicit cast is introduced to select the desired overload.) Short answer No.