This is my first technical post in this series of the blogs. Hope everyone gets something out of it. I chose this topic because this is been my favourite and my inspiration to explore the course I am pursuing currently. For some it may seem like a well well-dug by himself to fall inside. To some it is walking on thorns. People have far gone to even write books called ‘Pitfalls in pointers’. Whenever I read this title, I really enjoy what pointers have done to people. Now, Let us start with the basics of pointers.

In any programming language, they are variables which are to be stored in memory during the execution. These variables are the data values used by the program and occupy a memory location. Each of these memory locations has an address. Each address is specific to a single byte. Whenever a variable is accessed, the data is getting accessed from this addressable memory (forget about caching). ‘Is there any way to access this memory location without accessing the variable?’ is the question to be asked to get the answer as ‘Pointers’.

So, what is a pointer? A pointer is a variable which stores address of other variables instead of data values. But what is the use of this? This pointer variable points to the memory location to which it has been initialized or assigned.

Simple example:
int n = 10;
int *ptr = &                     //this means the address of variable ‘n’ is assigned to ptr

Now we can access the variable ‘n’ either by using ‘n’ or ‘*ptr’.

Operators

The * is called the dereference operator, returns the value pointed by the variable. The & is called the address of operator, returns the address location occupied by the variable. Both of these are unary operators. So, &n returns the address of the variable ‘n’ and it is been assigned to the pointer variable ‘ptr’. Just ‘ptr’ returns the address of ‘n’ whereas ‘*ptr’ returns the value stored in the variable.

Pointer Types

1)     int *p;                  //A normal pointer which can point to a integer variable.

2)     void *p;                //A  pointer which can point to any data type.

3)     int *p[10];           //An array of pointers. This declaration consists of 10 pointers which can point to 10 other variables.

4)     int (*p)[10]         //A pointer that points to an array of 10 elements.

5)     int **p;                 //A ‘double’ pointer points to another pointer variable which in turn points to a normal variable. This is double dereferencing. This can be extended to any levels.

Poniters and Functions

1)     int *func(char c);           //A function that takes a character as input and returns a pointer to an integer.

2)     int func(char (*c)[]);       //A function taking argument as a character pointer pointing to a character array.

3)     int (*func)(void);           //A pointer to a function which takes no argument and returns an integer.

                    Example:
                         int normal_function(void);
                         func = normal_function;
                         int n = (*func)();

4)     int (*func[10])();         //An array of function pointers.

Pointers and Arrays

1)     int a[5] = {1, 2, 3, 4, 5};

&a[0], a, &a gives the address of the first element. *a, a[0] gives the value of first element.

2)     Arrays are passed in function as references.

3)     int a[2][3] = {1, 2, 3, 4, 5, 6};

a, a[0], &a[0], &a, *a gives the address of the first element of first row. *(a+1), a[1], &a[1], a+1 gives the address of the first element of second row.

4)     int a[2][3] = {1, 2, 3, 4, 5, 6}; int *p = a;

p points to first element of the array. Since it is a single pointer, it is treated as pointing to one-dimensional array.

Pointer Arithmetic

Example:
int n = 10;
int *p = &n;

1)     *p++;                    //returns the value pointed by p and increments the address in p.

2)     (*p)++;                 //returns the value pointed by p and increments the value in p.

3)     *++p;                    // increments the address in p and return the value pointed by p.

4)     ++*p;                    //increments the value pointed by p and returns that value.

5)     P++;                       //increments the address in p.

The address increment increments based on the pointer type. For integer, it increments by 2 bytes.

Pointers and Pitfalls

So I am ending this post with what I started. Whether these pitfalls considered are really pitfalls. Why and Why not?

1)     Dangling Pointer
Suppose a pointer is pointing to some memory location and that variable is getting deleted. What happens to the pointer variable? It still contains the address to which previously it was pointing. That is, the pointer is pointing to a location which is not available. This is called dangling pointer. This can be solved by assigning NULL to the pointer and then deleting the variable.

2)     Wild Pointer
A pointer which just gets declared without any initialization points to some random memory. This is called wild pointers. This often leads to segmentation fault. Always initialize the pointers with a NULL.

3)     Pointers and NULL

           Example:
           int *n = NULL; char *str = NULL;

Both these pointers point to nothing, yet it stores a value 0x0000. Accessing them leads to either a null reference error or a segementation fault. This depends on the platform used.

PS: Hope the above things are correct to my knowledge. If anything you find intriguing, leave me a message.