C

Estimated reading: 14 minutes 58 views

C Tutorial from Basics to Advanced

A complete C guide with clear concepts and fresh examples. Each topic has a concept and an explanation.

1. What is C

Concept C is a compiled and general purpose language. It gives you control over memory and hardware.

Why it matters

Runs fast
Used for systems, embedded, games, and performance critical code
The base for many other languages

Hello program

#include <stdio.h>

int main(void) {
    printf("Hello C\n");
    return 0;
}

Explanation #include brings in library declarations. main is the entry point. printf writes text to standard output. return 0 signals success.

2. Compile and Run

Concept You compile C code to an executable. The compiler checks and translates your code.

Example using GCC

gcc hello.c -o hello
./hello

Explanation gcc compiles the file and outputs an executable named hello. Run it from the terminal.

3. Program Structure

Concept A C program is a set of functions and global declarations. The execution starts in main.

Template

#include <stdio.h>

void greet(const char *name) {
    printf("Hi %s\n", name);
}

int main(void) {
    greet("Aarav");
    return 0;
}

Explanation Functions can be defined before or after main. If after, declare a prototype first.

4. Data Types and Variables

Concept C has basic types with fixed sizes depending on platform. Choose the right type for your data.

Common types

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    char c = 'Z';
    int i = 42;
    long long big = 9000000000LL;
    float f = 3.14f;
    double d = 2.718281828;
    printf("char %c int %d float %.2f double %.3f\n", c, i, f, d);
    printf("INT_MAX %d DBL_MAX %e\n", INT_MAX, DBL_MAX);
    return 0;
}

Explanation Use limits.h and float.h to see ranges. Add suffixes like LL and f to control literal types.

5. Constants and Literals

Concept Use constants to avoid magic numbers. Helps readability and safety.

#include <stdio.h>

#define MAX_USERS 1000
const double PI = 3.141592653589793;

int main(void) {
    const int window = 5;
    printf("Users limit %d PI %.5f window %d\n", MAX_USERS, PI, window);
    return 0;
}

Explanation #define creates a macro constant. const creates a typed constant that the compiler can check.

6. Operators and Expressions

Concept Operators work on values. Learn precedence and types.

#include <stdio.h>

int main(void) {
    int a = 9, b = 4;
    printf("%d %d %d %d %d %d\n", a + b, a - b, a * b, a / b, a % b, a == b);
    double x = 5.0, y = 2.0;
    printf("%.1f\n", x / y);
    int ok = (a > b) && (b > 0);
    printf("ok %d\n", ok);
    return 0;
}

Explanation / between ints does integer division. Use double for real division. && || ! are logical operators.

7. Control Flow

Concept Use branches and loops to control execution.

if else

#include <stdio.h>

int main(void) {
    int temp = 33;
    if (temp >= 40) {
        printf("Too hot\n");
    } else if (temp >= 30) {
        printf("Warm\n");
    } else {
        printf("Cool\n");
    }
    return 0;
}

while and for

#include <stdio.h>

int main(void) {
    int count = 3;
    while (count > 0) {
        printf("%d\n", count);
        count--;
    }
    for (int i = 0; i < 5; i++) {
        if (i == 2) continue;
        if (i == 4) break;
        printf("i %d\n", i);
    }
    return 0;
}

switch

#include <stdio.h>

int main(void) {
    char grade = 'B';
    switch (grade) {
        case 'A': printf("Excellent\n"); break;
        case 'B': printf("Good\n"); break;
        case 'C': printf("Average\n"); break;
        default:  printf("Unknown\n"); break;
    }
    return 0;
}

Explanation break exits loops and switch. continue skips to next iteration.

8. Functions

Concept Functions group logic and return values. Arguments pass data in.

#include <stdio.h>

int square(int n) {
    return n * n;
}

void print_sum(int a, int b) {
    printf("sum %d\n", a + b);
}

int main(void) {
    printf("%d\n", square(7));
    print_sum(3, 5);
    return 0;
}

Explanation Declare return type and parameter types. Use a prototype when needed to inform the compiler.

9. Arrays

Concept Arrays store elements of the same type in contiguous memory.

#include <stdio.h>

int main(void) {
    int scores[5] = {82, 91, 76, 88, 95};
    int total = 0;
    for (int i = 0; i < 5; i++) total += scores[i];
    double avg = total / 5.0;
    printf("avg %.2f\n", avg);
    return 0;
}

Explanation Index starts at zero. C does not check bounds. Be careful with indices.

10. Strings

Concept C strings are arrays of char terminated by a zero byte.

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

int main(void) {
    char name[16] = "Meera";
    printf("len %zu\n", strlen(name));
    strcat(name, " S");   // ensure enough space
    printf("%s\n", name);
    strcpy(name, "Asha"); // overwrite with a shorter string
    printf("%s\n", name);
    return 0;
}

Explanation Use strlen, strcpy, strcat with care. Prefer bounded forms like strncpy and strncat to avoid overflow.

11. Pointers

Concept A pointer holds an address. Use pointers for arrays, dynamic memory, and function args by reference.

#include <stdio.h>

void increment(int *p) {
    if (p) *p = *p + 1;
}

int main(void) {
    int x = 10;
    int *px = &x;
    printf("x %d via pointer %d\n", x, *px);
    increment(&x);
    printf("x after %d\n", x);
    return 0;
}

Explanation & takes address. * dereferences a pointer. Always check for null when appropriate.

12. Pointer Arithmetic and Arrays

Concept Array name decays to a pointer to first element. Pointer arithmetic moves by element size.

#include <stdio.h>

int main(void) {
    int a[4] = {2, 4, 6, 8};
    int *p = a;       // same as &a[0]
    printf("%d %d\n", *p, *(p + 2));  // 2 and 6
    for (int i = 0; i < 4; i++) {
        printf("%d ", *(p + i));
    }
    printf("\n");
    return 0;
}

Explanation Do not move a pointer outside the array bounds. That is undefined behavior.

13. Dynamic Memory

Concept Allocate memory at runtime with malloc and friends. Free it when done.

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

int main(void) {
    size_t n = 5;
    int *arr = malloc(n * sizeof *arr);
    if (!arr) {
        perror("malloc failed");
        return 1;
    }
    for (size_t i = 0; i < n; i++) arr[i] = (int)(i * i);
    for (size_t i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Explanation Always check allocation. Use sizeof *ptr pattern to avoid type mistakes. Free every allocation once.

14. Structures

Concept Structures group related fields into one type.

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

struct Book {
    char title[32];
    int pages;
    double price;
};

void print_book(const struct Book *b) {
    printf("%s pages %d price %.2f\n", b->title, b->pages, b->price);
}

int main(void) {
    struct Book b;
    strcpy(b.title, "C in Practice");
    b.pages = 280;
    b.price = 499.0;
    print_book(&b);
    return 0;
}

Explanation Use . for direct access and -> for pointer access.

15. typedef and enums and unions

Concept typedef creates type aliases. enum creates integer constants. union shares memory among fields.

#include <stdio.h>

typedef unsigned long uid_t;

enum Status { OK = 0, FAIL = 1, UNKNOWN = 2 };

union Number {
    int i;
    float f;
};

int main(void) {
    uid_t uid = 12345UL;
    enum Status s = OK;
    union Number n;
    n.i = 10;
    printf("uid %lu status %d union as int %d\n", uid, s, n.i);
    n.f = 3.5f;
    printf("union as float %.1f\n", n.f);
    return 0;
}
``]
Explanation  
An enum is stored as an int in practice. A union overlays memory so only the last written field is valid.

## 16. Storage classes and scope
Concept  
Storage class defines lifetime and linkage.

```c
#include <stdio.h>

int counter = 0;        // external linkage global lifetime

static int hidden = 7;  // internal linkage in this file

void hit(void) {
    static int local_count = 0; // retains value between calls
    local_count++;
    counter++;
    printf("local %d global %d\n", local_count, counter);
}

int main(void) {
    hit(); hit(); hit();
    return 0;
}

Explanation static on a function or global gives internal linkage. static inside a function gives persistent storage.

17. Const and volatile

Concept const prevents modification through that name. volatile tells the compiler that a value may change outside program control.

#include <stdio.h>

int main(void) {
    const int a = 10;
    volatile int flag = 0; // might be set by hardware or another thread
    printf("a %d flag %d\n", a, flag);
    return 0;
}

Explanation Use const for read only data. Use volatile for memory mapped registers or signal flags.

18. Preprocessor and macros

Concept The preprocessor runs before compilation. It handles includes, macros, and conditional code.

#include <stdio.h>

#define SQUARE(x) ((x) * (x))
#define LOG(fmt, ...) printf("[LOG] " fmt "\n", __VA_ARGS__)

int main(void) {
    int n = 6;
    printf("sq %d\n", SQUARE(n + 1));
    LOG("n is %d", n);
    return 0;
}

Explanation Use parentheses in macros to avoid precedence bugs. Prefer inline functions for type safety when possible.

19. Header files and multiple files

Concept Split declarations and definitions. Headers expose interfaces. Source files provide implementations.

file mathx.h

#ifndef MATHX_H
#define MATHX_H

int add(int a, int b);
int mul(int a, int b);

#endif

file mathx.c

#include "mathx.h"

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

file app.c

#include <stdio.h>
#include "mathx.h"

int main(void) {
    printf("%d %d\n", add(2, 3), mul(4, 5));
    return 0;
}

Build

gcc -c mathx.c
gcc -c app.c
gcc app.o mathx.o -o app

Explanation Include guards avoid double inclusion. Compile each source to an object then link.

20. Function pointers

Concept A function pointer holds the address of a function. Use for callbacks and strategies.

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int compute(int (*op)(int, int), int x, int y) {
    return op(x, y);
}

int main(void) {
    printf("%d\n", compute(add, 7, 2));
    printf("%d\n", compute(sub, 7, 2));
    return 0;
}

Explanation Type the pointer exactly. Use (*op)(...) to call through the pointer.

21. File I O

Concept Use standard file functions to read and write files.

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

int main(void) {
    FILE *f = fopen("notes.txt", "w");
    if (!f) { perror("open write"); return 1; }
    fprintf(f, "learn C daily\n");
    fclose(f);

    f = fopen("notes.txt", "r");
    if (!f) { perror("open read"); return 1; }
    char buf[64];
    while (fgets(buf, sizeof buf, f)) {
        printf("%s", buf);
    }
    fclose(f);
    return 0;
}

Explanation Always check return values. Use fgets for safe line reads. Close files.

22. Error handling and errno

Concept Most library functions signal errors with return values and set errno.

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

int main(void) {
    FILE *f = fopen("no_such_file.txt", "r");
    if (!f) {
        printf("error %d %s\n", errno, strerror(errno));
    }
    return 0;
}

Explanation errno is a thread local integer. Use strerror to get a message.

23. Bitwise operations

Concept Work with bits for flags and compact data.

#include <stdio.h>

#define F_READ  0x1
#define F_WRITE 0x2
#define F_EXEC  0x4

int main(void) {
    unsigned int perms = 0;
    perms |= F_READ | F_WRITE;
    if (perms & F_READ)  printf("R\n");
    if (perms & F_WRITE) printf("W\n");
    perms ^= F_WRITE;   // toggle write
    if ((perms & F_WRITE) == 0) printf("no W\n");
    unsigned int x = 0b10110000;
    printf("shift %u\n", x >> 4);
    return 0;
}

Explanation Use & for test, | for set, ^ for toggle, ~ for invert, shifts to move bits.

24. Common data structures

Concept Implement structures manually using pointers and dynamic memory.

Singly linked list

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

typedef struct Node {
    int value;
    struct Node *next;
} Node;

Node* push_front(Node *head, int v) {
    Node *n = malloc(sizeof *n);
    if (!n) return head;
    n->value = v;
    n->next = head;
    return n;
}

void print_list(const Node *h) {
    while (h) {
        printf("%d ", h->value);
        h = h->next;
    }
    printf("\n");
}

void free_list(Node *h) {
    while (h) {
        Node *tmp = h->next;
        free(h);
        h = tmp;
    }
}

int main(void) {
    Node *head = NULL;
    head = push_front(head, 3);
    head = push_front(head, 7);
    head = push_front(head, 1);
    print_list(head);
    free_list(head);
    return 0;
}

Explanation Always free nodes. Careful with pointer updates to avoid leaks.

25. Modular design and libraries

Concept Split code into reusable modules and build static or shared libraries.

Static library

gcc -c mathx.c
ar rcs libmathx.a mathx.o
gcc app.c -L. -lmathx -o app

Explanation Archive object files into a library. Link with -lname and -Lpath.

26. Build tools

Concept Automate compilation with Make or CMake.

Makefile example

CC = gcc
CFLAGS = -Wall -Wextra -O2

app: app.o mathx.o
    $(CC) $(CFLAGS) $^ -o $@

%.o: %.c
    $(CC) $(CFLAGS) -c $<

clean:
    rm -f *.o app

Explanation Targets describe outputs and dependencies. Make rebuilds only what changed.

27. Debugging with GDB

Concept Use a debugger to step through code and inspect state.

Build with debug info

gcc -g app.c -o app
gdb ./app

Inside gdb

break main
run
next
print variable
bt

Explanation -g adds symbols. Use breakpoints and stepping to find bugs.

28. Performance tips

Concept Write clear code then measure. Optimize hot paths and memory use.

Guidelines

Use appropriate data types
Avoid unnecessary copies
Use local variables for better cache
Minimize branching in tight loops
Profile with perf or gprof or time

Micro benchmark with time

time ./app

Explanation Real performance needs profiling on target workloads.

29. Undefined behavior safety

Concept Some actions have no defined result. The compiler may assume they never happen.

Examples to avoid

Out of bounds array access
Use of uninitialized variables
Integer overflow on signed types
Using freed memory
Data races without synchronization

Explanation Follow the rules. Turn on warnings. Use tools like AddressSanitizer and UBSan.

30. C standard highlights

Concept Know features from modern standards.

C99

Declarations in for loop
Inline functions
stdint.h fixed width types
Variable length arrays in some compilers

C11

_Static_assert
_Atomic for atomics
Thread library in threads.h optional support

C17

Maintenance fixes

Explanation Prefer stdint.h types like uint32_t for precise widths.

31. Concurrency with pthreads

Concept Threads run functions in parallel and share memory. Use mutexes to protect shared data.

#include <stdio.h>
#include <pthread.h>

static int counter = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void* worker(void* arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, worker, NULL);
    pthread_create(&t2, NULL, worker, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("counter %d\n", counter);
    return 0;
}

Explanation Always protect shared state. Use pthread_join to wait for threads.

32. Networking with sockets

Concept Sockets let programs talk over networks.

TCP client example

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main(void) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) { perror("socket"); return 1; }

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(80);
    inet_pton(AF_INET, "93.184.216.34", &addr.sin_addr); // example dot org

    if (connect(sock, (struct sockaddr*)&addr, sizeof addr) < 0) {
        perror("connect");
        close(sock);
        return 1;
    }

    const char *req = "GET / HTTP/1.1\r\nHost: example.org\r\nConnection: close\r\n\r\n";
    send(sock, req, strlen(req), 0);

    char buf[1024];
    ssize_t n;
    while ((n = recv(sock, buf, sizeof buf, 0)) > 0) {
        fwrite(buf, 1, (size_t)n, stdout);
    }
    close(sock);
    return 0;
}

Explanation Fill the address, connect, send a request, receive, and close.

33. Testing in C

Concept Write unit tests to verify functions. Use a small testing library or simple asserts.

Simple assert based test

#include <assert.h>

int add(int a, int b) { return a + b; }

int main(void) {
    assert(add(2, 3) == 5);
    assert(add(-1, 1) == 0);
    return 0;
}

Explanation Assertions stop the program if a condition fails. For larger projects consider libraries like Unity or CMocka.

34. Practical project example

Concept Combine parsing, data structures, and file I O.

Task Read numbers from a file and print median.

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

int cmp_int(const void *a, const void *b) {
    int x = *(const int*)a;
    int y = *(const int*)b;
    return (x > y) - (x < y);
}

int main(void) {
    FILE *f = fopen("numbers.txt", "r");
    if (!f) { perror("open"); return 1; }

    int cap = 16, n = 0;
    int *arr = malloc((size_t)cap * sizeof *arr);
    if (!arr) { perror("malloc"); fclose(f); return 1; }

    while (1) {
        int v;
        if (fscanf(f, "%d", &v) != 1) break;
        if (n == cap) {
            cap *= 2;
            int *tmp = realloc(arr, (size_t)cap * sizeof *arr);
            if (!tmp) { perror("realloc"); free(arr); fclose(f); return 1; }
            arr = tmp;
        }
        arr[n++] = v;
    }
    fclose(f);

    if (n == 0) { printf("no data\n"); free(arr); return 0; }

    qsort(arr, (size_t)n, sizeof *arr, cmp_int);

    double median = 0.0;
    if (n % 2 == 1) median = arr[n / 2];
    else median = (arr[n / 2 - 1] + arr[n / 2]) / 2.0;

    printf("median %.2f\n", median);
    free(arr);
    return 0;
}

Explanation Use dynamic arrays with growth pattern. Sort with qsort. Compute median based on count parity.

35. Safety and tooling checklist

Concept Use compiler checks and sanitizers to catch bugs early.

Checklist

Compile with warnings like -Wall -Wextra -Werror
Use AddressSanitizer and UndefinedBehaviorSanitizer during tests
Run static analysis with cppcheck or clang tidy
Add continuous integration to run tests

Explanation Early detection reduces debugging time and improves reliability.

36. Next steps

Concept Practice with small programs and grow steadily.

Ideas

A tiny CSV reader that computes stats
A simple stack and queue library
A small HTTP parser for headers only
A text search tool using strstr and regex via POSIX

Explanation Real practice cements pointers, memory, and modular design.

Raidles Blogs / Tutorials

Learn from Blogs and Tutorials:

C