Memory layout in C

Introduction

Memory layout refers to how a computer’s memory is organized and structured. It defines how memory is divided and utilized by various system components.

This is crucial in C as it directly impacts how variables, functions, and data structures are stored and accessed during execution.

In this article, we’ll learn about the fundamental aspects of the memory layout in the C.

Segments In C’s Memory Layout

The memory layout in C consists of different segments, below are the segments;

1. Text(Code) segment.
2. Data segment.
3. Heap.
4. Stack.

The diagram below depicts C’s memory layout.

Now let’s discuss the segments in detail.

Text(code) Segment

The text segment is a region of memory in a C program that stores the compiled machine code instructions. These instructions constitute the executable logic of the program and are responsible for defining its behavior.

Here's a simple example to illustrate the concept of the text segment in a C program:

#include <stdio.h>

int main() {
    int x = 5;
    int y = 10;
    int sum;

    sum = x + y;
    printf("The sum of %d and %d is %d\n", x, y, sum);

    return 0;
}

The compiler converts the source code into machine code when this program is compiled. This machine code constitutes the logic and behavior of a program and is stored in the text segment.

While we can't directly see the machine code. We can understand that the text segment contains the compiled instructions.

Essentially, the text segment holds instructions that define how the program behaves when it's executed.

Data segment

The data segment is divided into two parts:

• Initialized data segment
• uninitialized data segment

Initialized Data Segment

The initialized data segment consists of global, extern, static(both local and global), and constant global variables initialized beforehand. The initialized data segment has two sections, the read-only and read-write sections.

Variables with predefined values that can be modified i.e. initialized global, extern, and static(both local and global) variables are stored in the read-write section. Constant variables on the other hand come under the read-only section.

Here's an example illustrating variables stored in the initialized data segment, both in the read-write and read-only sections:

#include <stdio.h>

// Global variable (read-write section)
int globalVar = 10;

// External variable declaration (read-write section)
extern int externVar;

// Static global variable (read-write section)
static int staticGlobalVar = 20;

// Constant global variable (read-only section)
const int constGlobalVar = 30;

int main() {
    globalVar += 5;
    staticGlobalVar += 10;

    printf("Global variable: %d\n", globalVar);
    printf("Extern variable: %d\n", externVar);  // Assuming externVar is defined in another file
    printf("Static global variable: %d\n", staticGlobalVar);
    printf("Constant global variable: %d\n", constGlobalVar);

    return 0;
}

This illustrates variables stored in the read-write and read-only sections of the initialized data segment.

Uninitialized Data Segment

The uninitialized data segment also known as BSS(Block started by symbol) segment consists of uninitialized global, extern, and static(both local and global) variables.

These variables are initialized to zero by default before the program's execution. They have read-write permissions. Thus allowing them to be both read from and written to during the program's execution.

Example:

#include <stdio.h>

// Uninitialized global variable (goes to the BSS segment)
int globalVar;

// Uninitialized static global variable (also goes to the BSS segment)
static int staticGlobalVar;

int main() {
    // Uninitialized local static variable (goes to the BSS segment)
    static int staticLocalVar;

    printf("Uninitialized Global Variable: %d\n", globalVar);
    printf("Uninitialized Static Global Variable: %d\n", staticGlobalVar);
    printf("Uninitialized Static Local Variable: %d\n", staticLocalVar);
    return 0;
}

In this program, the uninitialized variables will contain zero or null values by default. This is due to automatic initialization by the compiler. This shows the behavior of variables stored in the BSS segment.

Heap

The heap is a region of memory used for dynamic memory allocation during runtime. This allows memory to be allocated and released as needed during program execution. Functions such as malloc(), calloc(), realloc(), and free() are used for memory allocation and deallocation in the heap. The heap is accessible to all parts of the program.

Example:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Dynamically allocate memory for an integer variable on the heap
    int *ptr = (int *)malloc(sizeof(int));

    return 0;
    }

This code snippet demonstrates a simple use of dynamic memory allocation in C. It draws attention to the steps involved in requesting memory, initializing a pointer to that memory, and managing memory properly to avoid leaks. While error handling and memory deallocation are not included in this example, these are crucial components of working with dynamic memory in practical applications.

Stack

The stack segments primary function is to manage function calls and store local variables. This part is crucial in a program's memory layout, as it controls the flow within a program. The stack adopts a Last In, First Out (LIFO) structure, meaning the most recently added data is removed first. This makes the stack very efficient for managing local variables and nested function calls.

Example:

#include <stdio.h>

void functionA(int n) {
    int a = n + 1; // Local variable
    printf("In functionA, a = %d\n", a);
}

void functionB() {
    int b = 10; // Local variable
    printf("In functionB, b = %d\n", b);
    functionA(b); // Call to functionA
}

int main() {
    int x = 20; // Local variable
    printf("In main, x = %d\n", x);
    functionB(); // Call to functionB
    return 0;
}

The code explains how stack frames store local variables. New stack frames are created by the function calls and are eliminated when the functions return. The printf instructions facilitate the visualization of each function's local variable values. The execution flow follows the calls to and returns from functions.

Conclusion

C programmers can improve their coding techniques and gain a better understanding of how their programs interact with memory by mastering these concepts. Understanding memory layout is a vital skill in your programming toolbox, whether you're optimizing for performance or troubleshooting a complex problem.

Feel free to follow, comment, and leave claps. Happy Coding!

Let’s connect on LinkedIn.