Why we shouldn't dynamically allocate memory on stack in C?

We have functions to allocate memory on stack in both in windows and Linux systems but their use is discouraged also they are not a part of the C standard? This means that they provide some non-standard behavior. As I'm not that experienced I cannot understand what could be the problem when allocating memory from stack rather then using heap?

Thanks.

EDIT: My view: As Delan has explained that the amount of stack allocated to a program is decided during compile time so we cannot ask for more stack from the OS if we run out of it.The only way out would be a crash.S开发者_JAVA技巧o it's better to leave the stack for storage of primary things like variables,functions,function calls,arrays,structures etc. and use heap as much as the capacity of the OS/machine.

Stack memory has the benefit of frequently being faster to allocate than heap memory.

However, the problem with this, at least in the specific case of alloca(3), is that in many implementations, it just decreases the stack pointer, without giving regard or notification as to whether or not there actually is any stack space left.

The stack memory is fixed at compile- or runtime, and does not dynamically expand when more memory is needed. If you run out of stack space, and call alloca, you have a chance of getting a pointer to non-stack memory. You have no way of knowing if you have caused a stack overflow.

Addendum: this does not mean that we shouldn't use dynamically allocate stack memory; if you are

• in a heavily controlled and monitored environment, such as an embedded application, where the stack limits are known or able to be set
• keeping track of all memory allocations carefully to avoid a stack overflow
• ensuring that you don't recurse enough to cause a stack overflow

then stack allocations are fine, and can even be beneficial to save time (motion of stack pointer is all that happens) and memory (you're using the pre-allocated stack, and not eating into heap).

Memory on stack (automatic in broader sense) is fast, safe and foolproof compared to heap.

Fast: Because it's allocated at compile time, so no overhead involved

safe: It's exception safe. The stack gets automatically wound up, when exception is thrown.

full proof: You don't have to worry about virtual destructors kind of scenarios. The destructors are called in proper order.

Still there are sometimes, you have to allocate memory runtime, at that time you can first resort on standard containers like vector, map, list etc. Allocating memory to row pointers should be always a judicious decision.