How do you declare an object reference variable?

Answer 1

For an object named Point you would declare an object reference variable like this:

Point p1;

The name p1 can be any valid variable name that you want. Note that p1 does not yet refer to an actual object yet, you have just created a reference to one (kind of like a pointer in C). To set p1 to actually refer to an instance of the object Point you could do something like this:

p1 = new Point();

Answer 2

You create a reference with the reference operator (&).

int val = 42; // normal variable

int& ref = value; // reference to val

Note that val and ref refer to the same object, ref is simply an alias for val. If you alter the value of the ref you alter the value of val, and vice versa.

Answer 3

There's no such thing as a reference variable. A variable is an object that has identity (an address). Variables in static memory or on the stack (local memory) can be named, however objects on the heap (free store) cannot be named because they do not exit at compile time, they only exist at runtime, so they are anonymous. However, any object in memory, whether named or anonymous, has identity because we can take its address.

A reference is not an object of any kind (it has no identity), it is simply an alternate name or alias for another object that exists in memory (one that has identity). References are a bit like pointer variables in that they can both refer to something in memory, however pointers are variables so we can take the address of a pointer and store it in another pointer (creating a pointer to pointer variable). References don't have identity so if we try to take the address of a reference we end with the address of the object being referred to. This would be akin to taking the value of a pointer variable. More importantly, a pointer variable can refer to the NULL address (meaning "no object") whereas a reference cannot; a NULL reference would invalidate the program.

Not all languages support references. C is a prime example. Although we often use the term reference when referring to a pointer variable in C, this is only because C predates the concept of a native reference type. C++, on the other hand, does support a native reference type. Consider the following:

int i = 0;

int& ref = &i;

ref = 42;

assert (i == 42);

Here, both i and ref refer to the same object. Referring to an object in the same scope is pointless; it already has a perfectly good name, there's no need to give it another (it would only lead to confusion). References come into their own when we pass objects to functions because the function cannot know the name of the object (the actual argument) being passed:

void f (int& n) {

n = 0;

}

f (i);

Here, the function refers to i by the formal argument name n, which is a reference. Thus i and n both refer to the same object. If we change the value of n we change the value of i.

We can achieve the same sort of thing with pointer variables:

void g (int* n) { if (n!=NULL) *n = 0; }

g (&i);

Here we can see the main difference between a reference and a pointer variable. With a pointer variable we must be sure we are referring to something valid before we attempt to dereference the object being referred to. A reference is guaranteed to be non-null so we can eliminate many unnecessary tests for NULL from our code. We also get the advantage of a much simpler syntax; we don't have to dereference references!

Getting back to the question, how do we declare an array reference? First, we have to declare the array:

int x[3] {5, 10, 15};

The array's name is x and it has the type int[3]. There are basically two ways to declare a reference of this type:

int (&r)[3] = x; // the hard way

auto& r = x; // the easy way (since C++11)

The first way is only hard because we have to be explicit.

The biggest problem with arrays is that they decay to temporary pointers as soon as we try to copy them via assignment. This makes it impossible to pass arrays into functions by reference; in effect we have to refer to a pointer to the array:

void h (int* const& rpa) {

// ...

}

While this would work, the conversion to pointer means we lose all size information. This means we must pass the size through another parameter. However, a reference to a pointer only guarantees that the pointer variable is valid, it does not guarantee the pointer refers to a non-NULL address. Given that, we might as well just pass the pointer add array size just as we would in C:

void h (int* p, size_t size) {

if (p==NULL size==0) return; // safety-first!

// ...

}

We don't have this problem with resource handles like std::array because only built-in arrays decay to pointers. A std::array object can be referred just as easily as any other (non-array) variable:

template<typename T, size_t N>

void h2 (std::array<T, N>& a) {

if (a.size() == 0) return; // safety-first!

// ...

}

std::array<int, 3> z = {5, 10, 15};

h2 (z); // pass array by reference!