Assignement of variable to reference inside a function.

Question

I am experimenting with C++ references and came across the following scenario : Consider the following code

void foo(float &y)
{
    float k = 0.0;
    k += 20.1;
    y = k;
    cout << "y = " << y << endl;
} 



int main() {

    float  i;
    foo(i);
    i+=10.00;
    cout<<"value of I after returning is :: "<<i<<endl;

    return 0;
}

The program compiles and runs. The output is :

y = 20.1
value of i after returning is :: 30.1

Now with that happening my dilemma is that ... in function "foo" we assign y (which is a reference to i) as k. And k's scope is only in that function. So once the function returns, k should be destroyed and the value of i should be some undefined value. But contrary to my expectation, i has the value of k after the function.

Am I missing something or understanding things differently ... ? Any help in understanding what is happening here ? Thanks in advance.

Answer 1

I think you are confusing C++ references with pointers. They are different things! Once a reference is set to reference some object, it can never be changed to refer to another object. And any operation that is performed on the reference is actually done to the value of the referred object. In this case, the assignment y = k actually sets the value of the object referred to by y to k.

To make things a bit more concrete, I will annotate the example you gave with comments describing what is happening:

void foo(float &y)
{
    float k = 0.0;
    k += 20.1;
    y = k;  /* The value of the object referred to by y (i, in this program)
               is set to k (20.1f) */
    cout << "y = " << y << endl; /* When we write y in this way, we are 
               really referring to the value of the object referred to by y. 
               This is why it prints 20.1 instead of some memory address. */
} 

int main() {
    float  i;
    foo(i);   /* i is passed as a reference to foo */
    i+=10.00; /* The value of i was modified in foo. */
    cout<<"value of I after returning is :: "<<i<<endl;

    return 0;
}

To contrast, here is similar code using pointers instead of references (with a mistake-- it assigns the pointer, y, instead of changing the value pointed at by y):

void foo(float *y)
{
    float k = 0.0;
    k += 20.1;
    y = &k;
    cout << "y = " << *y << endl;
} 

int main() {
    float  i = 0;
    foo(&i);   /* i is passed as a reference to foo */
    i+=10.00; /* The value of i was modified in foo. */
    cout<<"value of I after returning is :: "<<i<<endl;

    return 0;
}

What happens in this case? Well, we print out y = 20.1 and that the value of i after returning is 10.00. In this example, when we assign y = &k we are changing the variable y, which is local to foo, to refer to k. This has no effect on i (we are not modifying the value pointed to by y), so i is unchanged after we exit foo. If you wanted to change i to equal k after foo, we would have to change the line to read *y = k.

Hope that cleared up some of the differences between C++ references and pointers! There are plenty of good tutorials out there that do an excellent job explaining the topic.

Answer 2

float &y = k;  // Or float &y argument of a function initialized with i

is very different from

float &y = something;
...
y = k;

In former version, y is a reference of k.

In later version, y is still reference of something, and y = k, assigns value to k to y alias or something

Always remember that a reference can not be re-assigned.

for example:

int x = 10;
int &y = x;
int z = 20;

y = z;  // x= 20, y(x) = 20, z = 20
x = 15; // x= 15, y(x) = 15, z = 20
y= 25;  // x= 25, y(x) = 25, z = 20
z= 30;  // x= 25, y(x) = 25, z = 30
// Also note that &x and &y (addresses) are same. But &z would be different

Answer 3

References are syntactic sugar for pointers. Your code is equivalent to the following:

void foo(float * const y)
{
    float k = 0.0;
    k += 20.1;
    *y = k;
    cout << "y = " << *y << endl;
} 
int main() {
    float  i;
    foo(&i);
    i+=10.00;
    cout<<"value of I after returning is :: "<<i<<endl;
    return 0;
}

Basically, you can set the target of the reference only at initialisation. If you assign to the reference afterwards, then these will be assignments to the referenced value.