Firstly, the expected difference in behaviour is because the operator<<(std::ostream&, const char*) overload (it’s actually a function template specialization, but nevermind for now) has a parameter of type std::ostream& and an lvalue reference can only bind to an lvalue, and in your example the stream is an rvalue so that overload can’t be used. In … Read more
I’ll answer your question… the other way around. Why did they allowed Foo const& foo = fooByValue(); to begin with ? It makes life (somewhat) easier, but introduces potential undefined behavior all over the place. Foo const& fooByReference() { return fooByValue(); // error: returning a reference to a temporary } This is obviously wrong, and … Read more
A good place to start would be Howard Hinnant’s answer and paper on std::forward(). Your implementation handles all the normal use-cases correctly (T& –> T&, T const& –> T const&, and T&& –> T&&). What it fails to handle are common and easy-to-make errors, errors which would be very difficult to debug in your implementation … Read more
Most of the work is already done for you by the stdlib, you just need a function wrapper: template <typename T> constexpr bool is_lvalue(T&&) { return std::is_lvalue_reference<T>{}; } in the case you pass a std::string lvalue then T will deduce to std::string& or const std::string&, for rvalues it will deduce to std::string Note that Yakk’s … Read more
&std::string(“Hello World”) The problem with this isn’t that std::string(“Hello World”) yields a temporary object. The problem is that the expression std::string(“Hello World”) is an rvalue expression that refers to a temporary object. You cannot take the address of an rvalue because not all rvalues have addresses (and not all rvalues are objects). Consider the following: … Read more
should that work in c++11? No, it should not. Foo is a custom class, I don’t understand why the first two line compiles It compiles only with MSVC. MSVC has an (arguably useful) compiler extension that allows binding lvalues of user-defined types to rvalues, but the Standard itself forbids this. See, for instance, this live … Read more
The point is that for class types (but not for builtin types), a = b is just a shorthand to a.operator=(b), where operator= is a member function. And member functions can be called on rvalues such (a * b) created by Rational::operator*. To enforce similar semantics as for builtin rvalues (“do as the ints do“) … Read more
Yes, it’s ill-specified and has been covered before. Basically, every time an lvalue expression is required is enumerated, so we assume that every other operand must be a prvalue expression. So to answer your questions: A prvalue. If it’s not specified, it’s a prvalue. The note that is quoted in the linked answer seems 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
This is one of the most common “rules of thumb” used to explain what is the difference between lvalues and rvalues. The situation in C++ is much more complex than that so this can’t be nothing but a rule of thumb. I’ll try to resume a couple of concepts and try to make it clear … Read more