Introduction to C

The C programming language was conceived and developed between 1969 and 1973 by computer scientist Dennis M. Ritchie at AT&T Bell Laboratories in Murray Hill, New Jersey. Its principal motivation was to rewrite the Unix operating system kernel, which was previously implemented in hardware-dependent assembly language on the DEC PDP-11 computer.

C evolved through a distinguished lineage of procedural programming languages:

• ALGOL 60 (1960): Introduced structured block programming and formal language grammars.
• CPL (Combined Programming Language, 1963): Developed jointly by Cambridge and London Universities; highly expressive but exceedingly complex to compile.
• BCPL (Basic Combined Programming Language, 1967): Developed by Martin Richards at Cambridge as a compact, untyped compiler-writing tool.
• B Language (1969): Developed by Ken Thompson at Bell Labs; an untyped, word-oriented distillation of BCPL used in the initial assembly of Unix.
• C Language (1972): Created by Dennis Ritchie by introducing explicit data typing, structures, and pointer arithmetic to the B language, achieving both machine independence and raw hardware efficiency.
• ANSI C (C89/C90): Standardized in 1989 by the American National Standards Institute (ANSI X3.159-1989) and internationally ratified by ISO (ISO/IEC 9899:1990) to eliminate non-standard dialect discrepancies.

Computer scientists categorize programming languages into high-level, low-level, and middle-level based on their abstraction distance from physical computer hardware:

A complete, well-formed C source program consists of six distinct functional sections:

1. Documentation Section: Contains comments documenting program intent, author details, algorithms, and revision dates. C supports multi-line block comments (`/* comment */`) and C99 single-line comments (`// comment`). Comments are stripped during preprocessing and generate zero machine instructions.
2. Link Section (Preprocessor Directives): Provides instructions to the C preprocessor to include external header files containing standard library declarations (`#include <stdio.h>`, `#include <math.h>`).
3. Definition Section: Declares symbolic constants and macro functions using the `#define` directive (`#define PI 3.14159265`, `#define MAX_BUFFER 1024`).
4. Global Declaration Section: Declares global variables accessible across all program functions and prototypes of user-defined functions (`int calculate_sum(int, int);`).
5. Main Function Header & Body (`main()`): The mandatory entry point of every C executable. Program execution unconditionally commences at `main()`. In modern ANSI C, it has the signature `int main(void)` or `int main(int argc, char *argv[])` and returns an integer exit code to the operating system shell.
6. Subprogram Section (User-Defined Functions): Contains the concrete implementation bodies of functions prototyped earlier, promoting modularity and code reuse.

Unlike interpreted scripting languages that execute source text directly, C is a purely compiled language. Transforming a human-authored text file into an executable binary involves five rigorous transformation stages:

When an operating system loads a compiled C executable into memory, it structures the application's virtual address space into five distinct segments:

• 1. Text Segment (Code Segment): Resides in the lowest memory addresses. Contains the compiled machine-code instructions of the program. It is marked Read-Only to prevent errant pointers from overwriting program logic, and is sharable among concurrent processes running the same binary.
• 2. Initialized Data Segment: Contains global variables, static variables, and constant strings that are explicitly assigned initial values by the programmer prior to compilation (e.g., `int global_count = 100; static float tax = 0.05;`).
• 3. Uninitialized Data Segment (BSS Segment): Acronym for "Block Started by Symbol". Contains all uninitialized global and static variables (e.g., `static int buffer[1000];`). The executable file stores only the byte length of BSS rather than zeroed bytes on disk; upon process creation, the OS kernel automatically zeroes out this memory segment.
• 4. Heap Segment: Used for dynamic runtime memory allocation managed explicitly by the programmer via `malloc()`, `calloc()`, `realloc()`, and released via `free()`. The heap begins immediately above the BSS segment and grows upward toward higher memory addresses.
• 5. Stack Segment: Resides at the highest virtual memory address and grows downward toward lower memory addresses. Manages automatic variables, function formal parameters, activation records (stack frames), and function return addresses in a strict LIFO (Last-In, First-Out) discipline.

The basic source character set in ANSI C comprises:

• Letters: Uppercase `A`–`Z` and Lowercase `a`–`z` (52 distinct characters; C is strictly case-sensitive).
• Digits: Decimal digits `0`–`9` (10 characters).
• Special Characters: `+ - * / % = < > ! & | ^ ~ . , ; : ? ' " ( ) [ ] { } _ # \` (29 characters).
• White Space Characters: Blank space, horizontal tab (` `), carriage return (` `), newline (` `), and form feed (``).

A C Token is the smallest indivisible individual lexical unit recognized by the C compiler during lexical analysis. The compiler converts raw source characters into a stream of tokens. C tokens are categorized into six mutually exclusive classes:

1. Keywords: Reserved words possessing immutable predefined meanings.
2. Identifiers: User-defined names assigned to variables, functions, arrays, and user structures.
3. Constants (Literals): Fixed values that remain completely invariant during program execution.
4. Strings: Sequences of characters bounded by double quotes, terminated by a null byte (`'\0'`).
5. Operators: Symbols instructing the compiler to perform specific mathematical, logical, or relational operations.
6. Special Symbols (Punctuators): Delimiters such as parentheses `( )`, brackets `[ ]`, braces `{ }`, commas `,`, and semicolons `;`.

ANSI C (C89) establishes exactly 32 reserved keywords, all written strictly in lowercase. They cannot be redeclared or repurposed as identifier names:

An identifier is a programmatic name assigned by the developer to variables, arrays, symbolic functions, and labels. Valid identifiers must strictly adhere to four lexical rules:

• Valid Characters: May contain letters (`A`–`Z`, `a`–`z`), decimal digits (`0`–`9`), and the underscore character (`_`).
• First Character Restriction: Must commence with an alphabet letter or an underscore. An identifier can never begin with a digit (e.g., `1variable` is invalid; `_count` and `variable1` are valid).
• Case Sensitivity: C is strictly case-sensitive; `Total`, `total`, and `TOTAL` represent three completely distinct memory locations.
• Prohibitions: Identifiers cannot contain whitespace, punctuation marks, or special symbols (`@`, `$`, `#`, `-`); and cannot duplicate any of the 32 reserved keywords.
• Length Significance: While modern compilers support long names, ANSI C guarantees that at least the first 31 characters of an internal identifier are significant.

Constants represent fixed values that cannot be altered by the program:

• Integer Constants:
  • Decimal: Digits 0–9 without leading zero (`45`, `-312`).
  • Octal: Digits 0–7 with a mandatory leading zero `0` (`075` = $7 imes 8^1 + 5 imes 8^0 = 61_{10}$).
  • Hexadecimal: Digits 0–9 and A–F with leading prefix `0x` or `0X` (`0x2A` = $2 imes 16^1 + 10 imes 16^0 = 42_{10}$).
• Floating-Point (Real) Constants: Written in fractional notation (`3.14159`) or exponential scientific notation (`mantissa E exponent`, e.g., `1.5e-3` representing $1.5 imes 10^{-3} = 0.0015$).
• Character Constants: A single character enclosed in single quotation marks (`'A'`, `'7'`, `'+'`). In C, character constants evaluate to their underlying integer ASCII code (e.g., `'A'` equals integer `65`).
• Escape Sequences: Non-printable or formatting characters preceded by a backslash (`\`):
  • `\n`: Newline (Line Feed, ASCII 10)
  • `\t`: Horizontal Tab (ASCII 9)
  • `\r`: Carriage Return (ASCII 13)
  • `\0`: Null character (ASCII 0, string terminator)
  • `\\`: Literal backslash character
  • `\'` and `\"`: Literal single and double quotes
• String Literals: An ordered sequence of zero or more characters bounded by double quotes (`"Hello, World!"`). The compiler automatically appends a terminating null byte (`'\0'`) at the end of the string array in memory. Hence, `"A"` occupies 2 bytes (`'A'` and `'\0'`), whereas character constant `'A'` occupies 1 byte.

A data type establishes the memory width, bit representation, and permissible range of values for a variable. The core primitive data types in C are:

• `const` Qualifier: Declares a variable as read-only. Once initialized, any programmatic attempt to modify its value triggers a compile-time error (`const float TAX_RATE = 0.18;`).
• `volatile` Qualifier: Informs the compiler optimizer that the variable's value may change unexpectedly through external hardware, memory-mapped I/O, or asynchronous interrupt service routines (ISRs). It forces the CPU to re-read the variable directly from physical RAM rather than caching it in a CPU register.

The storage class of a variable dictates four critical runtime properties: its physical storage location (RAM stack, RAM data, or CPU register), default initial value, scope (visibility), and lifetime (extent):

Critical Engineering Distinctions:

• `register` Limitation: Because a register variable resides physically in a CPU register rather than RAM, the address-of operator `&` cannot be applied to it (`&reg_var` produces a compile error).
• `static` Persistence: When declared inside a function, a `static` local variable retains its modified value across multiple function calls, initializing exactly once before program startup.
• `extern` Linkage: Declaring `extern int x;` creates a declaration without allocating physical memory, notifying the linker that `x` is defined in an external compilation unit.

The `printf()` function, declared in `<stdio.h>`, performs formatted stream output to the standard output device (`stdout`, typically the terminal monitor). Its formal prototype is:

int printf(const char *format, ...);

Return Value: `printf()` returns the total number of characters successfully printed to the output stream, or a negative value if an output error occurs.

Format Conversion Specifier Structure: `%[flags][width][.precision][length]type`

• Conversion Types: `%d`/`%i` (signed decimal integer), `%u` (unsigned integer), `%f` (floating-point), `%lf` (double), `%c` (single character), `%s` (string sequence), `%x`/`%X` (hexadecimal lowercase/uppercase), `%o` (octal), `%p` (pointer memory address), `%%` (literal `%`).
• Width Specifier: Sets the minimum number of print columns. If the value has fewer characters, it is padded with leading spaces (`%6d` prints `42` as `__42`).
• Precision Specifier: For floating-point, specifies the exact number of digits after the decimal point (`%.2f` rounds `3.14159` to `3.14`). For strings, specifies the maximum characters to print (`%.4s` on `"TARGET"` prints `"TARG"`).
• Flags:
  • `-` (Minus): Left-aligns the output within the field width (`%-6d` prints `42__`).
  • `0` (Zero): Pads field width with leading zeros instead of spaces (`%06d` prints `000042`).
  • `+` (Plus): Forces explicit display of positive sign `+` for positive numerical values (`%+d` prints `+42`).

The `scanf()` function reads formatted input from the standard input stream (`stdin`, typically the keyboard):

int scanf(const char *format, ...);

The Address-of Operator Requirement (`&`): Because C functions receive parameters strictly by value, passing a variable name directly (`scanf("%d", num)`) passes a copy of its current value, preventing `scanf` from modifying the caller's memory. Therefore, `scanf` requires the memory address of the variable (`&num`), simulating call-by-reference.

Exception for Strings and Arrays: In C, the name of an array acts as a pointer to its first element. Hence, reading into `char str[50]` requires `scanf("%s", str)` without the `&` operator.

Return Value: `scanf()` returns the total number of input items successfully matched, converted, and assigned. It returns `EOF` (-1) if end-of-file is encountered before any conversion occurs.

• Character Functions:
  • `getchar()`: Reads a single character from `stdin` including whitespace and newline; returns an `int` containing the ASCII value or `EOF`.
  • `putchar(int c)`: Writes a single character to `stdout`.
  • `getch()` & `getche()`: Non-standard console functions in `<conio.h>`. `getch()` reads a keystroke instantly without buffering or echoing; `getche()` echoes the character to the screen.
• String Functions:
  • `gets()`: Historically used to read an entire line including spaces until newline. CRITICAL DANGER: `gets()` does not perform boundary bounds-checking, causing catastrophic Buffer Overflow vulnerabilities. It was formally deprecated in C99 and completely eliminated in the C11 standard.
  • `fgets(char *str, int size, FILE *stream)`: The safe, standard replacement. Reads up to `size - 1` characters, guaranteeing null termination without exceeding buffer bounds (`fgets(name, sizeof(name), stdin)`).
  • `puts(const char *str)`: Prints a string followed automatically by a newline (`\n`).

An operator is a syntactic token that triggers a computational, relational, or logical transformation across one or more operands:

1. Arithmetic Operators: Addition (`+`), Subtraction (`-`), Multiplication (`*`), Division (`/`), and Modulus (`%`).
   • Integer Division: Dividing two integers truncates any fractional portion: $17 / 5 = 3$.
   • Modulus Operator: Computes remainder after integer division ($17 \% 5 = 2$). Operands of `%` must be integers; applying `%` to float or double produces a compile-time error.
2. Relational Operators: Evaluate inequalities and return integer `1` for True or `0` for False: `==` (equality), `!=` (inequality), `<`, `<=`, `>`, `>=`.
3. Logical Operators: Logical AND (`&&`), Logical OR (`||`), and Logical NOT (`!`). Operates with short-circuit evaluation.
4. Bitwise Operators: Perform bit-level binary manipulations on integer and character operands:
   • `&` (Bitwise AND): Sets bit to 1 only if both corresponding bits are 1.
   • `|` (Bitwise OR): Sets bit to 1 if either corresponding bit is 1.
   • `^` (Bitwise XOR): Sets bit to 1 if bits differ ($1 \oplus 0 = 1$, $1 \oplus 1 = 0$).
   • `~` (Bitwise NOT / One's Complement): Inverts all bits ($~x = -(x + 1)$ in two's complement).
   • `<<` (Bitwise Left Shift): Shifts bits left by $k$ positions, filling with zeros; equivalent to multiplying by $2^k$ ($x \ll 1 \equiv x imes 2$).
   • `>>` (Bitwise Right Shift): Shifts bits right by $k$ positions; equivalent to integer dividing by $2^k$ ($x \gg 1 \equiv \lfloor x / 2 floor$).
5. Assignment & Compound Assignment: Simple assignment (`=`) and compound shorthands: `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`. Evaluates from right to left.
6. Increment / Decrement Operators: Pre-increment (`++x`) increments $x$ before yielding its value; Post-increment (`x++`) yields current value first, then increments $x$.
7. Conditional (Ternary) Operator: `condition ? expr_true : expr_false`. The only ternary operator in C.
8. Special Operators:
   • `sizeof`: Computes size in bytes of a data type or variable at compile-time.
   • Comma Operator (`,`): Evaluates expressions sequentially from left to right, returning the value of the rightmost expression (`x = (a=3, b=5, a+b);` yields `8`).
   • Address-of (`&`) and Pointer Dereference (`*`).

When multiple operators appear in a single compound expression without explicit parentheses, their evaluation order is dictated by strict operator precedence and associativity:

• Implicit Conversion (Type Promotion / Coercion): Automatically performed by the compiler during mixed-mode arithmetic without programmer intervention. The operands are systematically promoted upward along the rank hierarchy to preserve numerical precision:
  `char` / `short` → `int` → `unsigned int` → `long` → `unsigned long` → `float` → `double` → `long double`.
  For example, evaluating `5 / 2.0`: integer `5` is promoted to `double 5.0`, yielding `double 2.5`.
• Explicit Conversion (Type Casting): Manually enforced by the programmer using the cast syntax `(target_type) expression`. For example, `(float)15 / 4` forces floating-point division yielding `3.75` instead of integer truncation `3`.