哪个在C分配/释放使用局部变量的内存方面更好？为什么？

Question

If I need to do string manipulation or manipulating any kind of arrays be it stantard types like int or a self defined data structure. What is better local variable or dynamically allocating and de-allocating memory?

I know that if you are using a local variable you will not need to allocate/de-allocate of the memory and that might save us from memory leaks. But I want to know why people like using dynamically allocate memory. Is it just a coding style or does it really have its benefits. Also does it depends on system on which we are compiling or does it depend on the compiler?

Even if the system have enough resources for memory and speed which technique is better suited to optimize the code?

Answer 1

Local, stack-allocated operations will pretty much always trump dynamic memory allocation in terms of speed. The reason being that, during dynamic memory allocation, your program needs to ask the operating system for help. This causes a context switch (which are very slow/expensive), and blocks until the operating system returns you a block of memory (which it may not even be able to).

Your program however, has its own stack already, and so it can manipulate that as necessary without interrupting the flow of execution (other than multi-tasking which is out of your control anyway).

The benefits to dynamic memory allocation are that sometimes we do not know how much we need to allocate until runtime. Without dynamic allocation, we would need to allocate a static buffer upfront, and reserve enough memory for the worst-case scenario (which we may or may not have enough resources for).

Answer 2

The question you should ask in this matter is: do I know the memory size the program's going to need in runtime?

If you know you'll be needing for instance only 3 int variables, then you should go for local variables. No memory leak, and your program won't run unless there's enough memory available.

If you can't predict how much memory you'll need, let's say if you need to read a file into memory, you have no choice but to go for dynamic allocation.

Answer 3

There are good reason for having both as options.

Typically, you will use a heap allocation (eg malloc ) when:

• you don't know the size of the allocation you will need until execution
• when it consumes a good amount of the stack memory (or all)
• when the allocation needs to live beyond the current scope (eg is returned from a function)

Also does it depends on system on which we are compiling or does it depend on the compiler?

It depends on both the compiler and the system you are targeting.

Even if the system have enough resources for memory and speed which technique is better suited to optimize the code?

What's more important is how you need to use and access the memory and the hardware in most cases. A local variable has more advantage for optimization. However, the compiler may optimize away calls to malloc , in some cases.

Answer 4

Local, non-malloc, calls will generally allocate/deallocate faster as they require only stack work and not heap management - and they have the added benefit of limited scope. But, they have limited scope and often you need your memory to last beyond a function.

On some embedded systems with limited stack space, one will call malloc even on local vars just to get access to the larger heap, but in general, you want to limit your memory access to the scope it is intended - regardless of performance considerations.

Answer 5

As a default position, unless you have a need for the allocation to outlive the scope in which it's created, or the allocation is significant, stack allocation is preferred. In your case, you're asking about a local variable, which should presumably be free'd at the end of the enclosing scope. One rule of thumb is that if the allocation is less than 1K , stack is appropriate, otherwise heap. Microsoft's _malloca uses this threshold to switch between stack and heap allocation. Of course, much depends on what state you expect the stack to be in for your allocation. For example, a 1K stack allocation in a deeply recursive function may not be wise.