There is no way to directly get the address of a lambda object within a lambda prior to c++23. Now, as it happens this is quite often useful. The most common use is in order to recurse. The y_combinator comes from languages where you could not talk about yourself until you where defined. It can … Read more
You can leverage std::function here which will give you an alias for the functions return type. This does require C++17 support, since it relies on class template argument deduction, but it will work with any callable type: using ReturnTypeOfFoo = decltype(std::function{foo})::result_type; We can make this a little more generic like template<typename Callable> using return_type_of_t = … Read more
From the proposal that suggested its deprecation: As an aid to writing iterator classes, the original standard library supplied the iterator class template to automate the declaration of the five typedefs expected of every iterator by iterator_traits. This was then used in the library itself, for instance in the specification of std::ostream_iterator: template <class T, … Read more
To convert a std::filesystem::path to a natively-encoded string (whose type is std::filesystem::path::value_type), use the string() method. Note the other *string() methods, which enable you to obtain strings of a specific encoding (e.g. u8string() for an UTF-8 string). C++17 example: #include <filesystem> #include <string> namespace fs = std::filesystem; int main() { fs::path path{fs::u8path(u8″愛.txt”)}; std::string path_string{path.u8string()}; } … Read more
The allocator requirements table says that construct(c, args), if provided, must “construct an object of type C at c“. It says absolutely nothing about 1) what arguments are to be passed to C‘s constructor or 2) how these arguments are to be passed. That’s the allocator’s choice, and in fact two allocators in the standard … Read more
This is CWG active issue 2118: Defining a friend function in a template, then referencing that function later provides a means of capturing and retrieving metaprogramming state. This technique is arcane and should be made ill-formed. Notes from the May, 2015 meeting: CWG agreed that such techniques should be ill-formed, although the mechanism for prohibiting … Read more
There is no X object, living or otherwise, so pretending that there is one results in undefined behavior. [intro.object]/1 spells out exhaustively when objects are created: An object is created by a definition ([basic.def]), by a new-expression ([expr.new]), when implicitly changing the active member of a union ([class.union]), or when a temporary object is created … Read more
Here’s a minimal complete solution that will do what you want. You can add more operators etc to make the class more useful as you see fit. #include <iostream> #include <string> #include <map> // define some tags to create uniqueness struct portal_tag {}; struct cake_tag {}; // a string-like identifier that is typed on a … Read more
try_emplace can indeed replace most uses of emplace, but if you have an unusual use case of a map with a non-copyable and immovable key type, try_emplace will not work because it copies or moves the key. In that case, you must use emplace with std::pair‘s piecewise construction constructor to avoid copies and moves. Even … Read more
A std::string_view doesn’t provide a conversion to a const char* because it doesn’t store a null-terminated string. It stores a pointer to the first element, and the length of the string, basically. That means that you cannot pass it to a function expecting a null-terminated string, like foo (how else are you going to get … Read more