rvalue

Consider the below. #include <string> using std::string; string middle_name () { return "Jaan"; } int main () { string&& danger = middle_name(); // ?! return 0; } This doesn't compute anything, but it compiles without error and demonstrates something that I find confusing: danger is a dangling reference, isn't it? Do rvalue references allow dangling references? If you meant "Is it possible to create dangling rvalue references" then the answer is yes. Your example, however, string middle_name () { return "Jaan"; } int main() { string&& nodanger = middle_name(); // OK. // The life-time of the

This question already has an answer here: How can a returned object be assignable? 1 answer The " Effective C++ " Item 3 says "Use const whenever possible", and it gives an example like: const Rational operator*(const Rational& lhs, const Rational& rhs); to prevent clients from being able to commit atrocities like this: Rational a, b, c; ... (a * b) = c; // invoke operator= on the result of a*b! But isn't the non-reference return value of functions allready a rvalue ? So why bother doing this? TemplateRex The point is that for class types (but not for builtin types), a = b is just a shorthand

PREMISE: The C++11 Standard classifies expressions into three disjoint value categories : lvalues , xvalues , and prvalues (§ 3.10/1). An explanation of what value categories are is available for instance here . I am struggling to figure out what are the requirements of the different operators on the value category of their operands. Paragraph 3.10/1 specifies: [...] Every expression belongs to exactly one of the fundamental classifications in this taxonomy: lvalue, xvalue, or prvalue. This property of an expression is called its value category. [ Note: The discussion of each built-in operator

Here is some example code: #include <iostream> class Foo { public: explicit Foo(int x) : data(x) {}; Foo& operator++() { data += 1; return *this; } void *get_addr() { return (void*)this; } friend Foo operator + (const Foo& lhs, const Foo& rhs); friend std::ostream& operator << (std::ostream& os, const Foo& f); private: int data; }; std::ostream& operator << (std::ostream& os, const Foo& f) { return (os << f.data); } Foo operator + (const Foo& lhs, const Foo& rhs) { return Foo(lhs.data + rhs.data); } void bar(Foo& f) { std::cout << "bar(l-value ref)" << std::endl; } void bar(const Foo& f) { std

Just wonder if a literal string is an lvalue or an rvalue. Are other literals (like int, float, char etc) lvalue or rvalue? Is the return value of a function an lvalue or rvalue? How do you tell the difference? string literals are lvalues, but you can't change them rvalue, but if it's a pointer and non-NULL, the object it points to is an lvalue The C standard recognizes the original terms stood for left and right as in L = R ; however, it says to think of lvalue as locator value , which roughly means you can get the address of an object and therefore that object has a location. (See 6.3.2.1 in