Teach Yourself Borland C++ in 14 Days - portal

76 Day 3
First, on line 13 I declared the listArray array as an array of pointers. Following that,
ANALYSIS
I created objects for each element of the array. This takes place in the for loop on
lines 17 and 18. After that, I changed the direct membership operators (.) to indirect
membership operators (->). I also have to dereference the pointers on line 57 and again on
line 72. This is necessary because an object is expected and we cannot use a pointer in place
of an object. Notice that the displayRecord function (starting on line 82) doesn’t change. I
haven’t changed the fact that the mailingListRecord structure is passed to the function by
value, so the code in the function doesn’t need to be modified.
If you’ve had previous experience with C++, you may have noticed that this program has a
bug in it. I’ll let you in on the secret before the end of the chapter.
References
NEW TERM
A reference is a special type of pointer that allows you to treat a pointer like a regular
object.
References, like pointers, can be confusing. A reference is declared using the reference operator.
The symbol for the reference operator is the ampersand (&) which is the same symbol used
for the address-of operator (don’t worry, the compiler knows how to keep it all straight). As
I said, a reference allows you to treat a pointer like an object. Here’s an example:
MyStruct* pStruct = new MyStruct;
MyStruct& ref = *pStruct;
ref.X = 100;
Notice that with references you use the direct member operator rather than the indirect
member operator as you do with pointers. Now you can get rid of all of those pesky ->
operators! Although you won’t use references a lot, they can be very handy when you need
them. By the way, this code snippet could be condensed a little. Here’s how I would write
it in a real program:
MyStruct& ref = *new MyStruct;
ref.X = 100;
Although this might look odd, it does exactly the same thing as the first example. Combining
statements like this is common and avoids unnecessary overhead.
Let’s go once more to the MAILLIST example. This time I’ll modify it by implementing a
reference in the do-while loop. Actually, I’ll be modifying the POINTER example found in
Listing 3.1. The new program, found in Listing 3.2, illustrates this change.