Thread: Declaring dynamic vs fixed 2D char array

For example I have a list of names to be created. I can use a **char (string array).

Method 1:

declaring a dynamic array

Code:

    char **namelist = (char **) calloc(6, sizeof (char*));


    for (int i=0; i<6; i++)
    {
        namelist[i] = (char *) calloc(20, sizeof (char));
    }

Method 2:
Declare array with fixed size

Code:

    char namelist[6][20];

One of my colleague told me the second one is more appropriate because the first one will slow down while allocating small amount of memories in heap. Is that considerable or negligible?

My second question, If I have to pass this array into another function, which is the right way to declare the array?

Common wisdom says that calloc() is slow. There are a bunch of explanations for it. I look at a failed or slow allocation like winning the lottery - you just get very unlucky. Unfortunately there isn't a lot you can do about that, if you need calloc(). Without knowing the compiler vendor's implementation strategy, it can feel impossible to create favorable conditions. Because different implementations can become slow or not work in different ways. For example, free list implementations of malloc() - which calloc() will probably call - might try to merge many small, previous allocations into a larger chunk, which can be slow. You could profile calloc() in the real code and see how slow it actually is - measuring is the only way to be sure. In a very recent thread, the subject came up (albeit in a slightly different context,) and the results were surprising, and favorable(!) when it was actually tested.

Like I said, winning the lottery. It's just really hard to know what will happen.

I would declare namelist on the stack because it can fit on the stack. 120 bytes is a very small amount. Eventually I stop thinking hard.

For your second question, remember the goal is to do something like this:

Code:

foo(name);

To achieve this, simply declaring foo like this actually works:

Code:

void foo(char namelist[6][20]);

But the compiler only pays attention to dimension sizes after the first - so it could look more like:

Code:

void foo(char *name[20]);

It should be:

Code:

void foo(char (*namelist)[20]);

You can minimize your calloc calls like so:

Code:

char **namelist;

// no need to use calloc here
namelist = malloc(numrows * sizeof *namelist);

// calloc all elements at the same time
namelist[0] = calloc(numrows * numcols, sizeof **namelist);

// assign rows to namelist elements
for (int i = 1; i < numrows; i++)
  namelist[i] = namelist[0] + i * numcols;

However, if you can use a fixed array then you may as well:

Code:

#define NUMROWS 6
#define NUMCOLS 20
//...
char namelist[NUMROWS][NUMCOLS] = {{0}};;