Detail about independence reference in c plus plus?

Answer 1

An independent reference (or simply a reference) is an alias to an existing reference.

int a = 42;

int& ref = a; // independent reference

In the above code, ref is a reference to the object named a. If you modify the value of ref then you modify the value of a -- they are one and the same object. This can be proved as follows:

ref *= 2; // double the value of ref

assert (a==84); // verify a has also doubled

References are a bit like constant pointers. That is, once assigned, they cannot be reassigned, they must always refer to the same object, just like a constant pointer:

int* const ptr = &a;

The difference is that a pointer (even a constant pointer) is a variable and therefore requires memory of its own to store the memory address of the object being pointed to. A reference does not; a reference is simply an alias -- an alternate name for an object.

Also, unlike a pointer, a reference cannot be null -- it must always refer to something valid. Moreover, the object it refers to must be guaranteed to outlive the reference itself. For example:

int* ptr = new int(42);

int& bad_ref = *ptr; // refer to the object pointed to by ptr (the int with value 42)

delete ptr;

At this point, what is bad_ref referring to? The integer pointed to by ptr no longer exists (we just deleted it), so bad_ref is now referring to memory that no longer belongs to our program. The value may still exist at the original memory location, but now the memory is released to the system, any external process can modify that memory behind our backs. Thus any future attempt to access that memory via bad_ref would result in undefined behaviour. Therefore never refer to dynamic memory unless you are absolutely certain that memory will outlive the reference.

Reference are predominantly used when passing objects to functions by reference. Passing by reference can be achieved either by passing a pointer or passing a reference. But in cases where a pointer must be non-null and the pointer must be constant, passing by reference is the preferred option. Consider:

void f1 (int* const p)

{

if (p)

{

*p *= 2; // double the value being pointed at.

}

}

Every time we call this function we must test p to ensure it is non-null before we can access the memory being pointed at. If we pass by independent reference instead, we can eliminate the unnecessary test:

void f2 (int& r)

{

r *= 2; // double the value being referred to by r

}

Can we always be certain r never refers to a null object? No, we cannot. Consider the following:

int main()

{

int* p = nullptr;

f1 (p); // OK

f2 (*p); // unhandled exception: access violation!

}

You might ask where's the benefit, but the benefit comes from the calling convention itself. Function f2() expects a non-null reference therefore that is exactly what we should pass. *p is an invalid reference because p is a nullptr, so the problem is not the function, it is the caller. Although function f1() can handle invalid references gracefully, the point is that we don't want to pass invalid references to this particular function at all, and f1() does not alert us when we do. If an exception occurs then the program is invalid, so the exception forces us to rectify that. In this manner we achieve more robust and efficient code.

If a reference argument is optional, then of course a pointer makes more sense (typically defaulted to nullptr). Similarly if we need to refer to different objects through the same pointer argument (non-const pointer). But when a reference is not optional and must refer to the same object, an independent reference makes the most sense.