Teach Yourself Borland C++ in 14 Days - portal

Up to Your Neck in C++
Although it might appear that references are preferred over pointers, that is not the case.
References have some peculiarities that make them unsuitable in many cases. For one thing,
references cannot be declared and then later assigned a value. They must be initialized when
declared. For instance, the following code snippet will result in a compiler error:
MyStruct* pStruct = new MyStruct;
MyStruct& ref;
ref = *pStruct;
ref.X = 100;
Another problem with references is that they cannot be set to 0 or NULL as pointers can. That
means you’ll have to take special care to ensure that a reference is not deleted twice. References
and pointers can often serve the same purpose, but neither is perfect in every programming
situation.
Passing Function Parameters by
Reference and by Pointer
Earlier I talked about passing objects to functions by value. I said that in the case of structures
and classes, it is usually better to pass those objects by reference rather than by value. Any
object can be passed by reference. This includes the primitive data types such as int and long,
as well as instances of a structure or class. To review, when you pass function parameters by
value, a copy of the object is made, and the function works with the copy. When you pass
by reference, a pointer to the object is passed and not the object itself. This has two primary
implications. First, it means that objects passed by reference can by modified by the function.
Second, passing by reference eliminates the overhead of creating a copy of the object.
The fact that an object can be modified by the function is the most important aspect of
passing by reference. Take this code, for instance:
void IncrementPosition(int& xPos, int& yPos)
{
xPos++;
yPos++;
}
int x = 20;
int y = 40;
IncrementPosition(x, y);
// x now equals 21 and y equals 41
Notice that when the function returns, both of the parameters passed have been incremented
by one. This is because the function is modifying the actual object via the pointer (remember
that a reference is a type of pointer).
79
3