How are pointer variables declared

The C language permits a pointer to be declared for any data type. The declaration of a pointer variable takes the following general form:

type *ptr_var;

where type is a valid C data type and ptr_var is the name of the pointer variable. We can read this declaration backwards as ptr_var is a pointer to type type. Another interpretation of this declaration is that *ptr_var has a value of type type, the value of the variable to which pointer ptr_var will point. Thus, we can use the expression *ptr_var in place of the variable pointed by ptr_var. The operator* is called as the dereference operator (note that the symbol is same as that of the multiplication operator).

The declaration given above reserves memory for pointer variable ptr_var. As we know, the C language does not automatically initialize the value of a local variable. Thus, variable ptr_var will contain some garbage value, i.e., it will point to some arbitrary memory location and not to any specific variable. Such a pointer is called a stray pointer. Also note that a pointer variable having zero value does not point anywhere. Such a pointer is called a null pointer. Hence, we must initialize pointer ptr_var to point to the desired variable before we use it.

As with simple variables, we can declare multiple pointer variables of the same type in a single declaration statement using the following form:

type *ptr_var1, *ptr_var2, *ptr_var3, ... ;

Here, each variable is declared as a pointer by prefixing it with the dereferencing operator. Also note that although we can mix the declaration of simple variables and pointers in a single declaration statement, it should be avoided to keep the code readable.

Example of declaring pointer Variable

Consider the following example which declare several pointer variables.

char *pc;
int *pi;
double *pd;
unsigned long *pul;

Here, pc, pi, pd and pul are declared as pointers to char, int, double and unsigned long, respectively. The types of these pointers are char *, int *, double * and unsigned long *, respectively. These pointers have not yet been initialized. Thus, they are stray pointers. Now consider an example in which we declare multiple pointers in each statement.

char *pc1, *pc2;
int *pi1, *pi2, *pi3;

This example declares variables pc1 and pc2 as pointers to char type and variables pil, pi2 and pi3 as pointers to int type.

Finally, consider the following declarations in which the pointer declarations are mixed with Declarations and initializations of simple variables.

float x, *px, y = 1.2, *py;
short a = 100, b, *pa, *pb;

Note that although these declarations are concise requiring only two lines, they are somewhat Difficult to read. This style is not recommend.

Some authors suggest a slightly different style for declaration of a pointer variable in which the dereference operator is written immediately after the data type as shown below.

type*ptr_var ;

Since C is a free-format language, this style is equivalent to the previous one. However, if we declare multiple pointer variables in the same declaration, this style can lead to errors. Consider the following example:

int* pa, pb, pc;

We may interpret this as the variables pa, pb and pc are declared as pointers to type int. However, this is not the case. You will be surprised to know that only variable pa is declared as a pointer, whereas pb and pc are simple variables of type int. Hence, this declaration style is discouraged. However, if you wish to use it, declare only one variable per declaration as insisted on by authors recommending this style.