5

May be similar question found on SO. But, I didn't found that, here is the scenario

Case 1

void main()
{
    char g[10];
    char a[10];
    scanf("%[^\n] %[^\n]",a,g);
    swap(a,g);
    printf("%s %s",a,g);
}

Case 2

void main()
{
    char *g=malloc(sizeof(char)*10);
    char *a=malloc(sizeof(char)*10);
    scanf("%[^\n] %[^\n]",a,g);
    swap(a,g);
    printf("%s %s",a,g);
}

I'm getting same output in both case. So, my question is when should I prefer malloc() instead of array or vice-verse and why ?? I found common definition, malloc() provides dynamic allocation. So, it is the only difference between them ?? Please any one explain with example, what is the meaning of dynamic although we are specifying the size in malloc().

Improve this question
1
  • 2
    sizeof char is always 1 FYI Commented Dec 23, 2012 at 18:43

3 Answers 3

Reset to default
6

The principle difference relates to when and how you decide the array length. Using fixed length arrays forces you to decide your array length at compile time. In contrast using malloc allows you to decide the array length at runtime.

In particular, deciding at runtime allows you to base the decision on user input, on information not known at the time you compile. For example, you may allocate the array to be a size big enough to fit the actual data input by the user. If you use fixed length arrays, you have to decide at compile time an upper bound, and then force that limitation onto the user.

Another more subtle issue is that allocating very large fixed length arrays as local variables can lead to stack overflow runtime errors. And for that reason, you sometimes prefer to allocate such arrays dynamically using malloc.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I will appreciate, if you will explain with some examples
@var___ See my answer (and try to make the effort to understand this, it is something very basic...)
Ya, i'm trying, one thing, which confused me every time, the word dynamic. Perhaps, i'm trying to figure out from your answer.
In this instance dynamic is synonymous with at runtime. The key for you is to understand the difference between deciding an array length at compile time, or deciding at runtime.
@var___: the word dynamic is associated with when the requested memory is allocated rather than on how much memory is allocated. With malloc you cannot request to allocate arbitrary amount of memory during program's execution. In the case of array which is referred to as static memory allocation (en.wikipedia.org/wiki/Static_memory_allocation) since the program specifies to the compiler how much memory is needed during compile time itself. On the other hand, even though in the call to malloc you specify how much memory is needed it is not allocated until the call is made.
2

Please any one explain with example, what is the meaning of dynamic although we are specifying the size.

I suspect this was significant before C99. Before C99, you couldn't have dynamically-sized auto arrays:

void somefunc(size_t sz)
{
    char buf[sz];
}

is valid C99 but invalid C89. However, using malloc(), you can specify any value, you don't have to call malloc() with a constant as its argument.

Also, to clear up what other purpose malloc() has: you can't return stack-allocated memory from a function, so if your function needs to return allocated memory, you typically use malloc() (or some other member of the malloc familiy, including realloc() and calloc()) to obtain a block of memory. To understand this, consider the following code:

char *foo()
{
    char buf[13] = "Hello world!";
    return buf;
}

Since buf is a local variable, it's invalidated at the end of its enclosing function - returning it results in undefined behavior. The function above is erroneous. However, a pointer obtained using malloc() remains valid through function calls (until you don't call free() on it):

char *bar()
{
    char *buf = malloc(13);
    strcpy(buf, "Hello World!");
    return buf;
}

This is absolutely valid.

Improve this answer

Comments

0

I would add that in this particular example, malloc() is very wasteful, as there is more memory allocated for the array than what would appear [due to overhead in malloc] as well as the time it takes to call malloc() and later free() - and there's overhead for the programmer to remember to free it - memory leaks can be quite hard to debug.

Edit: Case in point, your code is missing the free() at the end of main() - may not matter here, but it shows my point quite well.

So small structures (less than 100 bytes) should typically be allocated on the stack. If you have large data structures, it's better to allocate them with malloc (or, if it's the right thing to do, use globals - but this is a sensitive subject).

Clearly, if you don't know the size of something beforehand, and it MAY be very large (kilobytes in size), it is definitely a case of "consider using malloc".

On the other hand, stacks are pretty big these days (for "real computers" at least), so allocating a couple of kilobytes of stack is not a big deal.

Improve this answer

2 Comments

This advice is fine so long as you know at compile time how much memory is needed
Yes, or at least you know that "it's not going to be more than this, and check that it's not more". I just dislike the general suggestion of "use malloc whenever you don't know the size of the input" - it's perfectly fine to have a 1000 character buffer to input a filename into, you don't need to read the filename by getchar and realloc as you go to make sure it matches perectly...

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.