Unlike the stack, there's no enforced pattern to the allocation and deallocation of blocks from the heap you can allocate a block at any time and free it at any time. The heap is memory set aside for dynamic allocation.

This makes it really simple to keep track of the stack freeing a block from the stack is nothing more than adjusting one pointer. The stack is always reserved in a LIFO (last in first out) order the most recently reserved block is always the next block to be freed. When that function returns, the block becomes unused and can be used the next time a function is called. When a function is called, a block is reserved on the top of the stack for local variables and some bookkeeping data. The stack is the memory set aside as scratch space for a thread of execution. Valgrind doesn't work well with stack-related errors, but like a debugger, it may help you pin-point the location and reason for the crash. You can get some information about the point of overflow by running the program with a debugger. Note that -fstack-protector should always be turned on for release builds as it is a security feature. In that case you will get a different error, most likely a segmentation fault as you are trying to access an illegal memory location. To get some insight, you can try disabling this protection of gcc using option -fno-stack-protector while compiling. An input string of size greater than 10 causes corruption of this variable resulting in SIGABRT to terminate the program. The compiler, (in this case gcc) adds protection variables (called canaries) which have known values. For example in the following snippet: #include Stack Smashing here is actually caused due to a protection mechanism used by gcc to detect buffer overflow errors.

Stack smashing detected