Dynamic Memory Allocation

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    // STACK: automatic, fixed size
6    int a = 10;           // On stack
7    int arr[5] = {1,2,3,4,5};  // On stack
8    
9    // HEAP: manual, dynamic size
10    int *p = malloc(sizeof(int));  // On heap
11    *p = 20;
12    
13    printf("Stack: a = %d\n", a);
14    printf("Heap:  *p = %d\n", *p);
15    
16    free(p);  // Must free heap memory!
17    return 0;
18}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    // Hardcoded 20 bytes (5 integers × 4 bytes)
6    // Problem: int size varies by system!
7    int *ptr = (int *)malloc(20);
8    
9    for (int i = 0; i < 5; i++)
10        ptr[i] = i + 1;
11        
12    for (int i = 0; i < 5; i++)
13        printf("%d ", ptr[i]);
14        
15    free(ptr);
16    return 0;
17}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    // sizeof(int) = 4 bytes on most systems
6    int *ptr = (int *)malloc(sizeof(int) * 5);
7    
8    for (int i = 0; i < 5; i++)
9        ptr[i] = i + 1;
10        
11    for (int i = 0; i < 5; i++)
12        printf("%d ", ptr[i]);
13        
14    free(ptr);
15    return 0;
16}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int *ptr = (int *)malloc(sizeof(int) * 5);
6    
7    // Always check for failure!
8    if (ptr == NULL) {
9        printf("Allocation Failed!\n");
10        return 1;
11    }
12    
13    for (int i = 0; i < 5; i++)
14        ptr[i] = i + 1;
15        
16    for (int i = 0; i < 5; i++)
17        printf("%d ", ptr[i]);
18        
19    free(ptr);
20    return 0;
21}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int *ptr = (int *)calloc(5, sizeof(int));
6    
7    if (ptr == NULL) {
8        printf("Allocation Failed!\n");
9        return 1;
10    }
11    
12    // No need to initialize - already 0!
13    for (int i = 0; i < 5; i++)
14        printf("%d ", ptr[i]);
15        
16    free(ptr);
17    return 0;
18}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    // Start with 5 integers
6    int *ptr = (int *)malloc(5 * sizeof(int));
7    
8    // Resize to hold 10 integers
9    ptr = (int *)realloc(ptr, 10 * sizeof(int));
10    
11    if (ptr == NULL) {
12        printf("Reallocation Failed!\n");
13        return 1;
14    }
15    
16    printf("Successfully resized to 10 integers\n");
17    free(ptr);
18    return 0;
19}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int *ptr = (int *)malloc(5 * sizeof(int));
6    
7    // Use temp pointer for safety!
8    int *temp = (int *)realloc(ptr, 10 * sizeof(int));
9    
10    if (temp == NULL) {
11        printf("Reallocation Failed!\n");
12        // ptr is still valid, can still use or free it
13        free(ptr);
14        return 1;
15    }
16    
17    // Only update ptr after success
18    ptr = temp;
19    
20    printf("Success!\n");
21    free(ptr);
22    return 0;
23}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    // Start with 5 integers
6    int *ptr = (int *)malloc(5 * sizeof(int));
7    for (int i = 0; i < 5; i++)
8        ptr[i] = (i + 1) * 10;
9    
10    // Grow to 8 integers
11    ptr = (int *)realloc(ptr, 8 * sizeof(int));
12    
13    // Shrink back to 5 integers
14    ptr = (int *)realloc(ptr, 5 * sizeof(int));
15    
16    for (int i = 0; i < 5; i++)
17        printf("%d ", ptr[i]);
18    
19    free(ptr);
20    return 0;
21}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int *ptr = (int *)calloc(5, sizeof(int));
6    
7    // Do some operations...
8    for (int i = 0; i < 5; i++)
9        printf("%d ", ptr[i]);
10    
11    // Free memory when done
12    free(ptr);
13    
14    // Good practice: set to NULL
15    ptr = NULL;
16    
17    return 0;
18}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int *ptr = calloc(4, sizeof(int));
6    
7    // Write using array notation
8    ptr[0] = 10;
9    ptr[1] = 20;
10    ptr[2] = 30;
11    
12    // Write using dereference (same as ptr[0])
13    *ptr = 5;  // Changes ptr[0] to 5
14    
15    // Read values
16    printf("%d %d %d %d\n", ptr[0], ptr[1], ptr[2], ptr[3]);
17    
18    free(ptr);
19    return 0;
20}

1#include <stdlib.h>
2
3void leak_example() {
4    int *p = malloc(100 * sizeof(int));
5    // Oops! Function ends without free()
6    // Memory is lost forever!
7}
8
9int main() {
10    for (int i = 0; i < 1000; i++) {
11        leak_example();  // 400 bytes leaked each time!
12    }
13    // 400 KB leaked in total!
14    return 0;
15}

1#include <stdlib.h>
2
3void no_leak() {
4    int *p = malloc(100 * sizeof(int));
5    // ... use the memory ...
6    free(p);  // Always free before returning!
7}
8
9int main() {
10    for (int i = 0; i < 1000; i++) {
11        no_leak();  // Memory freed each time
12    }
13    // No leak!
14    return 0;
15}

1#include <stdio.h>
2#include <stdlib.h>
3
4int main() {
5    int n;
6    printf("How many numbers? ");
7    scanf("%d", &n);
8    
9    // Allocate array based on user input
10    int *nums = malloc(n * sizeof(int));
11    if (nums == NULL) {
12        printf("Allocation failed!\n");
13        return 1;
14    }
15    
16    // Read numbers
17    printf("Enter %d numbers:\n", n);
18    for (int i = 0; i < n; i++) {
19        scanf("%d", &nums[i]);
20    }
21    
22    // Calculate sum
23    int sum = 0;
24    for (int i = 0; i < n; i++) {
25        sum += nums[i];
26    }
27    
28    printf("Sum: %d\n", sum);
29    
30    free(nums);
31    return 0;
32}