How to use double pointer as pointer arrays?

Question

Version 1:

struct mydef_s1 {
    int argc;
    char *argv[3];
};          

struct mydef_s1   *p1 = (struct mydef_s1*) malloc (sizeof (struct mydef_s1));     
p1->argv[0] = malloc (8);
p1->argv[1] = malloc (16);
p1->argv[2] = malloc (24);

Now, I want to achieve above with the following structure declaration?

Version 2:

struct mydef_s2 {
    int argc;
    char **argv;
};  

If I am right, then following would like allocate just 8 bytes (4 for memory pointer & 4 for integer in my machine)

struct mydef_s2   *p2 = (struct mydef_s2*) malloc (sizeof (struct mydef_s2));

What should I do to do the following?

p2->argv[0]= malloc(4);
p2->argv[1]=malloc(8);

Answer 1

In the case of a pointer to pointer like

struct mydef_s2 {
    int argc;
    char **argv;
};  

you have to first allocate the memory for argv itself, then for argv[i]s.

Something like (code is without error check)

  argv = malloc(n * sizeof*argv);  //allocate memory to hold 'n' number of 'argv[i]'s
  for (i = 0; i < n; i++)
       argv[i] = malloc(32);    //allocate individual `argv[i]`s

will do the job.

Answer 2

A pointer in C is behaving somewhat like an array. A pointer to pointer, however, is something completely different than a two dimensional array.

If you meant what you typed, i.e. - an array of a non (compiled time) known size of pointers to arrays of non compiled time known sizes of chars, then you will need to do just that. Allocate storage for the array of pointers, place that in your argv, and then initialize each position there with a pointer, possibly dynamically allocated with malloc, of the actual array of chars.

If, on the other hand, you meant a two dimensional array, you have two ways to proceed. One is to do the above, possibly saving a step by allocating the inner nesting in one malloc at one go. This is somewhat wasteful in memory.

The other option is to simulate what the compiler does for two dimensional arrays. Allocate n*m chars as a single dimension array, and jump into it by with the formula i = r*m + c, where r is the row index, m is the row size, and c is the column index.

While somewhat verbose, this is what C does when you define a two dimensional array. It is also quicker to allocate, initialize and use than the alternative.