difference between str[strlen(src)+1] and char str=(char)malloc((strlen(src)+1)*sizeof(char)) in a function

Question

I'm confused. What is the difference between:

char *someFunction(char *src) {
    char str[strlen(src) + 1];
    ...
    return str;
}

and

char *someFunction(char *src) {
    char *str = (char*)malloc((strlen(src) + 1) * sizeof(char));
    ... 
    return str;
}

The first one is with an array (char[]) and second one is with malloc. What I learned in the school is that I should use malloc if I want to make a new char-string within a function. However, it works with char[] also within a function (like first one). The teacher said that we must use the "heap-area", if something must be dynamically allocated. I thought the first one with array (char str[..]) is also dynamic because the size of char[] is not actually known before the program begins (is this the correct understanding!?). This one works by my compiler without any problem.

Please explain the difference easily and tell me some cases where I must use malloc and where I don't need to use it.

`This one works by my compiler without any problem` The compiler does not detect everything. Returning invalid pointers such as in your first example will compile fine. — Jesse Good, Jan 30 '16 at 11:10
Multiplying by `sizeof(char)+1` is probably wrong. You probably want to multiply by `sizeof(char)`, or, since that's guaranteed to be 1, not bother with that multiplication at all. — Steve Summit, Jan 30 '16 at 11:14
>Jesse 誤りを直してくれありがとうございました。 ok. thanks — Nats, Jan 30 '16 at 11:14
In short for declaring small size array you can use your first declaration.But for large size arry it is better to use malloc — Sagar Patel, Jan 30 '16 at 11:18
Please see [Do I cast the result of malloc?](http://stackoverflow.com/a/605858/3204551) — Deduplicator, Jan 30 '16 at 11:22

haccks · Answer 1 · 2016-01-30T11:59:38.277

3

I thought the first one with array(char str[..]) is also dynamically, because the size of char[] is not actually known before the program begins(is it correct understanding!?)

No. You are using variable length array feature of c added since c99. This is not dynamic allocation.
Once the function complete its execution str will no longer exist and returning pointer to it will invoke undefined behavior.

edited Jan 30 '16 at 11:59

answered Jan 30 '16 at 11:06

haccks

104,019
25
176
264

"_Memory is allocated on stack rather than heap._" -- Is it? I recall reading that it is not specified where VLAs are allocated. – Spikatrix Jan 30 '16 at 11:31
@CoolGuy; ASFAI remember, its allocated on stack. – haccks Jan 30 '16 at 11:35
@CoolGuy; Well, GCC allocates memory on stack for sure. – haccks Jan 30 '16 at 11:38
1

@CoolGuy: you are correct, automatic storage does not necessary imply a stack, what matters is that `str` cannot be returned by this function. – chqrlie Jan 30 '16 at 11:38

chqrlie · Accepted Answer · 2016-01-30T11:48:00.093

The difference is simple:

The first uses a C99 syntax to allocate a VLA in automatic storage (usually on the stack). This array can only be used for the duration of the function call, you cannot return a pointer to it, it will cause undefined behavior when the caller uses this return value. This version is incorrect.
The second allocates an array from the heap, that can be used beyond the end of the function call, until it is explicitly deallocated by free or realloc. This type of allocation is usually referred to as dynamic, the word has a broader meaning in English, but not in this context.

Note that you should simplify the allocation this way:

char *someFunction(char *src) {
    char *str = malloc(strlen(src) + 1);
    .... 
    return str;
}

sizeof(char) is 1 by definition and casting the return value of malloc is usually a bad idea in C, although it is necessary in C++, but other allocation methods are preferred in C++ anyway.

Note that you can get a copy allocated by malloc of src using the Posix function strdup(src).

You should use memory allocated by malloc and its variants when the memory will be used after the end of the current function. If the size if significant, you should also use malloc to avoid invoking undefined behavior by running out of automatic storage. The limit varies from system to system, but with modern environments, automatic storage can usually handle at least one megabyte for all current function invocations, beyond that I recommend using heap storage.

score 1 · Answer 3 · answered Jan 30 '16 at 11:23

Using a VLA (the first example) means the array will no longer exist when the function returns. The caller will exhibit undefined behaviour if it attempts to use the function's return value. VLAs are only guaranteed to work with compilers that comply with the 1999 C standard (or later).

Using malloc() (the second example) means that the array will not be deallocated when the function returns (unless your code also explicitly calls free()). So the caller can safely use the return value from that version of the function. The code will work the same with all C standards (from 1989/1990 until today), and even some earlier compilers.

score 0 · Answer 4 · answered Jan 30 '16 at 11:08

0

In the first, you are declaring an object with automatic storage duration. So the array lives only as long as the function that calls it exists. In the second , you are getting memory with dynamic storage duration, which means that it will exist until it is explicitly deallocated with free.
In C stack is allocated for local variabls and heap is for malloc.So if you declare large array with char str[n], then you might exceed the stack's storage space, which will cause the segfault

answered Jan 30 '16 at 11:08

Sagar Patel

864
1
11
22

Usage of heap and stack are not mentioned in the C standard. What you're describing with that occurs with some compilers, but is not required. And there are some modern compilers/libraries, targeting some host systems (admittedly, systems in less common usage that windows or unix), which simply don't do things that way. – Peter Jan 30 '16 at 11:26

score 0 · Answer 5 · answered Jan 30 '16 at 11:51

0

When you declare a variable like ckar[something] it is saved in the stack and not in the heap. It's not dynamical allocation. If you want to dynamicaly alocate memmory you should use malloc and the array will be saved in the heap

answered Jan 30 '16 at 11:51

Vaggelis Spi

164
2
11

difference between str[strlen(src)+1] and char *str=(char*)malloc((strlen(src)+1)*sizeof(char)) in a function

5 Answers5

difference between str[strlen(src)+1] and char str=(char)malloc((strlen(src)+1)*sizeof(char)) in a function