A reference is an alias; when you create a reference, you initialize it with
the name of another object, the target. From that moment on, the reference acts
as an alternative name for the target, and anything you do to the reference is
really done to the target.
You create a reference by writing the type of the target object, followed by
the reference operator (&), followed by the name of the reference.
References can use any legal variable name, but for this book we'll prefix all
reference names with "r." Thus, if you have an integer variable named someInt,
you can make a reference to that variable by writing the following:
int &rSomeRef = someInt;
This is read as "rSomeRef is a reference to an integer that is
initialized to refer to someInt." Program below shows how
references are created and used.
that the reference operator (&) is the same symbol as the one
used for the address of the operator. These are not the same operators,
however, though clearly they are related.
Creating and using
2: // Demonstrating the use of References
4: #include <iostream.h>
6: int main()
8: int intOne;
9: int &rSomeRef = intOne;
11: intOne = 5;
12: cout << "intOne: " << intOne << endl;
13: cout << "rSomeRef: " << rSomeRef << endl;
15: rSomeRef = 7;
16: cout << "intOne: " << intOne << endl;
17: cout << "rSomeRef: " << rSomeRef << endl;
18: return 0;
Output: intOne: 5
Anaylsis: On line 8, a local int
variable, intOne, is declared. On line 9, a reference to an int,
rSomeRef, is declared and initialized to refer to intOne. If
you declare a reference, but don't initialize it, you will get a compile-time
error. References must be initialized.
On line 11, intOne is assigned the value 5. On lines 12 and
13, the values in intOne and rSomeRef are printed, and are, of
course, the same.
On line 15, 7 is assigned to rSomeRef. Since this is a
reference, it is an alias for intOne, and thus the 7 is really
assigned to intOne, as is shown by the printouts on lines 16 and 17.