C

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

int main() { // Basic types int age = 30; float price = 9.99f; double pi = 3.14159265; char grade = 'A'; char name[] = "Sufi"; // string = char array

// printf format specifiers printf("Name: %s, Age: %d, Price: %.2f\n", name, age, price);

// Arrays int nums[5] = {10, 20, 30, 40, 50}; int size = sizeof(nums) / sizeof(nums[0]); // 5

// Loops for (int i = 0; i < size; i++) { printf("%d ", nums[i]); }

return 0; // 0 = success } ```

int x = 42;
int *ptr = &x;         // pointer to x

printf("%d\n", x); // 42 value printf("%p\n", ptr); // address of x printf("%d\n", *ptr); // 42 dereference

*ptr = 100; // modify x through pointer printf("%d\n", x); // 100

// Pointer arithmetic int arr[] = {1, 2, 3, 4, 5}; int *p = arr; // points to arr[0] printf("%d\n", *(p + 2)); // arr[2] = 3

// Function pointers int add(int a, int b) { return a + b; } int (*fn)(int, int) = add; printf("%d\n", fn(3, 4)); // 7

// NULL pointer check ALWAYS int *safe = NULL; if (safe != NULL) { printf("%d\n", *safe); } ```

#include <stdlib.h>

// Stack memory automatic, fast, limited size int stack_arr[100]; // deallocated when function returns

// Heap memory manual, flexible, large int *heap_arr = malloc(100 * sizeof(int)); if (heap_arr == NULL) { fprintf(stderr, "Memory allocation failed\n"); exit(1); }

// Use the memory for (int i = 0; i < 100; i++) { heap_arr[i] = i * 2; }

// MUST free heap memory to prevent leaks free(heap_arr); heap_arr = NULL; // avoid dangling pointer

// calloc allocate and zero-initialize int *zeroed = calloc(50, sizeof(int));

// realloc resize allocation int *resized = realloc(heap_arr, 200 * sizeof(int)); if (resized == NULL) { free(heap_arr); exit(1); } heap_arr = resized; ```

#include <stdio.h>
#include <string.h>

typedef struct { char name[50]; int age; float salary; } Employee;

typedef struct Node { int data; struct Node *next; // self-referential } Node;

// Struct initialization Employee emp = { .name = "Sufi", .age = 30, .salary = 95000.0f }; printf("%s earns $%.2f\n", emp.name, emp.salary);

// Pointer to struct Employee *ptr = &emp; printf("%s\n", ptr->name); // arrow operator for pointer printf("%s\n", (*ptr).name); // equivalent

// Linked list node creation Node *new_node(int val) { Node *n = malloc(sizeof(Node)); n->data = val; n->next = NULL; return n; } ```

#include <stdio.h>

// Writing a file FILE *f = fopen("output.txt", "w"); if (f == NULL) { perror("fopen"); return 1; } fprintf(f, "Line 1\nLine 2\n"); fclose(f);

// Reading a file FILE *r = fopen("output.txt", "r"); char line[256]; while (fgets(line, sizeof(line), r) != NULL) { printf("%s", line); } fclose(r);

// Binary I/O Employee emp = { "Sufi", 30, 95000.0f }; FILE *bin = fopen("data.bin", "wb"); fwrite(&emp, sizeof(Employee), 1, bin); fclose(bin);

// Read binary Employee loaded; FILE *bin2 = fopen("data.bin", "rb"); fread(&loaded, sizeof(Employee), 1, bin2); fclose(bin2); printf("Loaded: %s\n", loaded.name); ```

Where C is Still Essential
• Operating system kernels (Linux, macOS, Windows are mostly C)
• Embedded systems and IoT firmware
• Performance-critical libraries (OpenSSL, SQLite, NumPy core)
• Device drivers and real-time systems
• Language runtime implementations (CPython, Ruby MRI)

Common Pitfalls
• Buffer overflow: writing past array bounds (major security vulnerability)
• Use after free: accessing memory after free()
• Dangling pointers: pointer to freed/stack memory
• Integer overflow: wrapping around at max value
• Uninitialized variables: undefined behavior

Compilation & Tooling ``bash gcc -Wall -Wextra -O2 -g main.c -o program # compile with warnings valgrind ./program # detect memory leaks gdb ./program # debugger clang-tidy main.c # static analysis ``