Assigning value to function returning reference

Question

#include<iostream>
using namespace std;

int &fun()
{
  static int x = 10;
  return x;
}
int main()
{
   fun() = 30;
   cout << fun();
   return 0;
}

Function fun() is returning value by reference but in main() method I am assigning some int to function. Ideally, a compiler should show an error like lvalue required but in above case the program works fine. Why is it so?

Answer 1

It's loose and sloppy language to say "a function returns something". It's OK as a shorthand if you know how to work with that, but in this case you get confused.

The more correct way to think about it is that you evaluate a function call expression. Doing that gives you a value. A value is either an rvalue or an lvalue (modulo details).

When T is an object type and you evaluate a function that has return type T, you get a value of type T which is an rvalue. On the other hand, if the function has return type T &, you get a value of type T which is an lvalue (and the value is the thing bound to the reference in the return statement).

Answer 2

Returning a reference is quite useful.

For example it's what std::map::operator[] does. And I hope you like the possibility of writing my_map[key] = new_value;.

If a regular (non-operator) function returns a reference then it's ok to assign to it and I don't see any reason for which this should be forbidden.

You can prevent assignment by returning a const X& or by returning X instead if you really want.

Answer 3

You can rewrite the code using pointers, which might be easier to understand:

#include<iostream> 
using namespace std; 

int *fun() //fun defined to return pointer to int
{ 
    static int x = 10; 
    return &x; // returning address of static int
} 
int main() 
{ 
    *fun() = 30; //execute fun(), take its return value and dereference it,
                 //yielding an lvalue, which you can assign to. 
    cout << *fun();  //you also need to dereference here
    return 0; 
}

References can be very confusing from a syntax point of view, as the dereferencing of the underlying "pointer" is implicitly done by the compiler for you. The pointer version looks more complicated, but is clearer or more explicit in its notation.

PS: Before someone objects to me regarding references as being a kind of pointer, the disassembly for both code versions is 100% identical.

PPS: Of course this method is a quite insidious breach of encapsulation. As others have pointed out, there are uses for this technique, but you should never do something like that without a very strong reason for it.

Answer 4

It works becuse the result of that function is an lvalue. References are lvalues. Basically, in the whole point of returning a non-const reference from a function is to be able to assign to it (or perform other modifications of referenced object).

Answer 5

In addition to other answers, consider the following code:

SomeClass& func() { ... }

func().memberFunctionOfSomeClass(value);

This is a perfectly natural thing to do, and I'd be very surprised if you expected the compiler to give you an error on this.

Now, when you write some_obj = value; what really happens behind the scenes is that you call some_obj.operator =(value);. And operator =() is just another member function of your class, no different than memberFunctionOfSomeClass().

All in all, it boils down to:

func() = value;
// equivalent to
func().operator =(value);
// equivalent to
func().memberFunctionOfSomeClass(value);

Of course this is oversimplified, and this notation doesn't apply to builtin types like int (but the same mechanisms are used).

Hopefully this will help you understand better what others have already explained in terms of lvalue.

Answer 6

I was buffled by similar code too - at fist. It was "why the hell I assign value to a function call, and why compiler is happy with it?" I questioned myself. But when you look at what happens "behind", it does make sense.

As cpp and others poined out, lvalues are "memory locations" that have address and we can assign values to them. You can find more on the topic of lvalues and rvalues on the internet.

When we look at the function:

int& fun()
{
    static int x = 10;
    return x;
}

I moved the & to the type, so it's more obvious we are returning a reference to int.
We see we have x, which is lvalue - it has address and we can assign to it. It's also static, which makes it special - if it wasn't static, the lifetime (scope) of the variable would end with stack unwinding upon leaving the function and then the reference could point to whatever black hole exists in the universe. However as x is static, it will exist even after we leave the function (and when we come back to the function again) and we can access it outside of the function.

We are returning reference to an int, and since we return x, it's reference to the x. We can then use the reference to alter the x outside of the function. So:

int main()
{
    fun();

We just call the function. Variable x (in scope of fun function) is created, it has value of 10 assigned. It's address and value exist even after function is left - but we can't use it's value, since we don't have it's address.

    fun() = 30;

We call the function and then change the value of x. The x value is changed via the reference returned by the function. NOTE: the function is called first and only after the function call was completed, then, the assignment happens.

    int& reference_to_x = fun(); // note the &

Now we (finally) keep the reference to x returned by the function. Now we can change x without calling the function first. (reference_to_x will probably have the same address as the x have inside the fun function)

    int copy_of_x = fun(); // no & this time

This time we create new int and we just copy the value of x (via the reference). This new int has its own address, it doesn't point to the x like reference_to_x is.

    reference_to_x = 5;

We assigned x the value 5 through the reference, and we didn't even called the function. The copy_of_x is not changed.

    copy_of_x = 15;

We changed the new int to value 15. The x is not changed, since copy_of_x have its own address.

}

As 6502 and others pointed out, we use similar approach with returning references a lot with containers and custom overrides.

std::map<std::string, std::string> map = {};

map["hello"] = "Ahoj";
// is equal to
map.operator[]("hello") = "Ahoj"; // returns reference to std::string
// could be done also this way
std::string& reference_to_string_in_map = map.operator[]("hello");
reference_to_string_in_map = "Ahoj";

The map function we use could have declaration like this:

std::string& map::operator[]( const std::string& key ); // returns reference

We don't have address to the string we "stored" in the map, so we call this overridden function of map, passing it key so map knows which string we would like to access, and it returns us reference to that string, which we can use to change the value. NOTE: again the function is called first and only after it was completed (map found the correct string and returned reference to it) the assignment happens. It's like with fun() = 10, only more beatiful...

Hope this helps anyone who still woudn't understand everything even after reading other answers...

Answer 7

L-value is a locator-value. It means it has address. A reference clearly has an address. The lvalue required you can get if you return from fun() by value:

#include<iostream>
using namespace std;

int fun()
{
  static int x = 10;
  return x;
}
int main()
{
   fun() = 30;
   cout << fun();
   return 0;
}