views:

476

answers:

6

I have been coding in C++ for the last 6 years. But there is one question that I have not been able to figure out. I want to ask, are all temporaries in C++, rvalues?

If no, can anyone provide me an example where temporary produced in the code is an lvalue?

+1  A: 

An array indexing operation is both a temporary and an lvalue, something like a[10] = 1 is an example of what you're looking for; the lvalue is a temporary, calculated pointer.

Andrew McGregor
Beat me to it. An array index is always an lvalue and the results of the calculation to get there is temporary.
Travis Gockel
I semi disagree. a[10] is a native instruction in CPUs. It does not create a temporary pointer.
acidzombie24
The expression (assuming an int array) will not yield a calculated pointer, but rather a reference obtained by dereferencing the pointer. Even if `a[10]` is not a native type, but a user defined operation (the type of `a` is a class such that `operator[](int)` is defined, such as vector), only if it returns a reference (all references are lvalue-s) the operation would compile (assuming that there is some `operator=(int)` defined for the type of `a[10]`)
David Rodríguez - dribeas
There's no temporary object in that expression. You call `a.operator[](int)` and it returns a reference to an existing object. Nothing is necessarily created. In the case of `map::operator[]`, a *permanent* object is created, not a temporary. In the case of `vector<bool>::operator[]` a temporary object with `operator=` defined is created, but it's technically not an lvalue.
Potatoswatter
a[10] may be implemented as an indirect addressing mode in the CPU, but that doesn't change the formal existence of a calculated pointer there. However, if references are not technically lvalues... well, ok, point.
Andrew McGregor
+1  A: 

well, that array operator returns a reference, any function that returns a reference could be considered to do the same thing? all references are const, while they can be lvalues, they modify what they reference, not the reference itself. same is true for the *operator,

*(a temp pointer) = val;

I swear I used to use some compiler that would pass temp values to any function that took a reference,

so you could go:

int Afunc()
{
   return 5;
}

int anotherFunc(int & b)
{
    b = 34;
}


anotherFunc(Afunc());

can't find one that lets you do that now though, the reference has to be const in order to allow passing of temp values.

int anotherFunc(const int & b);

anyway, references can be lvalues and temporary, the trick being the reference it's self is not modified, only what it references.

if you count the-> operator as an operator, then temporary pointers can be lvalues, but the same condition applies, its not the temp pointer that would be changed, but the thing that it points to.

matt
The tricky part there is whether you can say that a reference is a temporary. I would not consider them to be temporaries, but then again that is just a gut feeling... after all the reference has entity (it exists, takes up space), is unnamed and will disappear right after the execution of the sentence... quite temporary...
David Rodríguez - dribeas
@David: the only question is whether "temporary" is taken to be shorthand for "temporary object." Temporary objects are described by §12.2 and don't include references.
Potatoswatter
@David: Being written out to RAM is immaterial. References go further than RAM or registers, though, because they really aren't supposed to *exist* like true objects. "The reference is the referent" or just a name for the object, perhaps implemented using a pointer under the hood but not constructed and without even the explicit lifetime that `2+2` has.
Potatoswatter
Does `2+2` yield a temporary?
David Rodríguez - dribeas
Depending on the context, yes. Not if used as an (compile-time) integral constant expression, e.g. as a template argument: `typedef foo<2+2> FooFour`
MSalters
The point with the `x+2` being considered a temporary is that the standard in section 12.2 does not include it. So if we are to assume that the return of the sum of two integers is a temporary, then not all temporaries are described in 12.2, and that takes us back to whether you can consider a reference to be a temporary... At this point, I agree with @Potatoswatter in that 'references ARE the referent' and thus there can be no temporary reference...
David Rodríguez - dribeas
due to operator overloads, I would consider all operators ([], +, or whatever) functions, and hence return temporaries. (except ones done at compile time.)
matt
+1  A: 

It depends on what you consider a temporary variable is. You can write something like

#include <stdio.h>
int main()
{
    char carray[10];
    char *c=carray+1;
    *(c+2+4) = 9;
    printf("%d\n",carray[7]);
    return 0;
}

This runs in VisualStudios and GCC. You can run the code in codepad

I consider (c+2+4) a temporary lvalue even though it isnt being assigned to. It holds the address of where to assign the variable but without the temporary the left side wouldnt work. Do you consider it as an lvalue if it isnt being written too? I sure do if its being used.

acidzombie24
Given a pointer expression E, the result of *E is a lvalue, regardless of whether evaluating E yields a temporary. Note that the result of E is not *E!! the temporary is not the lvalue, but rather a pointer into it.
David Rodríguez - dribeas
Exactly. Nice comment to make my answer more clear.
acidzombie24
A: 

Short answer: yes, but I'm not going to quote the standard, because proving the point would require addressing every kind of temporary there is. By definition a temporary has a lifetime of one statement, so assigning things to one would be poor style at best.

Interesting answer: Copy elision can make (often makes) a temporary object identical with an lvalue object. For example,

MyClass blah = MyClass( 3 ); // temporary likely to be optimized out

or

return MyClass( 3 ); // likely to directly initialize object in caller's frame

Edit: as for the question of whether there is any temporary object in those cases, §12.8/15 mentions

the copy operation can be omitted by constructing the temporary object directly into the target of the omitted copy

which would indicate that there is a temporary object which may be identical with an lvalue.

Potatoswatter
+3  A: 

Prasoon Saurav already linked a very good clc++ thread. In there, James Kanze explains why the question doesn't really make sense. It boils down to:

  • rvalue-ness is a (boolean) property of expressions - each expression is either an lvalue or an rvalue
  • temporaries are not expressions

For that reason, the question doesn't make sense.

A good example is the following code:

int main() {
  const int& ri = 4;
  std::cout << ri << std::endl; 
}

The temporary int with value 4 is not an expression. The expression ri that's printed is not a temporary. It's an lvalue, and refers to a temporary.

MSalters
Expressions may be temporaries. For example `int(3) = 5` is illegal, but would be legal if the temporary created by `int(3)` weren't required to be only an rvalue.
Potatoswatter
No, it doesn't work that way. Expressions may _create_ temporaries, or _refer_ to temporaries, but they are not temporaries themselves. They're just different beasts. And to take your example, it's the _expression_ `int(3)` which is an rvalue.
MSalters
You're making an imaginary distinction. Expressions do nothing besides create and refer to values. The evaluation of an expression may result in a handle to a temporary object. It may result in a handle through which assignment is allowed or disallowed. The question of whether a handle to a temporary ever allows assignment is valid.
Potatoswatter
(1) Sorry, but try building a compiler if you can't see the distinction. The distinction is subtle, but not imaginary. (2) That may be a valid question, but it's not the question he asked. And to clarify: the LHS of an assignment expression is an expression itself, and an lvalue expression to be precise.
MSalters
(1) Once raw text is turned into an AST, a (well-designed) compiler manipulates a graph of values. If you want to pass a piece of data from the grammar to the code generator, you'd better find a value or a control-flow structure to hang it on. (2) As I said, an expression may yield a handle to an object allowing assignment. Handles to objects which are temporary in the current scope do not allow assignment, although (and this was my error earlier) some lvalues are `const` and do not allow assignment.
Potatoswatter
And by "handle to an object" I simply mean value, just trying to be clear despite the notion that an expression itself has entity in terms of the program.
Potatoswatter
+7  A: 

No.

The C++ language specification never makes such a straightforward assertion as the one you are asking about. It doesn't say anywhere in the language standard that "all temporary objects are rvalues". Moreover, the question itself is a bit of misnomer, since the property of being an rvalue in the C++ language is not a property of an object, but rather a property of an expression (i.e. a property of its result). This is actually how it is defined in the language specification: for different kinds of expressions it says when the result is an lvalue and when it is an rvalue. Among other things, this actually means that a temporary object can be accessed as an rvalue as well as an lvalue, depending on the specific form of expression that is used to perform the access.

For example, the result of literal 2 + 3 expression is obviously an rvalue, a temporary of type int. We cannot apply the unary & to it since unary & requires an lvalue as its operand

&(2 + 3); // ERROR, lvalue required

However, as we all know, a constant reference can be attached to a temporary object, as in

const int &ri = 2 + 3;

In this case the reference is attached to the temporary, extending the lifetime of the latter. Obviously, once it is done, we have access to that very same temporary as an lvalue ri, since references are always lvalues. For example, we can easily and legally apply the unary & to the reference and obtain a pointer to the temporary

const int *pi = &ri;

with that pointer remaining perfectly valid as long as the temporary persists.

Another obvious example of lvalue access to a temporary object is when we access a temporary object of class type through its this pointer. The result of *this is an lvalue (as is always the case with the result of unary * applied to a data pointer), yet it doesn't change the fact that the actual object might easily be a temporary. For a given class type T, expression T() is an rvalue, as explicitly stated in the language standard, yet the temporary object accessed through *T().get_this() expression (with the obvious implementation of T::get_this()) is an lvalue. Unlike the previous example, this method allows you to immediately obtain a non-const-qualified lvalue, which refers to a temporary object.

So, once again, the very same temporary object might easily be "seen" as an rvalue or as an lvalue depending on what kind of expression (what kind of access path) you use to "look" at that object.

AndreyT
excellent answer.
acidzombie24
I agreed with this sentence: 'being an rvalue in the C++ language is not a property of an object, but rather a property of an expression'. But then again, the standard is not quite so consistent: 5.2.3/2 defines `T()` as an expression that 'creates an rvalue of the specified type'. My understanding (english is not my native language) is that 'rvalue' is used as a property of the created instance, and not the expression itself.
David Rodríguez - dribeas