What is meant by passing an argument as a pointer to an object?

Answer 1

In C++ we can pass arguments to functions in only two ways: by value or by reference. The method is decided by the signature of the function we call. The following examples demonstrate these signatures:

void byval (object val) {}

void byref (object& ref) {}

When we pass arguments to the byval function, we are passing the value of those arguments. Thus the formal argument, val, is always a copy of the actual argument we pass and any changes made to the formal argument are not reflected in the actual argument.

When we pass arguments to the byref function, we are passing the argument itself. Thus the formal argument, ref, is an alias for the actual argument we pass and any changes made to the formal argument are reflected in the actual argument.

To pass an argument by pointer, the formal argument must be a pointer of the same type as the actual argument (or any derivative of that type):

void byptr(object* ptr) {}

If we don't have an actual pointer variable to pass to the function, we must use the address-of operator to obtain an automatic pointer variable that we can pass:

object something;

byptr (&something);

If we don't do this, the compiler will search for a function signature that accepts a value or a reference and will completely ignore the pass by pointer signature., resulting in a compile-time error.

Passing by pointer is essentially an alternative method of passing by reference. However, when we pass by pointer we introduce an extra layer of indirection that we don't get when we pass by reference. This is because we are not actually passing by reference at all, we're passing by value. Pointers are variables that store memory addresses, thus whatever address we pass as the actual argument, that address becomes the value that is copied to the formal argument, ptr. However, because the formal argument and the actual argument both refer to the same object (because they both point to the same memory address), we are effectively passing that object by reference.

Passing by reference is always the preferred method of passing complex objects into functions, because copying complex objects is expensive. Imagine if the object represented a list containing 1 million nodes. That's 1 million copies for the nodes alone. However, we cannot pass by reference if there's even the slightest possibility there may be no object to pass. References cannot be NULL (or if they are, the program is deemed invalid) but pointers can be NULL. So in these cases we can pass by pointer rather than by reference.

Programmers try very hard never to pass function arguments more than 4 bytes in length (or 8 bytes on 64-bit systems). Thus passing primitive variables by value is fine unless you want changes reflected in the actual arguments. But complex objects must always be passed by reference, or by pointer variable, which is also a primitive type in itself because memory addresses are always the same length, depending on the architecture (32/64-bit).

Pointers can also be passed by reference as well as by value. Being able to pass a pointer by value means we can operate upon the object being pointed to, but we cannot change the value of the actual argument itself -- the pointer that was originally passed to the function. To do that we must pass the pointer by reference and we achieve this by introducing yet another layer of indirection, by passing a pointer to pointer variable:

void bypptr(object** pptr) {}

When we do this, pptr now holds the memory address of the pointer we actually passed, not the memory address of the object it pointed to. Thus we can change the memory address stored in that pointer thereby pointing it to another object of the same type, or indeed NULL, just as if we'd passed that pointer by reference.

Remember that pointers are just variables -- they simply store memory addresses. The pointer's type tells us what type of data resides at that address, thus allowing us to access that data via indirection. If that data happens to be another pointer, we have an extra layer of indirection between the pointer to pointer variable and the object being pointed at.

We cannot do this with references. References are easier to work with (provided we can be sure the reference will always be non-NULL) but, once assigned, we cannot reassign them like we can a pointer variable. That is, references must always refer to whatever object we initially assigned to them. But pointers are variables, thus we can reassign them any valid address, including NULL, at any time. So although pointers are slightly more complex than references and consume more memory than references, they are more flexible than references.

New programmers are often confused by the terms reference and pointer. This is understandable, particularly for C programmers moving to C++ because C has no concept of a reference (A C reference is the same as a C pointer). References are perhaps best understood using the following example:

class person {};

person Robert;

Here we've instantiated a person object named Robert. Whenever we refer to Robert we're actually referring to the memory address allocated to Robert. This memory address is not physically stored anywhere (as it would be if we assigned Robert to a pointer variable), we simply identify the address by the name Robert (or rather, &Robert).

person& Bob = Robert;

Here we've assigned Robert to the reference named Bob. Thus Bob and Robert both refer to the same memory address (Robert's address). In other words, Bob is an alternate name, an alias, for the memory allocated to Robert. We don't need the address-of operator to perform the assignment because we're assigning an object to a reference (&), not a pointer (*). The compiler knows the difference.

Note that Bob is neither a variable nor a constant. We haven't actually stored the memory address of Robert as we would were Bob a pointer variable. Since it is not a variable, we cannot reassign Bob to another person object and thus treat the two as being separate people (we can with pointers, but not with references). Indeed, if we did assign another person to Bob, we'd actually be invoking Robert's assignment operator (because Bob refers to Robert), thus Robert will end up copying the member data of that other person object and assigning that data to its own members. Robert then becomes a different person but a person who can still be referred to as either Bob or Robert. They are still one and the same person.

We can take this concept to extremes:

person& Bobby = Bob;

person& Rab = Robert;

person& Rabbie = Bobby;

person& Rob = Bob;

person& Robby = Rab;

Now we can refer to Robert as Rob, Bobby, Rab, Rabbie, Rob or Robby. Note how the reference we assign need not be the name we gave the original person object. They all refer to the same person object so any existing reference will do for assignment. And since references do not store memory addresses like pointers do, we can have as many different references to the same object as we like without consuming any additional memory in order to store the addresses, as we would with multiple pointers to the same object.

We would not normally use multiple references to the same object within the same code block, but passing references to different code blocks (functions) means those code blocks can refer to the same object by alternate names. This is important because the code block will not know the original name assigned to an object, but must refer to it in some way -- thus we use aliases.

void func (person& someone) {}

Thus if we pass Robert (or Bob, etc) into this function, the function will refer to Robert by the alias named someone. In turn, the function might pass someone into another function that perhaps uses the alias anyone. Thus that function refers to Robert by the alias anyone.

With pointers we do exactly the same thing except we pass a physical copy of the address of the person object:

void func2 (person* anyone) {}

Thus the anyone variable will store the address of Robert regardless of which alias (Bob, Rob, etc) we actually pass to the function, like so:

func2 (&Bobby);

Note that although Bobby is a reference (and therefore a memory address), we must use the address-of operator in order to pass by pointer. What we're actually doing is creating an automatic pointer variable whose value can be copied to the function's formal argument, anyone. If we don't use the address-of operator, the compiler will look for a signature that accepts Bobby by reference or by value, but will completely ignore any signature that accepts a pointer, because we didn't actually pass a pointer, we passed a reference.