Don’t worry about that. According to the same information source: this library component should be retired to Annex D, along side , until a suitable replacement is standardized. So, you can still use it until a new standardized, more-secure version is done.
Here is at least one case: struct foo { template<class T> operator T() const { std::cout << sizeof(T) << “\n”; return {}; } }; if you do foo f; int x = f; double y = f;, type information will flow “backwards” to figure out what T is in operator T. You can use this … Read more
Is it guaranteed that all compliant compilers have the same experimental features? No, experimental features are optional. Are experimental features prone to big changes that make them unreliable? Yes, the C++ committee might even decide to abandon a feature or in the process of standardization a defect might come up that would force a feature … Read more
You are missing a semicolon after the attribute: case 0: std::cout << “a\n”; [[fallthrough]]; // ^ case 1: The [[fallthrough]] attribute is to be applied to an empty statement (see P0188R1). The current Clang trunk gives a helpful error in this case: error: fallthrough attribute is only allowed on empty statements [[fallthrough]] ^ note: did … Read more
The intent of these constants is indeed to get the cache-line size. The best place to read about the rationale for them is in the proposal itself: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html I’ll quote a snippet of the rationale here for ease-of-reading: […] the granularity of memory that does not interfere (to the first-order) [is] commonly referred to as … Read more
<filesystem> (added in C++17) makes this very straightforward. #include <cstdint> #include <filesystem> // … std::uintmax_t size = std::filesystem::file_size(“c:\\foo\\bar.txt”); As noted in comments, if you’re planning to use this function to decide how many bytes to read from the file, keep in mind that… …unless the file is exclusively opened by you, its size can be … Read more
There’s the free-function route, but unless you also provide overloads for std::string it’s a snake-pit. #include <string> #include <string_view> std::string_view sub_string( std::string_view s, std::size_t p, std::size_t n = std::string_view::npos) { return s.substr(p, n); } int main() { using namespace std::literals; auto source = “foobar”s; // this is fine and elegant… auto bar = sub_string(source, 3); … Read more
The problem is that std::string_view -> std::string makes a copy of the underlying memory, complete with heap allocation, whereas the implicit std::string -> std::string_view does not. If you’ve bothered to use a std::string_view in the first place then you obviously care about copies, so you don’t want one to happen implicitly. Consider this example: void … Read more
Some common cases where the evaluation order has so far been unspecified, are specified and valid with C++17. Some undefined behaviour is now instead unspecified. i = 1; f(i++, i) was undefined, but it is now unspecified. Specifically, what is not specified is the order in which each argument to f is evaluated relative to … Read more
Template deduction guides are patterns associated with a template class that tell the compiler how to translate a set of constructor arguments (and their types) into template parameters for the class. The simplest example is that of std::vector and its constructor that takes an iterator pair. template<typename Iterator> void func(Iterator first, Iterator last) { vector … Read more