nixawk
commented
6 years ago Stack
demo1
#include "stdafx.h"
#include <windows.h>
int ShowStackLayout(int x, int y)
{
int z;
z = x + y;
return z;
}
int main(int argc, char *argv[])
{
int x = 1;
int y = 2;
int z;
z = ShowStackLayout(x, y);
printf("x + y = %d\n", z);
return 0;
}- debug
0:000> bp Stack_VS_Heap!ShowStackLayout
0:000> g
0:000> p
0:000> uf Stack_VS_Heap!ShowStackLayout
Stack_VS_Heap!ShowStackLayout [c:\users\debug\desktop\src\stack_vs_heap\stack_vs_heap\stack_vs_heap.cpp @ 9]:
9 00411390 55 push ebp
9 00411391 8bec mov ebp,esp
9 00411393 81eccc000000 sub esp,0CCh
9 00411399 53 push ebx
9 0041139a 56 push esi
9 0041139b 57 push edi
9 0041139c 8dbd34ffffff lea edi,[ebp-0CCh]
9 004113a2 b933000000 mov ecx,33h
9 004113a7 b8cccccccc mov eax,0CCCCCCCCh
9 004113ac f3ab rep stos dword ptr es:[edi]
12 004113ae 8b4508 mov eax,dword ptr [ebp+8]
12 004113b1 03450c add eax,dword ptr [ebp+0Ch]
12 004113b4 8945f8 mov dword ptr [ebp-8],eax
13 004113b7 8b45f8 mov eax,dword ptr [ebp-8]
14 004113ba 5f pop edi
14 004113bb 5e pop esi
14 004113bc 5b pop ebx
14 004113bd 8be5 mov esp,ebp
14 004113bf 5d pop ebp
14 004113c0 c3 ret
0:000> dd /c 1 [ebp-8]
0012fe28 00000003 ---- [ebp-8] local variable
0012fe2c cccccccc ---- [ebp-4]
0012fe30 0012ff30 ---- [ebp]
0012fe34 00411409 ---- [ebp+4] : return address
0012fe38 00000001 ---- [ebp+8]: arg1
0012fe3c 00000002 ---- [ebp+c]: arg2
0012fe40 00000000
0012fe44 000000000:000> u 00411409
Stack_VS_Heap!main+0x39 [c:\users\debug\desktop\src\stack_vs_heap\stack_vs_heap\stack_vs_heap.cpp @ 22]:
00411409 83c408 add esp,8
0041140c 8945e0 mov dword ptr [ebp-20h],eax
0041140f 8bf4 mov esi,esp
00411411 8b45e0 mov eax,dword ptr [ebp-20h]
00411414 50 push eax
00411415 683c574100 push offset Stack_VS_Heap!`string' (0041573c)
0041141a ff15b0824100 call dword ptr [Stack_VS_Heap!_imp__printf (004182b0)]
00411420 83c408 add esp,8demo2
#include "stdafx.h"
#include <windows.h>
#ifndef BUFSIZE
#define BUFSIZE 4
#endif
void StackOverflow(char *input)
{
char localbuf[BUFSIZE];
strcpy(localbuf, input);
}
int main(int argc, char *argv[])
{
char buf[] = "AAAA";
StackOverflow(buf);
return 0;
}- BUFSIZE = 0x04, char localbuf[] = dd /c1 ebp-0x08
- BUFSIZE = 0x08, char localbuf[] = dd /c1 ebp-0x0C
- BUFSIZE = 0x0c, char localbuf[] = dd /c1 ebp-0x10
Stack vs Heap
So far we have seen how to declare basic type variables such as int, double, etc, and complex types such as arrays and structs. The way we have been declaring them so far, with a syntax that is like other languages such as MATLAB, Python, etc, puts these variables on the stack in C.
The Stack
What is the stack? It's a special region of your computer's memory that stores temporary variables created by each function (including the main() function). The stack is a "LIFO" (last in, first out) data structure, that is managed and optimized by the CPU quite closely. Every time a function declares a new variable, it is "pushed" onto the stack. Then every time a function exits, all of the variables pushed onto the stack by that function, are freed (that is to say, they are deleted). Once a stack variable is freed, that region of memory becomes available for other stack variables.
The advantage of using the stack to store variables, is that memory is managed for you. You don't have to allocate memory by hand, or free it once you don't need it any more. What's more, because the CPU organizes stack memory so efficiently, reading from and writing to stack variables is very fast.
A key to understanding the stack is the notion that when a function exits, all of its variables are popped off of the stack (and hence lost forever). Thus stack variables are local in nature. This is related to a concept we saw earlier known as variable scope, or local vs global variables. A common bug in C programming is attempting to access a variable that was created on the stack inside some function, from a place in your program outside of that function (i.e. after that function has exited).
Another feature of the stack to keep in mind, is that there is a limit (varies with OS) on the size of variables that can be stored on the stack. This is not the case for variables allocated on the heap.
To summarize the stack:
The Heap
The heap is a region of your computer's memory that is not managed automatically for you, and is not as tightly managed by the CPU. It is a more free-floating region of memory (and is larger). To allocate memory on the heap, you must use malloc() or calloc(), which are built-in C functions. Once you have allocated memory on the heap, you are responsible for using free() to deallocate that memory once you don't need it any more. If you fail to do this, your program will have what is known as a memory leak. That is, memory on the heap will still be set aside (and won't be available to other processes). As we will see in the debugging section, there is a tool called valgrind that can help you detect memory leaks.
Unlike the stack, the heap does not have size restrictions on variable size (apart from the obvious physical limitations of your computer). Heap memory is slightly slower to be read from and written to, because one has to use pointers to access memory on the heap. We will talk about pointers shortly.
Unlike the stack, variables created on the heap are accessible by any function, anywhere in your program. Heap variables are essentially global in scope.
Stack vs Heap Pros and Cons
Stack
Heap
When to use the Heap?
When should you use the heap, and when should you use the stack? If you need to allocate a large block of memory (e.g. a large array, or a big struct), and you need to keep that variable around a long time (like a global), then you should allocate it on the heap. If you are dealing with realtively small variables that only need to persist as long as the function using them is alive, then you should use the stack, it's easier and faster. If you need variables like arrays and structs that can change size dynamically (e.g. arrays that can grow or shrink as needed) then you will likely need to allocate them on the heap, and use dynamic memory allocation functions like malloc(), calloc(), realloc() and free() to manage that memory "by hand". We will talk about dynamically allocated data structures after we talk about pointers.
References