tags:

views:

121

answers:

4

I was wondering, why the following way of code (Already commented out) will cause
C2102: '&' requires l-value

Is there a better way to avoid using tmp variable?

class a {
private:
    int *dummy;
public:
    int* get_dummy() const {
        return dummy;
    }
};

int main()
{
    a aa;

    // error C2102: '&' requires l-value
    //int** me = &(aa.get_dummy());

    // OK!
    int *tmp = aa.get_dummy();
    int** me = &(tmp);
}
+4  A: 

No.

What address would me contain otherwise? Here you gave it the address of tmp -- but if you replace it with int** me = &aa.get_dummy();, where would it point?

There's no meaningful answer to that question, so the standard requires that the argument of & be an lvalue.

Billy ONeal
`where would it point?` - Isn't it point to the address of dummy instance?
Yan Cheng CHEOK
@Yan: No. The function returns the address (or value) stored by `dummy`, not `dummy` itself.
Billy ONeal
DeadMG
+3  A: 

You could instead define:

int **get_dummy() ... return &dummy;

You can think of an r-value as an expression, essentially, whereas an l-value is an actual object. Expressions don't have addresses, and even if they did, it's hard to imagine what good the address would be. It's easy to understand how the address of an object can be useful.

It's a bit hard to understand an issue like this abstractly. The very best way to develop an understanding of pointers and compiled languages is to learn assembly language.

DigitalRoss
+1 for suggesting a reasonable solution to the problem.
Billy ONeal
I do not have access to the get_dummy source code.
Yan Cheng CHEOK
DigitalRoss
@DigitalRoss, be it global, member or local variable, as long as its lifetime exceed the referrer, the "danger" of dangling pointer is non-existent.
YeenFei
A: 

The & operator must be applied to an lvalue. When the call aa.get_dummy() is not assigned to a variable, its return value is only put on the stack, so it would be silly (and erroneous) to get the address of a stack item.

Luca Martini
Err.. `tmp` is a stack item.
Billy ONeal
I meant unnamed stack item
Luca Martini
A: 

Because a::get_dummy() returns a unnamed temporary object (int pointer).
Object returned by function sit ontop of the stack frame and it is meaningless to get its address since it might be invalid after expression ends.

YeenFei
Same issue as Luca's answer. `tmp` is a stack object!
Billy ONeal
`dummy` is not a temporary object or a local object.
Naveen
@Naveen: Yes, that is true. But the answer doesn't say "unnamed temporary" (which lives until the end of it's full expression), it says "stack object" which typically means an object in "automatic" storage which lives until the end of it's scope.
Billy ONeal
@Billy, added the "unnamed" onto my answer. but i dont see "stack object" in my reply that you are referring to.
YeenFei
@YeenFei: Stack object is implied by "top of the stack frame" and "out of scope". `tmp` is **also** invalid when it goes out of scope. Unnamed compiler temporaries have *absolutely nothing* to do with scope. They live until the end of their owning full expression.
Billy ONeal
@Naveen: We are not returning dummey (as that would require a reference). We are returning a copy of dummy (a pointer) as such it is not a variable and thus we can not take its address. So yes this is a temporary (think of it as a temporary pointer).
Martin York
@Billy, alright, i always referred "expression lifetime" as scope, guess that wasn't the word others use.
YeenFei
@YeenFei: Scope has a very specific meaning according to the standard. see section 3.3 for an exhaustive definition (which is 2 pages long). In this case, though, we are concerned only with block scope (section 3.3.3), which is "merely" half a page long.
Billy ONeal
@Billy, edited usage of "scope" in my answer to "expression". The "top of stack frame" remains true unless it is assigned to a reference (and new temporaries can be placed on top instead of over it).
YeenFei