I have been coding in C++ for past few 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?
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.
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. –
Hacking 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:
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.
int(3) = 5 is illegal, but would be legal if the temporary created by int(3) weren't required to be only an rvalue. –
Pietrek int(3) which is an rvalue. –
Jilly const and do not allow assignment. –
Pietrek int(3)" there is no temporary created here –
Warm std:string() = std:string("Hello, world") –
Warm 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.
2+2 has. –
Pietrek 2+2 yield a temporary? –
Hacking typedef foo<2+2> FooFour –
Jilly 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 @Pietrek in that 'references ARE the referent' and thus there can be no temporary reference... –
Hacking 2+2 is never a temporary. It is merely a value. I downvoted some answers because they claimed that things like 2+2 are temporaries. But that does not make sense. –
Latrinalatrine void f(int&) { }. –
Latrinalatrine 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.
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]) –
Hacking 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. –
Pietrek 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 rvalue although i want to assign to it. When i dereference it, it would become an lvalue. So yes all temporaries are rvalues. But you can make rvalues (thus a temporary) into an lvalue by dereferencing it
(c+2+4) is an rvalue, by definition. –
Warm *((char*)(ptr+offset))=9 an rvalue? i think this wouldnt compile if i dont deference it... ok so after i deference an rvalue is it a lvalue? –
Chilopod *((char*)(ptr+offset)) is an lvalue, and so is *((char*)(ptr+offset))=9. In C, only the first expression is a lvalue. "i think this wouldnt compile if i dont deference it..." (ptr+offset); would compile as a statement, so would 2+2;. Expressions with no effect whose result is also ignored are legal in C and C++. "ok so after i deference an rvalue is it a lvalue?" Dereferencing a pointer gets you a lvalue. –
Warm (char*)2+2= 0 wouldnt (rvalue being treated as lvalue) –
Chilopod 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.
If no, can anyone provide me an example where temporary produced in the code is an lvalue?
The following code binds a constant reference to a temporary object of type const float created by the compiler:
int i;
const float &cfr = i;
The behaviour is "as if":
int i;
const float __tmp_cfr = i; // introduced by the compiler
const float &cfr = __tmp_cfr;
i to float) is an rvalue. I hope someone can explain that better than me. –
Avoidance float(i) is indeed an rvalue, which gets bound to the constant reference. A hypothetical expression cfr would be an lvalue. –
Masterpiece float(i)" but this expression does not appear in the code fragment, so how can we call that: a virtual expression? –
Warm © 2022 - 2024 — McMap. All rights reserved.