Is bar an rvalue or an lvalue? The question answers itself. Whatever has a name is an lvalue(1). So bar is an lvalue. Its type is “rvalue reference to string“, but it’s an lvalue of that type. If you want to treat it as an rvalue, you need to apply std::move() to it. If you … Read more
As @gudok answered before, everything is in the implementation… Then a bit is in user code. The implementation Let’s assume we’re talking about the copy-constructor to assign a value to the current class. The implementation you’ll provide will take into account two cases: the parameter is a l-value, so you can’t touch it, by definition … Read more
Both i and j are glvalues (see this value category reference for details). Then if you read this conditional operator reference we come to this point: 4) If E2 and E3 are glvalues of the same type and the same value category, then the result has the same type and value category So the result … 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
Other people have tackled the functional difference between post and pre increment. As far as being an lvalue is concerned, i++ can’t be assigned to because it doesn’t refer to a variable. It refers to a calculated value. In terms of assignment, both of the following make no sense in the same sort of way: … Read more
There is not much of a sane choice other than offering two overloads or making your function a template, I would say. If you really, really need an (ugly) alternative, then I guess the only (insane) thing you can do is to have your function accept a const&, with a pre-condition saying that you cannot … 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
This is a gcc bug. The problem is that gcc incorrectly treats the expression !(!b) as an lvalue instead of rvalue. You can confirm this here. As you’ll see in the above linked demo, the output gcc gives is lvalue instead of prvalue. The bug has been reported as: GCC treats rvalue as an lvalue
The address operator returns a pointer to something having a “home”, e.g. a variable. The value of the expression in your code is “homeless”. if you really need a *string, you’ll have to do it in 2 steps: tmp := a(); b := &tmp Note that while there are completely valid use cases for *string, … Read more