malloc pointer to pointer

[kunalnandi]

how to allocate memory to any "pointer to pointer" variable using malloc.
eg:

char** ch;

[grumpy]

Like you allocate memory for anything using malloc().

    ch = malloc(whatever_number_of_pointers_required * sizeof(char *));

or, idiomatically, using the fact that sizeof() evaluates the size of its argument, but does not actually evaluate the argument.

       ch = malloc(whatever_number_of_pointers_required * sizeof(*ch));

This allocates a number of pointers to char. Those pointers, if you wish to dereference them, also need to point to something valid. If you want to dynamically allocate each pointer to char as well (which is one way of making the pointers point at something valid) then you might do this.

       ch = malloc(whatever_number_of_pointers_required * sizeof(*ch));
       if (ch != NULL)
       {
              int i;
              for (i = 0; i < whatever_number_of_pointers_required; ++i)
              {
                  ch[i] = malloc(whatever_number_of_chars_required_for_i * sizeof(ch[i]));

                    /*  assume whatever_number_of_chars_required_for_i is at least 2 */

                  if (ch[i] != NULL)  strcpy(ch[i], "A");
               }
       }

It is necessary to #include <stdlib.h> in order to properly use malloc(), and <string.h> in order to use strcpy().

The other thing to remember with malloc() is that it is good practice to match every call of malloc() with a call of free(), when your program no longer needs the memory allocated.

[camel-man]

grumpy, could you also use ch[i] = malloc(whatever_number_of_chars_required_for_i * (sizeof(ch*))
in place of ch[i] = malloc(whatever_number_of_chars_required_for_i * sizeof(ch[i]))

[grumpy]

grumpy, could you also use ch[i] = malloc(whatever_number_of_chars_required_for_i * (sizeof(ch*))

Not quite. It would be ch[i] = malloc(whatever_number_of_chars_required_for_i * (sizeof(*ch[i])). (I left out an asterix in my previous post)

Equivalently the sizeof(ch[i]) expression may be replaced with sizeof(**ch).

The basic idiomatic technique is that whatever = malloc(number_required * sizeof(*whatever)).

Yes, it is true that sizeof(whatever[i]) and sizeof(*whatever) are always equivalent (assuming i has integral type). That is because, when evaluating sizeof(expression), the compiler only considers the TYPE of expression, not its value. So sizeof(whatever[i]) does NOT actually evaluate the values of either i or of whatever[i].