Well the author of the book prefers to use malloc() in a program to find prime numbers.

Since we don't know initially how many prime numbers the user wants, the author wants to allocate memory using malloc()

But the same thing could be done using an array.

I am just a beginner so don't know the real advantage.

Thanks for the help.

Unless you are using some non-standard compiler extensions, the size of an array must be declared at compile time. Therefore, since we don't know how many prime numbers the user wants, we can not "do the same thing" using an array, because we won't know what size to make it. We could easily size it way too small or even just 1 smaller than necessary and we would have serious problems.

There are some other benefits to using "heap" allocations versus "stack" allocations, but that is topic of another discussion.

The basic "test" for allocation is allocate only as much storage as is required. If you do not know how much will be required, dynamic allocation is probably your better choice. If you know that the user has only a surname, given name and perhaps a middle name, then allocation an array size of 3 elements deep appears to be a good option. But, how long is each name in characters (adding one extra for the terminator)?

What of those who have four or five names? What happens to our array then? What if we decide that nobody has more than 15 letters in any one of their names and then we encounter someone with 20?

This is a fairly typical problem with C and C++ programming. C++ handles this with much greater ease to the programmer through its standard containers and "string" class, but there isn't as much simplicity in C.

There are times when we know exactly how large something will be (or at least its maximum allowable size) and we can statically allocate for that maximum.


MxB

Unless it's a C99 standard conforming compiler.

To suggest that a VLA can replace a fixed size array is yet another over-simplification. While it is possible to declare VLAs in a C99-conformant compiler at a function prototype scope, some VLA declarations are simply not allowed.

Simplified and portable is that arrays must be sized at compile time.


MxB

For the problem originally posted here, the idea of using VLAs is misguided; it would take a rather non-intuitive approach to accomplish the goal. However, the use of VLAs can be a huge benefit when dealing with the generation of strings and such on the fly where many *alloc/free would open the door to leaks.
For instance: Is less preferable to the VLA version Again, each has their place, but the latter is much nicer in terms of ensuring proper memory handling.

__________________
My personal site: Utilities for text processing, debugging, testing and plotting