No history yet

Memory Layout

A Program's Place in Memory

When your C program runs, the operating system doesn't just toss it into a random corner of RAM. It carves out a specific, organized block of virtual memory for it. This space is divided into several distinct segments, each with a specific job. Think of it like a well-organized workshop: every tool and material has its designated place.

This layout ensures efficiency and prevents chaos. The main segments are the Text, Data, BSS, Heap, and Stack. Let's look at the first three, which are determined when your program is compiled.

Text Segment: This is where your compiled machine code lives. It's the set of instructions the CPU executes. This segment is typically marked as read-only. If you try to write data here, the system will stop you with a segmentation fault.

Data Segment: This holds global and static variables that you initialized with a specific value in your code. The size of this segment is fixed at compile time.

BSS Segment: This section holds global and static variables that are uninitialized or initialized to zero. The name is a historical artifact from an old assembler. The key here is optimization; the actual executable file on your disk doesn't need to store a block of zeros. It just records how much space the [{}] needs, and the OS allocates and zero-fills that memory when the program starts.

#include <stdio.h>

int initialized_global = 42;      // Goes in the Data segment
char* string_literal = "Hello";   // The pointer is in Data, "Hello" is in Text

int uninitialized_global;         // Goes in the BSS segment
static int static_zero_global = 0; // Also goes in the BSS segment

int main() {
    // main function code lives in the Text segment
    printf("Segments are organized!\n");
    return 0;
}

The Dynamic Duo

While the Text and Data segments are static, the Stack and Heap are dynamic. They grow and shrink as your program runs.

The Stack is an orderly, last-in, first-out (LIFO) structure. It's used for managing function calls and storing local variables. When you call a function, the system pushes a new stack frame onto the stack. This frame contains the function's parameters, its local variables, and the return address—the spot in the code where execution should resume after the function finishes. When the function returns, its frame is popped off the stack.

This process is extremely fast because it only involves adjusting a single CPU register called the stack pointer. The downside is that all memory on the stack must have its size known at compile time, and it's automatically deallocated when the function exits. You can't create a variable on the stack in one function and expect it to be alive after that function returns.

The Heap is the Wild West of memory. It's a large pool of memory available for you to use however you see fit. Unlike the stack, memory on the heap is managed manually. You request a chunk of memory using functions like malloc(), and that memory remains allocated until you explicitly free it with free(). This is perfect for data that needs to live longer than a single function call, or when you don't know the size of the data you need at compile time.

The trade-off is speed and responsibility. Heap allocation is slower than stack allocation because the system has to find a suitable free block of memory. And if you forget to free memory, you create a memory leak, where your program holds onto memory it no longer needs, potentially crashing if it runs out.

Alignment and Ordering

Computers don't always read memory one byte at a time. To improve performance, a CPU often fetches data in chunks of 4 or 8 bytes. For this to work efficiently, the data needs to be aligned. Memory alignment means that an object's memory address should be a multiple of its size. A 4-byte integer should start at an address divisible by 4.

If data isn't aligned, the CPU might have to perform two memory reads instead of one to fetch it, slowing things down. To prevent this, the C compiler often adds invisible padding bytes inside structures.

struct PaddedExample {
    char a;    // 1 byte
    // 3 bytes of padding inserted by compiler
    int b;     // 4 bytes
    char c;    // 1 byte
    // 7 bytes of padding inserted by compiler
};
// sizeof(PaddedExample) is 16, not 6!

Finally, when a multi-byte data type like an int is stored in memory, the order of its bytes matters. This is called ().

  • Big-endian: The most significant byte is stored at the lowest memory address. It's like writing numbers the way we read them, from left to right.
  • Little-endian: The least significant byte is stored at the lowest memory address. This is more common in modern CPUs like x86.

This usually doesn't matter unless you're sending binary data over a network or reading files created on a system with different endianness. It's a crucial detail in low-level systems programming.

Quiz Questions 1/6

In a C program, which memory segment is used for dynamic memory allocation, where the size of the data might not be known at compile time and needs to persist beyond a single function call?

Quiz Questions 2/6

What is the primary reason for memory alignment in C?

Understanding how memory is laid out is the first step toward mastering C. It explains many of the language's features and potential pitfalls, from dangling pointers to buffer overflows.