Unit 1: C Memory Architecture, Dynamic Allocation & Pointer Mechanics 45 mins study timeINTERMEDIATE

Pointers, Memory Architecture and Dynamic Allocation in C

Foundational understanding of hardware memory addresses, pointer dereferencing, arithmetic, and heap allocation.

Verified: Faculty Peer Review Board

Learning Objectives

Essential Prerequisites

Layer 1: Intuition & Why It Matters

The Core Mental Model

“Imagine kijiye ki aapki computer memory (RAM) ek bahut bada post office locker system hai. Har locker ka ek unique locker number hota hai jise 'Memory Address' kehte hain, aur har locker ke andar kuch data rakha hota hai jise 'Value' kehte hain. Jab aap ek normal variable declare karte hain jaise 'int a = 10;', toh system ek locker allocate karta hai jisme 10 store hota hai. Par jab aap ek 'Pointer' create karte hain, toh woh pointer locker ke andar koi regular value nahi balki kisi doosre locker ka 'Address' store karta hai. Pointer ka matlab simple hai: 'Mujhe data ka pata (address) pata hai, jab zaroorat hogi main us pate par jaakar value padh ya badal sakta hoon.' Is process ko Dereferencing kehte hain.”

Why This Exists

Pointers operating system, embedded systems aur high-performance computing ka backbone hain. C language direct memory access provide karti hai bina kisi runtime overhead ke. Real production software jaise Linux Kernel, PostgreSQL, aur Redis complete pointers aur manual memory management par built hain.

Beginner Foundation

Pointer ek aisi special variable hai jo kisi doosre variable ka memory address store karta hai. Do primary operators use hote hain: 1. '&' (Address-of Operator): Yeh kisi variable ka hexadecimal address return karta hai. Example: &x ka matlab hai 'x ka memory address'. 2. '*' (Dereference Operator): Yeh us address par rakhi hui actual value ko read ya modify karne ke liye use hota hai. Example: *ptr ka matlab hai 'ptr jis address ko point kar raha hai, wahan ki value'.

Micro Concepts Decomposition

MICRO CONCEPT 1Canonical Object

Virtual RAM & Addressing Architecture

Har process ko OS 64-bit flat address space deta hai. Memory addresses 0x0000000000000000 se 0x7FFFFFFFFFFFFFFF tak user space hote hain.

Key Takeaway: All 64-bit pointers are 8 bytes.

MICRO CONCEPT 2Canonical Object

Address-of (&) and Dereference (*)

& operator memory address fetch karta hai; * operator us address par jaakar bits ko read/write karta hai.

Key Takeaway: *ptr reads or writes the pointed memory cell.

MICRO CONCEPT 3Canonical Object

Dynamic Heap Management

Stack memory fixed size hoti hai. Dynamic memory malloc() se Heap par allocate hoti hai aur free() se return hoti hai.

Key Takeaway: Always pair every malloc() with free() and set pointer to NULL.

Layer 3 & 4: Formal Specification & Mechanism

Hardware State Machine Architecture

In Modern 64-bit Virtual Memory Architecture (x86_64 and ARM64): - A pointer occupies precisely 8 bytes (64 bits) regardless of the underlying data type pointed to (sizeof(char*) == sizeof(double*) == 8 bytes). - The address-of operator '&' extracts the lvalue's virtual memory address. - The dereference operator '*' accesses the memory cell referenced by the address, interpreting the raw bit sequence according to the pointer's base type. - Pointer Arithmetic: Incrementing a pointer 'ptr + 1' advances the address by (1 * sizeof(BaseType)) bytes, preserving spatial alignment.

Step 1: Allocation on Stack Frame Jab function execute hota hai, stack frame par variable 'x' (4 bytes for int) ke liye space reserve hoti hai at address 0x7ffd50. Step 2: Pointer Assignment 'int *ptr = &x;' execute hone par ptr ke 8 bytes me value 0x7ffd50 store ho jaati hai. Step 3: Dereferencing and Modification Statement '*ptr = 25;' CPU ko instruct karta hai: 'Go to address 0x7ffd50 in L1 Data Cache / RAM, write 32-bit integer 25 into that 4-byte cell.' Step 4: Memory Deallocation Stack variables automatically pop ho jaate hain jab function return karta hai. Par heap memory (malloc) tab tak exist karti hai jab tak explicitly free() call na kiya jaye.

Layer 7: Interactive Laboratory

Interactive Simulator

COA • SIMULATIONC Pointers, Memory Addresses & Dereferencing Simulator

Launch Fullscreen Lab

COA • CPU ARCHITECTUREOperand Fetch & Memory Dereference

Addressing Modes & Effective Address (EA) Visualizer

1. Instruction Opcode

LOAD R1, 8(R2)

Mode: INDEXED Addressing Mode

Base register plus index/offset value

2. Address Resolution Unit

DERIVATION FORMULA:

EA = [R2] + Displacement/Offset = 0x1004 + 0x0008 = 0x100C

Resolved EA: 0x100C

Memory Bus Accesses: 1 cycle(s)

3. Final Operand Fetched

0x7777 (MEM[0x100C])

Ideal for array and struct indexing (Array base address + index * element size).

CPU Internal Register FileWord-size: 16-bit

R1	0x0000	General Purpose
R2	0x1004	General Purpose
PC	0x0200	Program Counter
XR	0x0008	Index Register

RAM Physical Address SpaceWord Addressable

520	0x9999	Memory Word
4096	0x0042	Memory Word
4100	0x2000	Memory Word
4108	0x7777	Memory Word
8192	0x5555	Memory Word

Layer 5: Step-by-Step Worked Numerical Example

End-to-End Execution Trace

Problem: Swapping two 32-bit integers using pass-by-reference pointers without return values. Step 1: Declare function void swap(int *a, int *b). Step 2: Dereference *a and store temporarily in temp: int temp = *a; Step 3: Overwrite value at address a with value at address b: *a = *b; Step 4: Overwrite value at address b with temp: *b = temp; Step 5: Verify in main(): original variables swapped directly in caller's stack frame.

Layer 6: Active Runtime CodeLab

Step-by-Step Code Execution (C)

AURXON Sandbox

AURXON Digital Engine

Font

main.cGlacier Light

Ln 1 • GCC 13

#include <stdio.h>
#include <stdlib.h>
 
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
 
int main(void) {
    int x = 42, y = 99;
    printf("Before Swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After Swap:  x = %d, y = %d\n", x, y);
    
    // Dynamic Allocation Demo
    int *arr = (int*)malloc(3 * sizeof(int));
    if (arr == NULL) return 1;
    arr[0] = 100; arr[1] = 200; arr[2] = 300;
    printf("Heap Array Elements: %d, %d, %d\n", *(arr), *(arr + 1), *(arr + 2));
    free(arr);
    arr = NULL; // Prevent dangling pointer
    return 0;
}

593 chars • 25 lines • Ln 1UTF-8 • 4 Spaces

Interactive Terminal Shell

Sandbox Terminal Ready

Click Run Code or press Ctrl+Enter to compile and execute.

Layer 8: Practice & Knowledge Verification

Active Assessment Quiz

No Practice Questions Configured

Questions for this topic are currently undergoing faculty review.

Academic Evaluation Preparation

Viva Examination & University Scoring Strategy

Standard Viva Examination Questions

How to Write High-Scoring University Exam Answers

Formal 10-Mark Academic Answer: 1. Definition: A pointer is a derived data type in C that stores the virtual memory address of another variable or dynamically allocated heap block. 2. Syntax: DataType *PointerName; 3. Key Operators: & (Reference/Address) and * (Indirection/Dereference). 4. Pointer Arithmetic Rules: ptr + n = Address + (n * sizeof(DataType)). Subtraction of two pointers yielding element distance. 5. Dynamic Memory Functions: malloc(size), calloc(n, size), realloc(ptr, new_size), free(ptr). 6. Memory Leak vs Dangling Pointer: Detailed distinction with diagram.