mallocing是否等效于具有指定数组大小的指针

Question

I've read various tutorials on pointers, and I now come with a question,

is this:

char *input = malloc(sizeof(char)*24);

the same as

char *input[24];

I was under the impression that the malloc will also create my space on the heap with 24 slots. Usually, I see char input[24], but the char *input[24] I figured was a simpler way than mallocing.

Thanks!

Answer 1

No, they are not the same.

char *input = malloc(sizeof(char)*24);

will allocate a block of 24 char's on the heap and assign a pointer to the start of that block to input. (technically you are just telling it to allocate x number of bytes where x is 24 times the size, in bytes, of each char)

char *input[24];

will create an array of 24 char pointers on the stack. These pointers will not point to anything (or garbage on init) as you have it written.

For the second example, you could then take each pointer in the array input and allocate something for it to point to on the heap. Ex:

char *input[NUM_STRS];
for( int i = 0; i < NUM_STRS; i++ )
    {
    input[i] = malloc( MAX_STR_LEN * sizeof(char) );
    }

Then you would have an array of character pointers on the stack. Each one of these pointers would point to a block of characters on the heap.

Keep in mind, however, that things on the stack will be popped off when the function exits and that variable goes out of scope. If you malloc something, that pointer will be valid until it is freed, but the same is not true of an array created on the stack.

EDIT : Based on your comment, here is an example of making 24 character pointers on the heap and allocating space for them to point to:

#define NUM_STRS 24
#define MAX_STR_LEN 32
char **input = malloc( sizeof(char *) * NUM_STRS );
for( int i = 0; i < NUM_STRS; i++ )
    {
    input[i] = malloc( sizeof(char) * MAX_STR_LEN );
    }

Please keep in mind that with this example you will have to free each pointer in input, and then input itself at the appropriate time to avoid leaking memory.

Answer 2

These are not the same at all.

char *input = malloc(sizeof(char)*24);

This allocates enough memory to hold 24 char , and assigns the address to input (a pointer). This memory is dynamically-allocated, so it needs to be released at some point with an appropriate call to free() .

char *input[24];

This declares input to be an array of 24 pointers. This has automatic storage , which means you do not need to free it. (However, you may need to free the things being pointed to by each of the pointers, but that's a different matter!)

Answer 3

Fundamentally, the types of the two variables are different. In the first case, you declare a pointer to char that points to memory dynamically allocated by malloc (which you are morally obligated to free at a later instant). In the second case, you declare an array of pointers to char .

Couple of observations:

• sizeof(char) is one by definition, so you can leave that out. (No, it does not convey a documenting purpose . You are better of rewriting it as char *input = malloc( 24 * sizeof *input ); )
• Very seldom will the call to malloc have an integer literal. If it does ( 24 ) in your example, then usually one would prefer to have an array to hold that (there are some considerations regarding stack usage that I am side-stepping here).

hope this helps,

Answer 4

You can compare it better to char input[24]; (note no *). With that you can use input in the same way but the memory is on the stack instead of on the heap.