C Programming Basics

#include - Including Header Files

The #include directive copies the contents of another file into your program:

// System/Standard headers - use angle brackets < >
#include <stdio.h>    // Standard Input/Output (printf, scanf)
#include <stdlib.h>   // Standard Library (malloc, free, exit)
#include <string.h>   // String functions (strlen, strcpy)
#include <math.h>     // Math functions (sqrt, pow, sin)
#include <stdbool.h>  // Boolean type (true, false) - C99
#include <limits.h>   // Data type limits (INT_MAX, etc.)

// Your own headers - use double quotes " "
#include "myheader.h"     // Looks in current directory first
#include "utils/helper.h" // Can include path

#define - Creating Macros

The #define directive creates macros (text replacements):

// Simple constants
#define PI 3.14159
#define MAX_STUDENTS 100
#define GREETING "Hello, World!"

// Function-like macros (with parameters)
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(x) ((x) < 0 ? -(x) : (x))

// Multi-line macros (use backslash)
#define PRINT_DEBUG(msg) \
    printf("DEBUG: %s\n", msg); \
    printf("File: %s, Line: %d\n", __FILE__, __LINE__)

int main() {
    float area = PI * 5 * 5;           // PI becomes 3.14159
    int sq = SQUARE(4);                // Becomes ((4) * (4)) = 16
    int bigger = MAX(10, 20);          // Becomes ((10) > (20) ? (10) : (20)) = 20
    
    printf("Area: %f\n", area);
    printf("Square: %d\n", sq);
    printf("Max: %d\n", bigger);
    
    return 0;
}

Conditional Compilation

Include or exclude code based on conditions:

// Check if macro is defined
#define DEBUG  // Comment this out to disable debug mode

#ifdef DEBUG
    printf("Debug mode is ON\n");
    printf("Variable x = %d\n", x);
#endif

// Check if macro is NOT defined
#ifndef PRODUCTION
    printf("This is a development build\n");
#endif

// If-else conditions
#if MAX_SIZE > 100
    printf("Large array mode\n");
#elif MAX_SIZE > 50
    printf("Medium array mode\n");
#else
    printf("Small array mode\n");
#endif

// Prevent multiple inclusion (header guards)
#ifndef MYHEADER_H
#define MYHEADER_H
    // Header content goes here
#endif

Predefined Macros

C provides some built-in macros that are automatically available:

#include <stdio.h>

int main() {
    printf("This file: %s\n", __FILE__);
    printf("This line: %d\n", __LINE__);
    printf("Compiled on: %s at %s\n", __DATE__, __TIME__);
    printf("Function: %s\n", __func__);
    return 0;
}

Single-Line Comments (//)

Use // for short comments on one line. Everything after // until the end of the line is ignored:

#include <stdio.h>

int main() {
    // This is a single-line comment
    int age = 25;  // You can also put comments at the end of a line
    
    // Calculate the birth year
    // (assuming current year is 2026)
    int birthYear = 2026 - age;
    
    printf("Birth year: %d\n", birthYear);
    
    // return 0;  // You can "comment out" code to disable it
    return 0;
}

Multi-Line Comments (/* */)

Use /* */ for longer comments that span multiple lines:

/*
 * This is a multi-line comment.
 * It can span as many lines as you need.
 * The asterisks at the start of each line are optional
 * but make it easier to read.
 */

/* You can also write it all on one line like this */

/*
   Or without the asterisks,
   just starting after the opening
   and ending before the closing.
*/

int main() {
    /* 
       Calculate compound interest
       Formula: A = P(1 + r/n)^(nt)
       Where:
       - P = principal amount
       - r = annual interest rate
       - n = times compounded per year
       - t = time in years
    */
    float principal = 1000.0;
    float rate = 0.05;
    
    return 0;
}

/* outer comment /* inner comment */ still in outer? */ // ERROR!

Documentation Comments

For functions and files, use structured documentation comments. Tools like Doxygen can generate documentation from these:

/**
 * @file calculator.c
 * @brief A simple calculator program
 * @author Your Name
 * @date January 2026
 * @version 1.0
 */

/**
 * @brief Calculates the sum of two integers
 * 
 * This function takes two integer parameters and returns
 * their sum. It handles both positive and negative numbers.
 * 
 * @param a The first integer
 * @param b The second integer
 * @return The sum of a and b
 * 
 * @example
 *   int result = add(5, 3);  // Returns 8
 */
int add(int a, int b) {
    return a + b;
}

/**
 * @brief Divides two numbers safely
 * 
 * @param numerator The number to be divided
 * @param denominator The number to divide by (must not be 0)
 * @return The result of division, or 0 if denominator is 0
 * 
 * @warning Returns 0 if denominator is 0 (division by zero)
 */
float safeDivide(float numerator, float denominator) {
    if (denominator == 0) {
        return 0;  // Avoid division by zero
    }
    return numerator / denominator;
}

Comment Best Practices

// Use binary search for O(log n) performance
// instead of linear search O(n)
int index = binarySearch(arr, target);

// Convert Celsius to Fahrenheit
// Formula: F = C × 9/5 + 32
float fahrenheit = celsius * 9.0/5.0 + 32;

// TODO: Add input validation
// FIXME: This crashes with empty arrays
// HACK: Temporary workaround for bug #123

// Increment i by 1
i++;  // This is obvious from the code!

// Set x to 5
int x = 5;  // States the obvious

// Loop through array
for (int i = 0; i < n; i++) {
    // Do something
    process(arr[i]);  // Doesn't explain WHY
}

Primary Data Types

Type Modifiers

Modifiers change the range and size of data types:

unsigned int positive = 4000000000;  // Only positive
signed int negative = -500;          // Can be negative (default)

short int small = 32000;        // 2 bytes
long int big = 2000000000L;     // 4+ bytes
long long huge = 9000000000LL;  // 8 bytes

Checking Size with sizeof()

Use the sizeof() operator to check the size of data types on your system:

#include <stdio.h>

int main() {
    printf("Size of char: %zu bytes\n", sizeof(char));       // 1
    printf("Size of int: %zu bytes\n", sizeof(int));         // 4
    printf("Size of float: %zu bytes\n", sizeof(float));     // 4
    printf("Size of double: %zu bytes\n", sizeof(double));   // 8
    printf("Size of long: %zu bytes\n", sizeof(long));       // 4 or 8
    printf("Size of long long: %zu bytes\n", sizeof(long long)); // 8
    
    return 0;
}

Using the const Keyword

The const keyword creates a read-only variable:

#include <stdio.h>

int main() {
    const float PI = 3.14159;
    const int MAX_STUDENTS = 100;
    const char NEWLINE = '\n';
    
    printf("PI = %f\n", PI);
    printf("Max students: %d\n", MAX_STUDENTS);
    
    // PI = 3.14;  // ERROR: Cannot modify a const variable
    
    return 0;
}

Using #define Preprocessor

The #define directive creates symbolic constants (macros):

#include <stdio.h>

#define PI 3.14159
#define MAX_SIZE 100
#define GREETING "Hello, World!"
#define SQUARE(x) ((x) * (x))

int main() {
    float radius = 5.0;
    float area = PI * radius * radius;
    
    printf("Area: %f\n", area);           // Area: 78.539750
    printf("%s\n", GREETING);             // Hello, World!
    printf("Square of 4: %d\n", SQUARE(4)); // Square of 4: 16
    
    return 0;
}

const vs #define

Basic Usage

#include <stdio.h>

int main() {
    // Simple text output
    printf("Hello, World!\n");
    
    // Multiple printf statements
    printf("Line 1\n");
    printf("Line 2\n");
    
    // Without newline (continues on same line)
    printf("Part 1 ");
    printf("Part 2\n");  // Output: Part 1 Part 2
    
    return 0;
}

Printing Variables

Use format specifiers to print variable values:

#include <stdio.h>

int main() {
    int age = 25;
    float height = 5.9;
    char grade = 'A';
    char name[] = "Alice";
    
    printf("Name: %s\n", name);           // Name: Alice
    printf("Age: %d years\n", age);       // Age: 25 years
    printf("Height: %.1f feet\n", height); // Height: 5.9 feet
    printf("Grade: %c\n", grade);         // Grade: A
    
    // Multiple variables in one printf
    printf("%s is %d years old\n", name, age);  // Alice is 25 years old
    
    return 0;
}

Escape Sequences

Special character combinations for formatting output:

printf("Hello\tWorld\n");     // Hello    World
printf("Line1\nLine2\n");     // Line1
                               // Line2
printf("She said \"Hi\"\n");  // She said "Hi"
printf("Path: C:\\Users\n");  // Path: C:\Users

Basic Usage

Use the address-of operator (&) to pass variable addresses to scanf:

#include <stdio.h>

int main() {
    int age;
    float salary;
    char grade;
    
    // Reading an integer
    printf("Enter your age: ");
    scanf("%d", &age);  // Note the & before variable name
    
    // Reading a float
    printf("Enter your salary: ");
    scanf("%f", &salary);
    
    // Reading a character
    printf("Enter your grade: ");
    scanf(" %c", &grade);  // Space before %c to skip whitespace
    
    printf("\nYou are %d years old\n", age);
    printf("Salary: $%.2f\n", salary);
    printf("Grade: %c\n", grade);
    
    return 0;
}

Reading Multiple Values

#include <stdio.h>

int main() {
    int day, month, year;
    
    // Reading multiple integers at once
    printf("Enter date (DD MM YYYY): ");
    scanf("%d %d %d", &day, &month, &year);
    
    printf("Date: %02d/%02d/%d\n", day, month, year);
    
    // Reading with different separators
    printf("Enter date (DD/MM/YYYY): ");
    scanf("%d/%d/%d", &day, &month, &year);
    
    printf("Date: %02d-%02d-%d\n", day, month, year);
    
    return 0;
}

Reading Strings

#include <stdio.h>

int main() {
    char name[50];
    char city[50];
    
    // Reading a single word (stops at whitespace)
    printf("Enter your first name: ");
    scanf("%s", name);  // No & needed for arrays
    
    // Reading a line with spaces using fgets (safer)
    printf("Enter your city: ");
    getchar();  // Clear newline from previous input
    fgets(city, sizeof(city), stdin);
    
    printf("Hello, %s from %s", name, city);
    
    return 0;
}

Common Format Specifiers

Width and Precision

#include <stdio.h>

int main() {
    int num = 42;
    float price = 9.99;
    
    // Minimum width
    printf("[%5d]\n", num);      // [   42] - right-aligned, width 5
    printf("[%-5d]\n", num);     // [42   ] - left-aligned, width 5
    printf("[%05d]\n", num);     // [00042] - zero-padded, width 5
    
    // Precision for floats
    printf("[%f]\n", price);     // [9.990000] - default 6 decimals
    printf("[%.2f]\n", price);   // [9.99] - 2 decimals
    printf("[%8.2f]\n", price);  // [    9.99] - width 8, 2 decimals
    
    // Precision for strings
    printf("[%.5s]\n", "Hello World");  // [Hello] - max 5 chars
    
    return 0;
}

Implicit Conversion (Automatic)

C automatically converts smaller types to larger types to prevent data loss:

#include <stdio.h>

int main() {
    int num = 10;
    float result;
    
    // int automatically converted to float
    result = num + 2.5;  // 10 becomes 10.0, result = 12.5
    printf("Result: %f\n", result);  // 12.500000
    
    // char automatically converted to int
    char letter = 'A';
    int ascii = letter;  // ascii = 65
    printf("ASCII of %c is %d\n", letter, ascii);
    
    // Type promotion in expressions
    int a = 5, b = 2;
    float division = a / b;  // Integer division: 2.0 (not 2.5!)
    printf("5 / 2 = %f\n", division);
    
    return 0;
}

Explicit Conversion (Type Casting)

Use cast operator to force conversion:

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    float result;
    
    // Without casting: integer division
    result = a / b;
    printf("Without cast: %f\n", result);  // 2.000000
    
    // With casting: floating-point division
    result = (float)a / b;
    printf("With cast: %f\n", result);     // 2.500000
    
    // Converting float to int (truncates decimal)
    float price = 99.99;
    int rounded = (int)price;
    printf("Price: %.2f, Rounded: %d\n", price, rounded);  // 99.99, 99
    
    // Character to integer conversion
    char digit = '7';
    int value = digit - '0';  // Convert char '7' to int 7
    printf("Digit: %c, Value: %d\n", digit, value);
    
    return 0;
}