如果没有指针，堆栈上的内存如何识别？

Question

Correct me if I'm wrong but pointers are identifiers (an ID) given to each bit of memory. If the memory on the heap has pointers it can be identified which gives the code ability to delete, modify or even change it's size. The confusion comes when I've read a book saying stack doesn't have pointers.

I've been reading the book 'Head First C', and it was talking about pointers. Was it simply refering to pointers just as an example? Or does the memory on the stack have some kind of pointer to memory?

If not, how is it identified? The confusion or contradiction between web posts and books have really confused me on a subject I am only just understanding. Can anyone clear this up?

Answer 1

Every memory location has an address . There is nothing like the idea you suggest that stack memory does not have addresses.

A pointer value is the address of a memory location, and a pointer variable is a variable that can store a pointer value.

Answer 2

Data in the stack is referenced by an offset from the stack/base pointer.

When your program is executed, a chunk of memory is allocated by the OS for its purposes. The stack will then be used by your program to store data that is required for normal execution. Note that this chunk of memory may not be sequential in the physical memory but a virtual memory space mapped by the OS.

When a variable is defined locally in a function, the compiler will generate code that reads a chunk of data in the stack that is used to represent your variable. Care is taken by the compiler to ensure multiple variables will not occupy the same space. Note that a optimising compiler can still use the same space for several variables if previous definitions are deemed as useless within the execution flow (Not to be confused with lifetime validity of a variable in C++).

This process however, is only applicable when you know exactly how much memory you need at compile time, meaning the compiler will be able to generate an offset for each named variable defined in your program. This means that there is no need to explicitly read a memory location, aka dereferencing of pointers. However, this does not mean that the variable itself does not reside in a memory location and does not have an address that can reference it.

When writing programs that require dynamic memory allocation, you will have to explicitly tell the OS to allocate more memory to your program. Since this memory location is dynamic, the address will not be known at compile time, meaning data access can only be done via dereferencing memory locations. In this case, it will be the additional chunk of memory allocated by the OS.

Last but not least, compilers can and will always try generate code that stores variables in registers, hence referencing a variable can be very different depending on the code generated.