Why should I use reference variables at all

Question

I learnt Java as my first programming language, but now that I'm attending a different university, I'm also learning C++.

After switching from Java to C++, I studied about references and reference variables.  And how hazardous they may be, how to use caution when using them, and so forth.

Therefore, I have one clear thought in my head: Why even bother employing that kind of difficult, maybe problematic, stuff?

Is it worthwhile or simply a holdover from the days when RAM was only approximately 64MB in size?

Since pointers have been discussed in several responses, in my opinion, the idea is archaic.

I wouldn't even touch those equipment, with the exception of high-performance computing.

Answer 1

References themselves are unrelated to the issue.

The issue is because C++ manages object lifetimes differently from run-time systems that employ garbage collectors, such as Java. 

There is no standard built-in garbage collector in C++. 

Both automatic (within local or global scope) and manual (explicitly allocated/deallocated in heap) object lifetimes are possible in  C++.

A C++ reference is nothing more than an object's alias. 

It has no knowledge of object lifespan (for the sake of efficiency). 

The coder must give it some thought. 

A reference bound to a temporary object is an exception; in this situation, the temporary object's lifespan is prolonged to include the lifetime of the bound reference.

References play a crucial role in the fundamental ideas of C++, and they are required for 90% of jobs. 

Otherwise, pointers must be used, which is typically far worse.

You can use references, for instance, when you need to give an object as a function parameter by reference rather than by value:

void f(A copyOfObj);       // Passed by value, f receives copy of passed A instance
void f(A& refToObj);       // Passed by ref, f receives passed A instance itself, modifiable
void f(const A& refToObj); // Passed by const ref, f receives passed A instance itself, non modifiable