C forces you to manage memory manually, track every pointer, and understand exactly how data is laid out in RAM. That's why it's still the go-to language for systems programming, embedded devices, and security research. The examples below walk through core concepts with safe, defensive practices — the kind of code you should write in a learning environment or a controlled lab.
Your First C Program: Hello, World!
The classic starting point is a program that prints a string. It demonstrates the #include directive, the main() function, and the printf() library call.
#include <stdio.h>
int main(void) {
printf("Hello, World!n");
return 0;
}Compile with gcc -Wall -Wextra -o hello hello.c and run ./hello. The flags -Wall -Wextra enable most compiler warnings — a habit that catches many beginner mistakes early.
Working with Variables and Data Types
C provides basic types: int, float, double, char, and _Bool. Always initialize variables before use; uninitialized variables contain garbage values that can lead to unpredictable behavior.
#include <stdio.h>
int main(void) {
int age = 25;
float pi = 3.14159f;
char grade = 'A';
printf("Age: %dn", age);
printf("Pi: %.2fn", pi);
printf("Grade: %cn", grade);
return 0;
}Notice the %d, %f, %c format specifiers. Using the wrong specifier (e.g., %d for a float) causes undefined behavior — a common source of bugs.
Control Flow: Loops and Conditionals
Understanding if, for, while, and switch is essential. The example below counts down from 5 and prints a message when the count reaches zero.
#include <stdio.h>
int main(void) {
int count = 5;
while (count > 0) {
printf("%dn", count);
count--;
}
printf("Blast off!n");
return 0;
}Always ensure loop conditions eventually become false; otherwise you create an infinite loop that may consume CPU resources indefinitely.
Functions and Modular Code
Breaking code into functions improves readability and reusability. Each function should do one thing. Here is a function that computes the factorial of a number recursively.
#include <stdio.h>
long factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
int main(void) {
int num = 5;
printf("Factorial of %d is %ldn", num, factorial(num));
return 0;
}Recursion is elegant but can cause stack overflow if the depth is too high. For production code, iterative solutions are often safer.
Pointers and Memory Management – Handle with Care
Pointers store memory addresses. They are powerful but dangerous. A pointer that points to freed or uninitialized memory can crash your program or create security vulnerabilities. Always check pointer validity before dereferencing.
#include <stdio.h>
int main(void) {
int value = 42;
int *ptr = &value;
printf("Value: %dn", *ptr);
printf("Address: %pn", (void*)ptr);
return 0;
}Understanding addresses at the hardware level is a core skill for any developer who works with system internals. For a deeper look at how addresses work across IP, MAC, and memory, see our post on Understanding Addresses in Programming and Cybersecurity.
Arrays and Strings – Avoiding Buffer Overflows
Arrays in C are zero-indexed and have no built-in bounds checking. A common mistake is writing past the end of an array, which corrupts adjacent memory. Always use constants for array sizes and validate input lengths.
#include <stdio.h>
#include <string.h>
#define MAX_NAME 50
int main(void) {
char name[MAX_NAME];
printf("Enter your name: ");
if (fgets(name, sizeof(name), stdin) != NULL) {
// Remove trailing newline if present
size_t len = strlen(name);
if (len > 0 && name[len-1] == 'n') {
name[len-1] = '';
}
printf("Hello, %s!n", name);
}
return 0;
}Notice the use of fgets() instead of gets() — gets() is dangerous and has been removed from the C11 standard. fgets() limits the number of characters read, preventing buffer overflow.
Structures and File I/O
Structures group related data. Combine them with file operations to store and retrieve records. The following example writes a struct to a binary file and reads it back.
#include <stdio.h>
#include <string.h>
typedef struct {
int id;
char name[30];
float score;
} Student;
int main(void) {
Student s1 = {1, "Alice", 95.5};
FILE *fp = fopen("student.dat", "wb");
if (fp == NULL) {
perror("Failed to open file");
return 1;
}
fwrite(&s1, sizeof(Student), 1, fp);
fclose(fp);
// Read back
Student s2;
fp = fopen("student.dat", "rb");
if (fp == NULL) {
perror("Failed to open file");
return 1;
}
fread(&s2, sizeof(Student), 1, fp);
fclose(fp);
printf("ID: %d, Name: %s, Score: %.1fn", s2.id, s2.name, s2.score);
return 0;
}Always check the return value of fopen() — a null pointer indicates the file could not be opened. Use perror() to print a meaningful error message.
Putting It All Together: A Simple Safe Calculator
As a final example, here is a calculator that reads two numbers and an operator, using safe input functions and validating the divisor for division.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char input[100];
double a, b, result;
char op;
printf("Enter expression (e.g., 3.5 + 2.1): ");
if (fgets(input, sizeof(input), stdin) == NULL) {
return 1;
}
if (sscanf(input, "%lf %c %lf", &a, &op, &b) != 3) {
printf("Invalid input.n");
return 1;
}
switch (op) {
case '+': result = a + b; break;
case '-': result = a - b; break;
case '*': result = a * b; break;
case '/':
if (b == 0.0) {
printf("Division by zero is not allowed.n");
return 1;
}
result = a / b;
break;
default:
printf("Unknown operator '%c'.n", op);
return 1;
}
printf("%.2f %c %.2f = %.2fn", a, op, b, result);
return 0;
}This program checks that sscanf() parsed exactly three items, prevents division by zero, and rejects unknown operators. Every input path is validated — a minimal but effective defense against malformed data.
Try modifying the calculator to handle more operators like modulus or exponentiation. Each small change will teach you something about how C handles data — and where things can go wrong. That's the real value of learning C: you see the cracks before they become exploits.
