array and pointer ..char *argv[]

The arguments to a program are passed via two values :

    1) argc contains the number of arguments that were passed (including the name of the program)

    2) argv contains an array of the arguments (one string each). There will be argc arguments in the array, and the first will be the name of the program.

So, as said before, argv is an array of char* (and a char* is basically a string in C). In memory, that looks like this :

   -------------      ------------------------------------------------------------------------
   | argv[0] | --> | 'p' | 'r' | 'o' | 'g' | 'r' | 'a' | 'm' | '_' | 'n' | 'a' | 'm' | 'e' | '\0' |
   -------------      ------------------------------------------------------------------------
   |              |      -------------------------------------------------------------------------------
   | argv[1] | --> | 'f' | 'i' | 'r' | 's' | 't' | '_' | 'a' | 'r' | 'g' | 'u' | 'm' | 'e' | 'n' | 't' | '\0' |
   -------------      --------------------------------------------------------------------------------
   |              |      ---------------------------------------------------------------------------------------
   | argv[2] | --> | 's' | 'e' | 'c' | 'o' | 'n' | 'd' | '_' | 'a' | 'r' | 'g' | 'u' | 'm' | 'e' | 'n' | 't' | '\0' |
   -------------      ----------------------------------------------------------------------------------------

So, to access the first argument that was passed to the program, you use argv[1].
To access the third character of the first argument, you use argv[1][2].


>> Does it mean that the memory has already been allocated for the string ?

Yes, the memory has already been allocated for you.


>> also, if i declare a double like below , what does it mean..
>> double *a[12]..

It means you create an array of double pointers. You get something like this in memory :

      -----------
      | a[0]    |  -->
      |           |
      -----------
      | a[1]    |  -->
      |           |
      -----------
          ...
      -----------
      | a[11]  |  -->
      |           |
      -----------

So, an array of pointers to double that don't point to anything at the moment.

To use them, you need to let the pointers point to something, either by letting them point to already existing memory, or by allocating new memory for them.
Suppose you allocate new memory for them like this :

      for (i = 0; i < 12; ++i) {
          a[i] = (double*) calloc(1, sizeof(double));    /* we allocate memory for 1 double, but we could have allocated more */
      }

then we get this :

      -----------         ------------
      | a[0]    |  -->  |            |
      |           |         ------------
      -----------         ------------
      | a[1]    |  -->  |            |
      |           |         ------------
      -----------
          ...
      -----------         ------------
      | a[11]  |  -->  |            |
      |           |         ------------
      -----------

We can now put values in there, by doing for example :

      *(a[1]) = 0.5;

which gives us :

      -----------         ------------
      | a[0]    |  -->  |            |
      |           |         ------------
      -----------         ------------
      | a[1]    |  -->  |   0.5    |
      |           |         ------------
      -----------
          ...
      -----------         ------------
      | a[11]  |  -->  |            |
      |           |         ------------
      -----------

And so on.


Remember that I only allocated memory for 1 double ? We could have allocated memory for more than one double like this :

      for (i = 0; i < 12; ++i) {
          a[i] = (double*) calloc(3, sizeof(double));    /* we allocate memory for 3 doubles */
      }

then we get this :

      -----------         ---------------------------------
      | a[0]    |  -->  |            |            |            |
      |           |         ---------------------------------
      -----------         ---------------------------------
      | a[1]    |  -->  |            |            |            |
      |           |         ---------------------------------
      -----------
          ...
      -----------         ---------------------------------
      | a[11]  |  -->  |            |            |            |
      |           |         ---------------------------------
      -----------

We can now put values in there, by doing for example :

      a[1][2] = 0.5;

which gives us :

      -----------         ---------------------------------
      | a[0]    |  -->  |            |            |            |
      |           |         ---------------------------------
      -----------         ---------------------------------
      | a[1]    |  -->  |            |            |    0.5   |
      |           |         ---------------------------------
      -----------
          ...
      -----------         ---------------------------------
      | a[11]  |  -->  |            |            |            |
      |           |         ---------------------------------
      -----------

And so on.

Note that since we allocated dynamic memory ourselves, that we also need to clean it up ourselves once we don't need it any more :

      for (i = 0; i < 12; ++i) {
          free(a[i]);
      }


>> I guess, i dont understand what a pointer and [] together means...

You have to read them as they are defined. In this case, it's an array ([]) of pointers (*) to char, and the array is named argv :

      char* argv[]


Does that make more sense ?