Why should I use reference variables at all? [closed]

Answer 1

As you just came from Java, I can imagine you have problems with a lot of dangerous stuff that C/C++ lets you do. In my opinion, the difference is here:

• C/C++ lets you do a lot of powerful and dangerous stuff. You can do a lot of great things, but also shoot yourself in the leg
• Java restricts what you can do in the name of safety

What you don't like ("pointers/references are dangerous") is exactly what I love ("it lets me do a lot of stuff, and if I mess up it's my fault") about C++. It's a matter of programming language taste, in my opinion.

References were made to avoid some dangers of pointers, but on the other hand, even the pointers still have uses besides the obvious fast-access stuff. For example, let's say that you have a low-level object that does some useful work and is shared between more than one high-level objects. It can be shared for various reasons (e.g. it updates the internal state every time it does useful work so copying it is not an option).

class HL{
    private:
    LL &object;

    public:
    HL(LL &obj){
        object = obj; // initialization of reference
    }
    // a no-argument constructor is not possible because you HAVE to
    // initialize the reference at object-creation (or you could initialize
    // it to a dummy static object of type LL, but that's a mess)
    void some_routine(){
        ....
        object.useful_work();
        ...
    }
}

Using references in this case enforces the initialization of internal object. If, on the other hand, the functionality that the object provides is just optional for the high-level object, than the pointer is a way to go:

class HL{
    private:
    LL *object;

    public:
    HL(LL &obj){
        object = &obj; // initialization of reference
    }
    HL(){} // no-argument constructor possible
    void some_routine(){
        ....
        if (object != NULL)
           object->useful_work();
        ...
    }
}

Also, as for use of the call-by-reference, that's the most useful when you're passing a big structure to a function, e.g. vector<int>.

void function(vector <int> a); // call by value, vector copied every time
void function(vector <int> &a); // call by reference, you can modify
                                // the vector in the function
void function(const vector <int> &a); // if you don't want to be able to modify
                                      // it, you can add const for "protection"

Answer 2

For example because they are forcing you to initialze, this makes them less dangerous

Answer 3

References make call-by-reference easier, since the caller does not have to use the & operator when passinng an object.

Like this:

MyObject ob;

void foo_ref(MyObject& o){ ...}
void foo_ptr(Myobject* o){ ...}

//call

foo_ref(ob);
foo_ptr(&ob);

Furthermore, they enable initializing pointers in a function:

MyObject* ob = nullptr;
MySubject* sub = nullptr;

void foo_init(MyObject *& o, MySubject *& s) {

   o = new MyObject;
   s = new MySubject;
}

//call

foo_init(ob, sub);

Without the reference to pointer this example would only work with a pointers to pointers, making the code look terrible, as you would have to derefernce each argument first

MyObject* ob = nullptr;
MySubject* sub = nullptr;

void foo_init(MyObject ** o, MySubject ** s) {

   *o = new MyObject;
   *s = new MySubject;
}

//call

foo_init(&ob, &sub);

Answer 4

A reference is a pointer with restrictions. A reference is a way of accessing an object, but is not the object itself. If it makes sense for your code to use these restrictions, then using a reference instead of a pointer lets the compiler to warn you about accidentally violating them.

Answer 5

The most frequent use of references is to avoid an expensive deep copy; by default, C++ has value semantics, and if you write something like:

void f( std::vector<double> d );

The entire vector will be copied each time you invoke f. So you write something like:

void f( std::vector<double> const& d );

One place where this is particularly important is when defining a copy constructor. If you were to write:

MyType( MyType other );

, you would end up with infinite recursion since the compiler would have to call the copy constructor in order to copy the argument to this constructor. (In fact, the compiler will only accept a constructor which takes a reference to the copy constructor, precisely to avoid this problem.)

Outside of constructors, this is really an optimization and could be considered as premature optimization. In practice, however, the almost universal convention is to pass class types by reference to const, rather than by value.

References may also be used as out parameters; compared to a pointer, they have the advantage that they cannot be null.

References can also be used to provide a "window" into the class data. The classical example is the overload of operator[] in std::vector; it returns a reference so that you can modify, take the address of, etc. the actual element in the array.

Other than as parameters and return values, in the above cases, references are somewhat rare. If you use one as a class member, for example, you must be aware that you cannot give the class classical assignment semantics. (This is not an issue if the class doesn't support assignment.) As a global variable, they might be used to hide the implementation of what is being referred to, but this is exceedingly rare. As a local variable, about the only use I know, is to cache the results of another expression which returns a reference: for example, if I'm accessing someMap[aKey] a large number of times in a short block of code, it makes sense to write:

ValueType& element = someMap[aKey];

at the start, and use element after that. (Note that this only makes sense because someMap[aKey] returns a reference.)

Answer 6

The problem is not related to references itself.

The problem is that in C++, object lifetime is managed differently than in Java or other run-time environments that use a garbage collector. C++ doesn't have standard built-in garbage collector. C++ object lifetime can be automatic (within local or global scope) or manual (explicitly allocated/deallocated in heap).

A C++ reference is just a simple alias for an object. It doesn't know anything about object lifetime (for the sake of efficiency). The programmer must care about it. An exception is the special case where a reference is bound to a temporary object; in this case, the lifetime of the temporary is extended to lifetime of the bound reference. Details are here.

References are an important part of C++ basic concepts and you just cannot avoid using them for 90% of tasks. Otherwise you have to use pointers, which is usually even worse :-)

E.g., when you need to pass object as function argument by reference instead of by value you can use references:

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