C is a standardized programming language used to issue instructions to computer hardware. Unlike natural languages used for human communication, programming languages require strict syntax to be translated into machine code. Among the thousands of available languages, C remains a foundational choice for system programming, alongside modern alternatives like C++, Java, and Python.

Compilation and Linking Workflow

C is a compiled language. Source code stored in text files cannot execute directly. It must undergo translation by a compiler and combination by a linker to produce a binary executable.

The build process involves two primary stages:

1. Compilation: Each source file (typically ending in .c) is processed individually to generate object files (often .obj or .o).
2. Linking: The linker combines multiple object files and necessary library files to create the final executable (such as .exe on Windows).

Project Organization and File Types

When developing within an Integrated Development Environment (IDE), code is organized into projects. Within these projects, files are categorized by their extension:

• Source Files (.c): Contain the implementation of functions and logic.
• Header Files (.h): Contain declarations, macros, and function prototypes to be shared across source files.

Program Entry Point

Execution of a C program always begins at a specific function named main. This function serves as the unique entry point; even if a project contains multiple source files, only one main function is permitted.

The signature int main(void) indicates that the function returns an integer status code to the operating system upon completion. A return value of 0 typically signals successful execution.

#include <stdio.h>

int main(void) {
    printf("System Initialized\n");
    return 0;
}

Common syntax errors for beginners include misspelling main, omitting parentheses, using full-width punctuation, or forgetting semicolons at the end of statements.

Standard Library and Output

Functions like printf are not part of the core language syntax but belong to the standard library. These pre-implemented functions enhance development efficiency. To use them, the corresponding header must be included.

#include <stdio.h>

int main(void) {
    int quantity = 100;
    char grade = 'A';
    float price = 3.14f;

    printf("Count: %d\n", quantity);
    printf("Grade: %c\n", grade);
    printf("Cost: %f\n", price);
    
    return 0;
}

Format specifiers like %d, %c, and %f act as placeholders replaced by the provided arguments. The stdio.h header is required for standard input/output operations.

Reserved Keywords

C defines a set of reserved words that have special meaning to the compiler. These identifiers cannot be used for variable names or function labels. Examples include int, if, return, and while. The standard defines 32 core keywords, with additional ones like _Bool introduced in later standards like C99.

Character Encoding

Characters entered via keyboard are stored as numeric values based on the ASCII standard. In C, single characters are enclosed in single quotes (e.g., 'A').

Key ASCII ranges include:

• Uppercase A-Z: 65 to 90
• Lowercase a-z: 97 to 122
• Digits 0-9: 48 to 57
• Newline \n: 10

Characters can be printed as symbols or their numeric equivalents.

#include <stdio.h>

int main(void) {
    printf("%c\n", 'B');
    printf("%d\n", 'B'); // Prints 66
    return 0;
}

Iterating through numeric values allows printing ranges of characters.

#include <stdio.h>

int main(void) {
    for (int idx = 65; idx <= 90; idx++) {
        printf("%c ", idx);
    }
    printf("\n");
    return 0;
}

Strings and Null Termination

Strings are sequences of characters enclosed in double quotes (e.g., "Hello"). Internally, C appends a null character \0 (ASCII 0) to mark the end of the string. This terminator is crucial for functions like printf and strlen to determine where the string stops.

#include <stdio.h>

int main(void) {
    char auto_term[] = "end";
    char manual_term[] = {'e', 'n', 'd', '\0'};
    char no_term[] = {'e', 'n', 'd'};

    printf("%s\n", auto_term);    // Prints correctly
    printf("%s\n", manual_term);  // Prints correctly
    printf("%s\n", no_term);      // May print garbage after 'd'
    
    return 0;
}

Without the explicit \0, the program may continue reading memory until it randomly encounters a zero byte.

Escape Sequences

Certain characters require special representation using a backslash \. These escape sequences change the interpretation of the following character.

• \n: Newline
• \t: Horizontal tab
• \\: Backslash literal
• \": Double quote literal
• \0: Null character

#include <stdio.h>

int main(void) {
    printf("Line1\nLine2\n");
    printf("Tab\tSeparated\n");
    return 0;
}

Octal (\ddd) and hexadecimal (\xdd) notations can also represent specific character codes.

Statement Categories

C programs consist of discrete statements, generally ending with a semicolon. Statements fall into five categories:

1. Null Statement: A single semicolon ; performing no operation.
2. Expression Statement: An expression followed by a semicolon (e.g., x = y + 1;).
3. Function Call Statement: Invoking a function (e.g., printf("Hi");).
4. Compound Statement: A block of code enclosed in {}.
5. Control Statement: Directs flow (e.g., if, for, switch, break).

#include <stdio.h>

int compute(int x, int y) {
    return x + y;
}

int main(void) {
    int result = compute(10, 20); // Function call statement
    ;                             // Null statement
    {                             // Compound statement
        printf("%d\n", result);
    }
    return 0;
}

Comments and Annotations

Comments provide explanatory text ignored by the compiler. They are essential for documentation but should be used judiciously.

• Single-line: Starts with // and continues to the end of the line (C99 standard).
• Multi-line: Enclosed between /* and */.

#include <stdio.h>

int main(void) {
    // This is a single-line comment
    /* This is a 
       multi-line comment */
    printf("// Inside quotes is text\n");
    return 0;
}

Comments inside string literals are treated as plain text. During compilation, comments are effectively replaced by whitespace, ensuring they do not concatenate adjacent tokens unintentionally.