What are the advantge of pointer variables?

Answer 1

The main advantage of a pointer is that, unlike an ordinary variable which can only refer to one object in memory (or an array of objects), a pointer can refer to any object in memory and we can change which object it refers to unless it is declared constant (const). This is an extremely powerful feature as it allows us to pass objects to functions by address, rather than by value, thus enabling the pass by reference mechanism.

A pointer is a variable just like any other. When we instantiate a pointer, memory is set aside for it and we can store a value in that memory, take its address, perform arithmetic on the value, and so on. Where it differs from an ordinary variable is that the stored value represents a memory address. We call them pointers because they "point to" that memory address and thus a pointer can "refer to" the object stored at that address.

[Note that in C, pointers are also known as references. However this usage of the term should not be confused with the C++ usage of the term, where a reference is an alias rather than a variable in its own right].

A pointer's type determines how the object it refers to will be interpreted. Thus when using pointers to refer to other objects, it is important that the pointer's type matches the type of object we wish to refer to. That is, if we want to refer to a char, we use a char pointer (char*), but if we want to refer to an int, we use an int pointer (int*). In some cases we may wish to refer to a multi-byte variable (such as a long int) just as if it were really an array of individual bytes or words (such as char or short). For this we simply use a pointer of the appropriate type (such as char* or short*) and cast the address of the object to that same type. For instance:

long int x=42;

char* p = (char*) &x; // take the address of x, treat as char* rather than long int*

Once we have an address stored in memory (in a pointer variable), we can perform "pointer arithmetic" upon it. This feature is primarily used to navigate through an array of values and, just as we can use the array suffix operator to access the individual elements of an array, we can use the array suffix operator on a pointer. Using the previous example, we can refer to the 3rd char of x as follows:

char c = p[2];

Given that p refers to a char, if we increment (or decrement) p, we will advance to the next (or previous) char address. Thus the above can also be written:

char c = *(p + 2);

Given the choice, the array suffix operator is clearly the better option. However, when traversing an array, the ++ and -- operators can be more convenient:

long int x = 42;

char* p; = (char*) &x;

char c;

int i;

for (i=0; i<sizeof(long int); ++i) {

// ...

++p; // advance to the next char element of x

}

While pointer arithmetic is useful, the main purpose of pointers is to refer to whole objects and to pass those objects to functions by reference rather than by value. Consider the following:

void foo (int x) {

// ...

}

When we pass an actual argument to this function, the value of that argument is assigned to the formal argument named x. Thus x is merely a copy of the actual argument. This means the function can modify the value of x without affecting the value passed by the caller. If we want the function to pass the modified value back to the caller, we would normally use the return value:

int foo (int x) {

++x; // modify x

return x; // return modified value

}

This is the recommended method of changing a value via a function, as it allows us a bit more flexibility in terms of what we do with that value:

int y = 42;

foo (y); // upon return, y is still 42 (the return value is lost).

y = foo (y); // upon return, y will be 43

int z;

z = foo (y); // upon return, y is still 43, while z is 44

However, the pass by value mechanism does not work for arrays, and with good reason; an array name only refers to the start address of the array. The array type determines how that address is interpreted but the type cannot be used to determine how many elements are actually in the array; the size of an array is not part of its type.

When we want to pass an array to a function, there are two ways we can declare the function:

void foo (int[], unsigned);

void foo (int*, unsigned);

Both versions mean exactly the same thing and will produce exactly the same machine code. Note that the unsigned argument is used to allow us to explicitly pass the length of the array.

Note that second version declares a pointer type. This means the function accepts the address of an object rather than its value. The same applies to the first version. This should come as no surprise given we've already seen how we can use the array suffix operator on a pointer; an array will implicitly convert to a pointer at the slightest provocation.

When we pass the address of an object, the function can refer to that object just as if we'd passed the object itself into the function (rather than just its value). This is what we mean by pass by reference. This means we must take the address of the object we wish to pass:

int x = 42;

// ...

foo (&x, 1);

Note that we pass the size as 1 because an object of type int has a length of 1 x sizeof(int) and the compiler already knows that an int has a length of sizeof(int). The size relates to the number of elements of the given type, not the number of bytes (or chars).

When we pass an actual array, we do not need to take the address because the name of the array implicitly converts to a pointer:

int y[100];

// ...

foo (y, 100);

Although there's no need to, we can explicitly take the address if we really want to:

foo (&y, 100);

Alternatively, we could take the address of the first element:

foo (&y[0], 100);

All three methods are functionally equivalent and will generate the exact same code.

Give that we can take the address of the first element, we can also take the address of any element and thus pass a subarray:

foo (&y[50], 10);

Here we are passing a subarray of 10 elements beginning at address y+50. This means we could also write this call as follows:

foo (&(y+50), 10);

Having passed an object by reference, the function can operate upon that object directly. This is useful when passing large objects as it takes just one CPU operation to assign an address to a pointer. Copying values larger than the size of a pointer is an expensive operation, so we only do that (explicitly) when we actually need a copy.

While arrays explicitly convert to a pointer, user-defined types do not. Thus when passing a struct or union object by reference, we must explicitly take the address of that object, just as we would with any other non-array type:

typedef struct st { /* ... */ };

void foo (struct s*);

int main (void) {

struct st s;

// ...

foo (&s);

// ...

return 0;

}