Pointers in c

What is a Pointer?

A pointer is a variable which contains the address in memory of another variable. We can have a pointer to any variable type.

The unary or monadic operator & gives the ``address of a variable''.
The indirection or dereference operator * gives the ``contents of an object pointed to by a pointer''.
To declare a pointer to a variable do:
   int *pointer;
 
1st example: x value is 1 and address is 100 
in ip we assign the address of x into ip.

2nd example: *ip means getting the value at the address
contained by ip . so ip has 100 and at that address it has value 1 
so that value is assigned to y.

3rd example: we assign the value of ip that is 100 to x so x now has 100.

4th example: now this is tricky so try to understand this carefully.
*ip means assigning the value at the address contained by ip (100)
so at the address assign value 3 .
now the memory address 100 the value is 3.
as x's address is 100 so now x value also is now 3. 


We can do integer arithmetic on a pointer:

   float *flp, *flq;
 
   *flp = *flp + 10;
 
   ++*flp;
 
   (*flp)++;
 
   flq = flp;

NOTE: A pointer to any variable type is an address in memory -- which is an integer address. A pointer is definitely NOT an integer.
The reason we associate a pointer to a data type is so that it knows how many bytes the data is stored in. When we increment a pointer we increase the pointer by one ``block'' memory.
So for a character pointer ++ch_ptr adds 1 byte to the address.
For an integer or float ++ip or ++flp adds 4 bytes to the address.
Consider a float variable (fl) and a pointer to a float (flp) as shown in 
 
Pointer Arithmetic Assume that flp points to fl then if we increment the pointer ( ++flp) it moves to the position shown 4 bytes on. If on the other hand we added 2 to the pointer then it moves 2 float positions i.e 8 bytes as shown in the Figure.

Pointers and Arrays

Hint: think of array elements arranged in consecutive memory locations.

Consider the following:

   int a[10], x;
   int *pa;
 
   pa = &a[0];  /* pa pointer to address of a[0] */
 
   x = *pa;
   /* x = contents of pa (a[0] in this case) */

 
  Arrays and Pointers
To get somewhere in the array using a pointer we could do:

   pa + i a[i] 


There is no bound checking of arrays and pointers so you can easily go beyond array memory and overwrite other things.

For example we can just type

   pa = a;

instead of

   pa = &a[0]

and

   a[i] can be written as *(a + i). 
i.e. &a[i] a + i.  

We also express pointer addressing like this:

   pa[i] *(pa + i). 

However pointers and arrays are different:

• A pointer is a variable. We can do
  pa = a and pa++.
• An Array is not a variable. a = pa and a++ ARE ILLEGAL. 

Multidimensional arrays and pointers

We should think of multidimensional arrays in a different way in C:

A 2D array is really a 1D array, each of whose elements is itself an array

Hence

  a[n][m] notation.

Array elements are stored row by row.


Consider int a[5][35] to be passed in a function:

We can do:

   f(int a[][35]) {.....}

or even:

   f(int (*a)[35]) {.....} 
These both are same.
 


We need parenthesis (*a) since [] have a higher precedence than *

So:

   int (*a)[35]; declares a pointer to an array of 35 ints.  

  int *a[35]; declares an array of 35 pointers to ints.  
Understand the above eg, carefully as this might be confusing.


 char Aname[10][20]; 
Aname has 200 elements.
access the elements via 
 20*row + col+bas+address
in memory

char *name[10];
name has 10 pointer elements.
each pointer element can point to arrays of different length.

Consider the below :

char *name[] = { ``no month'', ``jan'',
    ``feb'', ... };
   char Aname[][15] = { ``no month'', ``jan'',
    ``feb'', ... };

 
2D Arrays and Arrays of Pointers
 name points to array of 13 elements  which in turn hold reference (address ) 13 arrays.
no month\0 is one array that name[0] is pointing to.
similarly jan\0
(Notice Each string ends with '\0' . String is an array of char type )
Consider the below example:



What happens when we declare a one dimensional array in memory.
in A[5]
mem location:
    200   204  208  212 216

 -----------------------------------------
   |2  |  4  | 6  | 8  | 10 |
------------------------------------------- 
    ^     ^     ^   ^     ^
    |     |     |   |     |   
   A[0]  A[1] A[2] A[3]  A[4]

contiguous block of memory 
integer is stored in 4 bytes ( block of four bytes) 

int *p = A;
address of array A will stored in p so aestrick upon a variable is used to hold 
value of address.
now we can by using d-referencing  technique get other elements of the array A.
eg:
print( p ) // Will give address of Array A 1.e 200
print( *p ) // will print the value at 200 memory location i.e 2 
          // Above is what is called d-referencing a pointer using * with         //address will give us the value at that address
print(*(p+2) )// will print 6 . This addition of 2 to integer pointer variable   
              //means we will hop two times from starting aadress
              // in address if we add anything suppose 2 or 3 what it does is 
              //adds 2*(no of bytes occupied by one element) here 4 bytes
              // occupied by each int element so 2*4 = 8 
              // 200+8 is 208 so p+2 is 208 and *(p+2) is the value at
              //208 i.e 6/


C gives us the flexibility of using array name instead of pointer variable.
Remember: Name of the array returns the address to the first element in the array.
So print( p ) is same as print(A)
similarly 
*A will print the value at A i.e 2.
*(A+2) will give us 6.

*(A+i) is same as A[i] .( where i being any number in the range of array i.e 
                           0 to n , n being the length of array )
A+1 is same as &A[i] . both will give us the address of the i th element.

Imp thing to note is 

int *p;
we can do p = A;
but not 
A=p; //will give compilation error

 

Two dimensional array.
int B[2][3];
here we are creating arrays of array 
in this case we are creating 2 one dimensional array of length 3.
B[0] -- an array of 3 elements so will occupy 3* 4 bytes( 4 because 
        each int element will occupy 4 bytes each ) so 12 bytes tot
B[1] -- another array of 3 elements.

   400            412
 -----------------------------------------
    400    404   408
   |  2  |3  | 4 | 5 | 6 | 7  |
    ^
  B[0][0]
------------------------------------------- 
    ^              ^ 
    |              |
   B[0]            B[1]


 int *p = B // compilation error as B will return pointer to a 1D array.

int (*p)[3] =B ;// This now correct as p will be able to hold what B returns
               // that is pointer to a 1 D array of 3 elements.
 


print(B);     // same as &B[0] that is 400

print(*B);    // same as &B[0] or &B[0][0] 400

print(B+1);   // B returns array of 3 integers 
              // adding 1 to that is like 
              // hoping the 3 elements 
              // B is 400 add one is 
              // hoping 3 int elements
              // 4*3 =12
             //412
         /// Don't get confused as this is a 2d array 
        // remember as b returns array of 3 so adding one to B will 
           //let us hop 1st row and go to next row.

print( *(B+1)); // same as B[1] or &B[1][0] ,B+1 returns a pointer to the 
                //  1 d array of 3 elements as shown above so 412 

                // *(B+1) is similar to int *p = &B[1][0]

print (*(*B+1)) ; // *B is same as &B[0] as we see above 
                  // adding one to that is same as adding 1 to memory address 
                  // of &B[0][0] which will give 404 
                    // Now *(&B[0][0]) which is we are dereferencing address 404 
            /// it will give us 3.
print ( *(B+1)+2)    // same as &B[1][0] add 2 to it is 412 + 2*4 ( int elements 
                     // has 4 bytes == 420


Point to remember

for a 2-d array 
B[i][j] where i and j are some indices in the array is same as 

B[i][j] == *(B[i]+j)

B[i][j] == *(*(B+i)+j)

























courtesy: http://www.cs.cf.ac.uk/Dave/C/node10.html