Applications of C Programming Language: 8 Real-World Uses (With Code Examples)

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();   // System call: ask OS to clone this process

    if (pid == 0) {
        // Child process
        printf("Child PID: %d\n", getpid());
        execlp("ls", "ls", "-l", NULL);  // Replace with new program
    } else if (pid > 0) {
        // Parent process
        printf("Parent waiting for child %d\n", pid);
        wait(NULL);             // Block until child finishes
        printf("Child done.\n");
    }
    return 0;
}

#include "stm32f4xx_hal.h"

int main(void) {
    HAL_Init();
    SystemClock_Config();

    // Enable clock for GPIO port A
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef gpio = {0};
    gpio.Pin  = GPIO_PIN_5;
    gpio.Mode = GPIO_MODE_OUTPUT_PP;
    gpio.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &gpio);

    while (1) {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);  // Toggle LED
        HAL_Delay(500);                         // Wait 500ms
    }
}

#include <stdio.h>
#include <ctype.h>

// Token types for a tiny expression lexer
typedef enum { TOK_NUM, TOK_PLUS, TOK_STAR, TOK_EOF } TokenType;

typedef struct {
    TokenType type;
    int       value;   // for TOK_NUM
} Token;

Token next_token(const char **src) {
    while (isspace(**src)) (*src)++;   // skip whitespace
    if (isdigit(**src)) {
        Token t = { TOK_NUM, 0 };
        while (isdigit(**src)) t.value = t.value * 10 + (*(*src)++ - '0');
        return t;
    }
    if (**src == '+') { (*src)++; return (Token){ TOK_PLUS }; }
    if (**src == '*') { (*src)++; return (Token){ TOK_STAR }; }
    return (Token){ TOK_EOF };
}

#include <SDL2/SDL.h>

#define TARGET_FPS    60
#define FRAME_MS      (1000 / TARGET_FPS)

int main() {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window   *win = SDL_CreateWindow("Game", 100, 100, 800, 600, 0);
    SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);

    int running = 1;
    while (running) {
        Uint32 frame_start = SDL_GetTicks();

        SDL_Event e;
        while (SDL_PollEvent(&e))
            if (e.type == SDL_QUIT) running = 0;

        // Update game state here

        SDL_SetRenderDrawColor(ren, 30, 30, 46, 255);
        SDL_RenderClear(ren);
        // Draw game objects here
        SDL_RenderPresent(ren);

        Uint32 elapsed = SDL_GetTicks() - frame_start;
        if (elapsed < FRAME_MS) SDL_Delay(FRAME_MS - elapsed);  // cap to 60fps
    }
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
    return 0;
}

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

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in addr = {
        .sin_family      = AF_INET,
        .sin_port        = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 5);
    printf("Listening on port 8080...\n");

    while (1) {
        int client = accept(server_fd, NULL, NULL);
        char buf[256];
        ssize_t n = read(client, buf, sizeof(buf));
        write(client, buf, n);   // Echo back
        close(client);
    }
}

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

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

Node* insert_front(Node *head, int val) {
    Node *node = malloc(sizeof(Node));
    node->data = val;
    node->next = head;
    return node;
}

void print_list(Node *head) {
    for (Node *n = head; n; n = n->next)
        printf("%d → ", n->data);
    printf("NULL\n");
}

int main() {
    Node *list = NULL;
    list = insert_front(list, 30);
    list = insert_front(list, 20);
    list = insert_front(list, 10);
    print_list(list);   // 10 → 20 → 30 → NULL
    return 0;
}

#include <stdio.h>
#include <math.h>
#include <fftw3.h>

#define N 8

int main() {
    // Allocate input/output arrays via FFTW
    fftw_complex *in  = fftw_alloc_complex(N);
    fftw_complex *out = fftw_alloc_complex(N);
    fftw_plan     p   = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);

    // Fill input: a simple cosine wave
    for (int i = 0; i < N; i++) {
        in[i][0] = cos(2.0 * M_PI * i / N);  // real
        in[i][1] = 0.0;                        // imaginary
    }

    fftw_execute(p);

    for (int i = 0; i < N; i++)
        printf("bin[%d] magnitude = %.2f\n", i,
               sqrt(out[i][0]*out[i][0] + out[i][1]*out[i][1]));

    fftw_destroy_plan(p);
    fftw_free(in); fftw_free(out);
    return 0;
}