No More Confusion with Pointers: A short technical paper for understanding Pointers

Pointers, the concept which a c beginner find difficult to understand. Even if you once read it carefully, you cannot be hell sure that you will be able to work with pointers conveniently. Here is a quick technical article which may help you understand pointers deeply.

Misconception: Pointer is an address to a VARIABLE.

A pointer points to an address, but the address need not be the address of a variable. It may be address of any location in the computer memory. For example,

int i=10, *pi;

pi=&i;

 

Here ‘pi’ is a pointer variable pointing to the location of ‘i’. Be careful, it does not point to ‘i’, it points to its location only. Now if we change either ‘i’ or ‘*pi’, the corresponding value at the location will change. Here 

arises the misconception that ‘pi’ is associated with ‘i’, which is not. Consider the following example:

int *pi;

pi=(int *)malloc(sizeof((int));

/* malloc is a function to dynamically allocate memory to a pointer. It returns ‘void *’, which is typecasted as ‘int *’ */

*pi=1024;

printf(“The value at pi is”,*pi);

free(pi);

Here ‘pi’ is a pointer which points to an integer value. But it does not points to some variable, but a memory location is allocated to it using ‘malloc’.

Hence we conclude that a pointer is a variable which points to a memory location and not particularly the location of a variable.

C program to evaluate a polynomial using HORNER’s Rule

Recently I was going through Data Structures in C, and I came to the problem of evaluating a polynomial using Horner’s rule. Horner’s rule is a strategy for evaluating a polynomial A(x) at a point using a minimum number of multiplication.

The following C program is a correct one, but the thing I want to emphasize is trouble with the use of global variables. Lets go through the C code first:

#include<stdio.h>
#include<conio.h>
int horner(int,int);
int count=0;
void main()
{
     /*Horner's rule for evaluating a polynomial */
     /* let us take a0=0,a1=1,a2=2.. and so on */
    
     int n,x,h=0; //n is order, x is value of X in polynomial.
     scanf("%d %d",&n,&x);
     h=horner(n,x);
     printf("%d",h);
     getch();
}

int horner(int n, int x)
{
    int i;
    if(count!=n)
    {
                i=count;
                count++;
                printf("%d+%d*(",i,x);
                return (i + x*horner(n,x));
    }
    else
    {
        printf("%d))=",count);
    return count;
   
}
    
}

Initially I faced a big problem with the above program when I was not using the local variable ‘i’ in the ‘horner’ function. You can check the output with and without the use of ‘i’. The problem was that all the return statements were being evaluated after the last ‘horner’ got evaluated for the recursive function, and in the meanwhile, the global variable ‘count’ got changed every time ‘horner’ was evaluated. Since the return statement depends upon ‘count’, the output came out to be deviated from the expected value depending upon the size of input. Hence the variable ‘i’ came into existence.