When we declare a pointer, it does not point to any specific variable. We must initialize it to point to the desired variable. This is achieved by assigning the address of that variable to the pointer variable, as shown below.
int a = 10;
pa = &a; /* pointer variable pa now points to variable a */
In this example, the first line declares an int variable named a and initializes it to 10. The second line declares a pointer pa of type pointer to int. Finally, the address of variable a is assigned to pa.Now pa is said to point to variable a.
We can also initialize a pointer when it is declared using the format given below.
type *ptr_var = init_expr ;
where init_expr is an expression that specifies the address of a previously defined variable of appropriate type or it can be NULL, a constant defined in the <stdio.h> header file.
Consider the example given below.
float x = 0.5;
float *px = &x;
int *p = NULL;
The second line declares a pointer variable px of type float * and initializes it with the address of variable x declared in the first line. Thus, pointer px now points to variable x. The third line declares pointer variable p of type int * and initializes it to NULL. Thus, pointer p does not point to any variable and it is an error to dereference such a pointer.
Note that a character pointer can be initialized using a character string constant as in
char *msg = “Hello, world!”;
Here, the C compiler allocates the required memory for the string constant (14 characters, in the above example, including the null terminator), stores the string constant in this memory and then assigns the initial address of this memory to pointer msg,as iliustrated in Fig.
The C language also permits initialization of more that one pointer variable in a single statement using the format shown below.
type *ptr_var1 = init_expr1, *ptr_var2 = init_expr2, … ;
It is also possible to mix the declaration and initialization of ordinary variables and pointers. However, we should avoid it to maintain program readability.
Example of Pointer Assignment and Initialization
Consider the example given below.
char a= ‘A’;
char *pa = &a;
printf(“The address of character variable a: %p\n”, pa);
printf(“The address of pointer variable pa : %p\n”, &pa);
printf(“The value pointed by pointer variable pa: %c\n”, *pa);
Here, pa is a character pointer variable that is initialized with the address of character variable a defined in the first line. Thus, pa points to variable a. The first two printf statements print the address of variables a and pa using the %p (p for pointer) conversion. The last printf statement prints the value of a using the pointer variable pa. When the program containing this code is executed in Code::Blocks, the output is displayed as shown below. ·
The address of character variable a: 0022FF1F
The address of pointer variable pa : 0022FF18
The value pointed by pointer variable pa: A
Note that the addresses displayed in the output will usually be different depending on other variables declared in the program and the compiler/IDE used.
Another example is given below in which pointers are initialized with the addresses of variables of incompatible type.
char c = ‘Z’;
int i = 10;
float f = 1.1;
char *pcl = &i, *pc2 = &f;
int *pil = &c, *pi2 = &f;
float *pfl = &c, *pf2 = &i;
printf(“Character: %c %c\n”, *pcl, *pc2);
printf(“Integer : %d %d\n”, *pil, *pi2);
printf (“Float : %f %f\n”, =pfl, *pf2);
Note that the character pointer variables pcl and pc2 are initialized with the addresses of the int and float variables, respectively. Similarly, the int and float pointer variables are also initialized with addresses of variables of incompatible type. When the program containing this code is compiled in Code::Blocks, the compiler reports six warning messages (initialization from incompatible pointer type), one for each incompatible pointer initialization.
It is not a good idea to ignore such warnings associated with pointers. Although, the program executes in the presence of these warnings, it displays wrong results as shown below.
Integer : 90 1066192077
Float : 0.000000 0.000000