The 2nd template parameter of std::set expects a type, not an expression, so it is just you are using it wrongly. You could create the set like this: auto comp = [](const A& lhs, const A& rhs) -> bool { return lhs.x < rhs.x; }; auto SetOfA = std::set <A, decltype(comp)> (comp);
The compilers are caught in a dilemma here, for the following reasons: (1) Not specifying any exceptions in a function declaration (i.e. not using throw nor noexcept (which is equivalent to noexcept(true) )) means to allow that function to throw all possible exceptions: (§15.4/12, emphasis mine) A function with no exception-specification or with an exception-specification … Read more
There is indeed a way for non-final non-union class types: namespace detail { struct P {typedef int member;}; template <typename U> struct test_for_member : U, P { template <typename T=test_for_member, typename = typename T::member> static std::false_type test(int); static std::true_type test(float); }; } template <typename T> using test_for_member = std::integral_constant<bool, decltype(detail::test_for_member<T>::test(0)){}>; Demo. The trick is to … Read more
The reason this fails is because when you specify foo<Movable>, the function you’re binding to is: void foo(Movable&&) // *must* be an rvalue { } However, the value passed by std::bind will not be an rvalue, but an lvalue (stored as a member somewhere in the resulting bind functor). That, is the generated functor is … Read more
Disclaimer: my answer is somewhat simplified compared to the reality (I put some details aside) but the big picture is here. Also, the Standard does not fully specify how lambdas or std::function must be implemented internally (the implementation has some freedom) so, like any discussion on implementation details, your compiler may or may not do … Read more
This is now possible with C++20, with syntax like: const std::string s = std::move(ss).str(); This is possible because the std::ostringstream class now has a str() overload that is rvalue-ref qualified: basic_string<charT, traits, Allocator> str() &&; // since C++20 This was added in P0408, revision 7, which was adopted into C++20. This is the exact approach … Read more
Insert(key, Value()); // Compiler error here key here is Key&& key – this is an lvalue! It has a name, and you can take its address. It’s just that type of that lvalue is “rvalue reference to Key“. You need to pass in an rvalue, and for that you need to use std::move: Insert(std::move(key), Value()); … Read more
This code was written before I had std::max_align_t in my toolbox (which now lives in <cstddef>). I would now write this as: static const std::size_t alignment = alignof(std::max_align_t); which on my system is exactly equivalent to the current code, but now more portable. This is the alignment which new and malloc are guaranteed to return. … Read more
It’s not an oversight. It’s interesting, that in Decltype and auto (revision 4) (N1705=04-0145) there is a statement: The decltype rules now explicitly state that decltype((e)) == decltype(e)(as suggested by EWG). But in Decltype (revision 6): proposed wording (N2115=06-018) one of the changes is Parenthesized-expression inside decltype is not considered to be an id-expression. There … Read more
That leeway wording doesn’t mean that any and everything in C99 is in C++11. What you quoted is just introductory text.