How to test lvalue or rvalue in this case

Question

The code is as following:

struct A
{
   static int k;
   int i;
};
 
int A::k = 10;
 
A func() { A a; return a; }

My question is, how can I tell whether func().k or func().i is an lvalue or not? If both are lvalues/rvalues, how can I test them?

func().k = 0; // compile ok under g++-4.4 and g++-4.6
func().i = 1; // compile ok with g++-4.4, but g++-4.4 gives an error: 
              //"using temporary as lvalue [-fpermissive]"

You can't "test" it. You just apply the rules of the grammar... — Kerrek SB, May 02 '13 at 19:22
If the compiler doesn't complain when you assign to it, it's an lvalue. — Kevin, May 02 '13 at 19:22
You want to check if the variables `k` and `i` are rvalues or not? — David G, May 02 '13 at 19:28
@AnotherTest I know, I just want to understand what he's asking. — David G, May 02 '13 at 19:29
@0x499602D2 I met this problem in an interview. It is easy to see that func().k is a lvalue, because we can assign values to it like `func().k=0`. But I am not sure about the case of `func().i=1`. — Shijing Lv, May 02 '13 at 20:06
I removed the C tag as C doesn't allow structs to have static members. — CB Bailey, May 02 '13 at 20:53
@Kevin: It might be an rvalue and the compiler not complain, if it is a user defined type. The terms lvalue and rvalue no longer refer to what side of an assignment the variable can be in. — David Rodríguez - dribeas, May 02 '13 at 20:58

score 4 · Accepted Answer · edited May 23 '17 at 12:29

4

func().k is an lvalue and func().i is an xvalue.

You can see this for more details: rvalues and temporary objects in the FCD

Althrough, it is not difficult to test whether they are lvalues or rvalues:

#include <iostream>

struct A
{
    static int k;
    int i;
};

int A::k = 10;

A func( ){ A a; return a; }

void f (int & ) { std::cout << "int& " << std::endl; }

int main ()
{
    func().k = 0;  //ok, because func().k is an r
    f(func().k);
    func().i = 1; //compile error: "using temporary as lvalue"
    f(func().i);  //compile error because func().i is an rvalue of type ‘int’
    return 0;
}

edited May 23 '17 at 12:29

Community

1
1

answered May 02 '13 at 19:59

Liu Xiaoqing

76
4

3

What makes you think that `func().i` is an _xvalue_? (`func()` returns by value so `func()` is a _prvalue_ so `func().i` is a _prvalue_, too, surely?) – CB Bailey May 02 '13 at 20:27

Aleph · Answer 2 · 2014-02-08T14:38:35.030

There is no need to actually "test" whether a given value is an lvalue or an rvalue.

Etymologically/Historically, an lvalue is what is on the left side of the assigment operator, and an rvalue what is on the right side. (This definition is not exactly correct though.) Note that rvalues can be lvalues.

Simple rule of thumb: If you can take its address, it's an lvalue. However, in C++11 there are rvalue references which makes things not that simple. So the rule is more like: if you can take its address using &.

Maybe some examples will clear things up:

int a = 5; // a is an lvalue, 5 is an rvalue
int b = fun(); // fun is an rvalue
fun() = a; // illegal, can't assign to an rvalue (suppose foo returns int)

See http://en.wikipedia.org/wiki/Value_%28computer_science%29 for more.

score 2 · Answer 3 · edited Jun 20 '20 at 09:12

"Assignability" isn't a good test for lvalueness as we can have non-mutable lvalues (e.g. const reference expressions) and assignment may be a member function call which can be made on an rvalue of class type.

You have to refer to the standard (ISO/IEC 14882:2011).

5.2.2/10: A function call is an lvalue if the result type is an lvalue reference type or an rvalue reference to function type, an xvalue if the result type is an rvalue reference to object type, and a prvalue otherwise.

So func() is a prvalue.

5.2.5/4: If E2 is declared to have type "reference to T," then E1.E2 is an lvalue; the type of E1.E2 is T. Otherwise, one of the following rules applies.

If E2 is a static data member and the type of E2 is T, then E1.E2 is an lvalue; the expression designates the named member of the class. The type of E1.E2 is T`.

So func().k is an lvalue.

If E2 is a non-static data member and the type of E1 is "cq1 vq1 X", and the type of E2 is "cq2 vq2 T", the expression designates the named member of the object designated by the first expression. If E1 is an lvalue, then E1.E2 is an lvalue; if E1 is an xvalue, then E1.E2 is an xvalue; otherwise, it is a prvalue. [...]

So func().i is a prvalue.

score 0 · Answer 4 · answered May 02 '13 at 19:27

0

I am not sure what exactly you are trying to achieve but as you are allocating memory within scope of function() returning that object. This object goes out of scope once the call to function() returns and hence it can be freed by the compiler. You can face a lot of troubles in later phases. I think you need to redesign the problem solution.

answered May 02 '13 at 19:27

csurfer

296
1
7

A copy is returned? Won't cause any problems. – Aleph May 02 '13 at 19:28
Depends on how the person uses it later. Better to be safe than sorry, right ? – csurfer May 02 '13 at 19:30

How to test lvalue or rvalue in this case

4 Answers4