6. Arrays & Strings

Arrays are contiguous memory blocks. Strings are char arrays terminated by '\0'.

String functions (stdlib)

• strlen, strcpy, strncpy, strcmp, strcat, strtok

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

int main(void){
    char s[100] = "Hello";
    strcat(s, ", world");
    printf("%s\n", s);
    printf("len=%zu\n", strlen(s));
    return 0;
}

7. Structs, Unions & Enums

Structures group data; unions share memory among members. Enums provide named integer constants.

#include <stdio.h>

struct Point { int x, y; };

int main(void){
    struct Point p = { .x = 3, .y = 4 };
    printf("(%d,%d)\n", p.x, p.y);
    return 0;
}

8. File Input/Output

Use FILE *, fopen, fclose, fscanf, fprintf, fread, fwrite.

#include <stdio.h>

int main(void){
    FILE *f = fopen("data.txt","w");
    if(!f){perror("fopen"); return 1;}
    fprintf(f, "Hello file\n");
    fclose(f);
    return 0;
}

9. Advanced Topics & Good Practices

• Undefined behavior (UB) — know examples and how to avoid: using uninitialized variables, out-of-bounds access, double free, signed integer overflow.
• Memory safety: always initialize, check bounds, free memory once.
• Modular programming: header files, include guards (#ifndef #define #endif).
• Makefiles and build automation.
• Concurrency basics: threads via POSIX (pthread), race conditions, mutexes (theory level).

Preprocessor and macros

#define MAX(a,b) ((a) > (b) ? (a) : (b))

/* Use macros with care — avoid side-effects */

Header Guards

/* mylib.h */
#ifndef MYLIB_H
#define MYLIB_H

void myfunc(void);

#endif /* MYLIB_H */

10. Debugging & Testing

• Use gdb to step through code. Key commands: break, run, next, step, print.
• Use valgrind to detect memory leaks: valgrind --leak-check=full ./a.out.
• Unit testing frameworks exist (CMocka, Check) — academic knowledge sufficient for exams.

11. Important Sample Programs (Theory & Practical)

Sorting (Bubble sort)

#include <stdio.h>

void bubble(int a[], int n){
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1-i;j++){
            if(a[j] > a[j+1]){
                int t=a[j]; a[j]=a[j+1]; a[j+1]=t;
            }
        }
    }
}

int main(void){
    int a[] = {5,1,4,2,8};
    int n = sizeof a / sizeof a[0];
    bubble(a,n);
    for(int i=0;i<n;i++) printf("%d ", a[i]);
    printf("\n");
    return 0;
}

Linked List (Singly)

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

struct Node { int data; struct Node *next; };

void push(struct Node** head, int val){
    struct Node* n = malloc(sizeof *n);
    n->data = val; n->next = *head; *head = n;
}

void printList(struct Node* head){
    while(head){ printf("%d -> ", head->data); head = head->next; }
    printf("NULL\n");
}

int main(void){
    struct Node* head = NULL;
    push(&head, 3); push(&head, 2); push(&head, 1);
    printList(head);
    /* free nodes omitted for brevity */
    return 0;
}

12. Exercises & Practice Problems

Solve and test these by hand and in code. They cover typical exam topics.

1. Write a program to reverse a string in place.
2. Implement binary search on a sorted array.
3. Implement stack using linked list.
4. Detect and remove loop in a linked list (Floyd's cycle detection).
5. Implement matrix multiplication (NxN) and analyze time complexity.
6. Write a program that reads a text file and counts word frequency.
7. Use fork() and exec() to create a child process (Unix systems) — describe semantics.

13. Quick Exam Cheatsheet

• Remember sizeof returns size in bytes: sizeof(int).
• String literal type: array of char terminated by '\0'.
• const qualifier — read-only.
• Pointer arithmetic scales by the pointed type size.
• Functions receive copies of arguments (pass-by-value). To modify caller data, pass pointer to it.