My misconception about pass by and return by reference in C++

Question

Pass by reference:

I have learned that when a variables is passed as a reference to a function then instead of copy, the actual data is passed to the function but i think that if it is really the case then we shouldn't be able to access that data again once the program execution returns to main() after the stack frame of that function gets destroyed and leave that reference variable with zero or null value in main() but it is not the case and we can still access it in the main() so i think that in pass by reference, the memory address of that variable is passed to that function reference variable parameter and then we use that memory in that function with another name(reference variable) and when that function gets destroyed then the reference variables get destroyed rather than the actual data.

is my thinking towards this concept is right or am i doing some mistake in understanding this concept ?

Return By Reference

When a variable which is passed as a reference to another function returns back as a reference to main() then is the memory address passed back to main() or what actually is returned ?

Answer 1

I have learned that when a variables is passed as a reference to a function then instead of copy, the actual data is passed to the function

This is wrong. Passing the actual data would mean the value is passed (either by copy or by move). When passing by reference, a reference to the actual data is passed to the function.

so i think that in pass by reference, the memory address of that variable is passed to that function reference variable parameter and then we use that memory in that function with another name(reference variable)

This is right.

When a variable which is passed as a reference to another function returns back as a reference to main() then is the memory address passed back to main() or what actually is returned ?

A reference can be thought of as a memory address, so returning a reference is similar to returning a pointer (memory address).

When returning a reference from a function, you need to be careful that you don't return a reference to a variable that's local to the function, because that variable no longer exists after the function returns, and you are left with a dangling reference that may crash your program when you try to use it.

Answer 2

passed as a reference to a function then instead of copy, the actual data is passed to the function

It is unclear what you mean by "actual" data. A copy is actual data as much as the origianl object is.

References are a form of indirection. The reference variable indirectly refers to the object to which it was bound. An object variable is distinct from other objects, and its value may be copied from another.

if it is really the case then we shouldn't be able to access that data again once the program execution returns to main()

Binding a reference to an object does not make the object or its data disappear. Example:

void foo(int& ref);

int main()
{
    int obj;
    foo(obj);
    // obj still exists here
}

If you bind a reference to an object defined in main, then the object still exists in main regardless of where that reference was bound.

i doing some mistake in understanding this concept ?

Yes. You did not understand yet what a reference is, or at least were not able to describe them correctly.

Answer 3

Your concept of pass by reference is wrong.

Passing a variable to a function by reference means that something else (let's call it a handle) is passed that acts an alias of the original variable. Every operation that can be performed on the handle within the function (e.g. assigning it a value, retrieving its value, calculating its address, calling a member function if it is an object) are referred to the original variable that was passed by the caller. How those affects are achieved depends on the implementation (e.g. the compiler).

The called function, by performing operations on the handle, does not cause the original variable to cease to exist. (Except in some very specific circumstances, which I won't go into).

For example;

 #include <iostream>

 void foo(int &x)
 {
      x = 42;       //  x is the handle I refer to above
 }

 int main()
 {
      int y = 16;
      std::cout << y << '\n';
      foo(y);
      std::cout << y << '\n';
 }

will print the values 16 and 42, in that order. The assignment x = 42 in foo() has the effect of changing the value of y in main(). The lifetime of y is unaffected, so y continues to exist until the end of main().

That thing I have referred to as a "handle" is more commonly known as a reference.

Similarly, your concept of returning a reference is wrong. Returning a reference gives a handle to the caller, and the caller can then use the returned handle to access (and perform operations on) whatever variable is returned by the function.

Note that, in the above, I have said nothing about passing the address of a variable around. Because the description above focuses on the observable effect of using references, not on how that observable effect is achieved (e.g. by the compiler).

Behind the scenes, your compiler MIGHT implement all of the magic of references by passing the address of the affected variables around (in fact, most modern compilers do). That is one possible implementation approach. But there are, technically, other ways of achieving that effect - the C++ standard does not require the address of variables to be passed around to achieve the behaviours associated with passing them around by reference.