C Fundamentals

C Program Structure

A C program is not a random collection of lines. It follows a standard layout that the compiler and operating system expect. When you open a .c file, you can usually spot these parts in order.

First come comments (optional) that explain the purpose of the program to humans. Next come preprocessor directives such as #include <stdio.h>, which tell the preprocessor to bring in standard library support for input and output. After that, you may declare optional global variables or function prototypes. Then comes the most important function: main(). Program execution always starts from main. Inside main, you write declarations and statements. Finally, return 0; tells the operating system that the program finished successfully.

1. Documentation / comments — notes for humans (ignored by the compiler)
2. Preprocessor directives — e.g. #include <stdio.h>
3. Global declarations — optional globals / function prototypes
4. main() function — starting point of execution
5. Statements & expressions — actual logic of the program
6. return — exit status returned to the operating system

Tokens — the smallest units of a C program

When the compiler reads your source code, it does not understand whole paragraphs at once. It first breaks the program into tiny meaningful pieces called tokens. A token is the smallest individual unit in C. Spaces and new lines are usually separators, not tokens themselves.

C tokens are grouped into these common categories:

• Keywords — reserved words with fixed meaning (int, return, if)
• Identifiers — names created by the programmer (sum, studentAge)
• Constants / Literals — fixed values written in code (10, 3.14, 'A')
• Operators — symbols that perform operations (+, -, =, ==)
• Special symbols — punctuation used by grammar ({}, (), ;, ,)
• String literals — text in double quotes ("Hello")

Example: in int a = 10; the tokens are int, a, =, 10, and ; — five tokens in total.

Keywords

Keywords are predefined reserved words of the C language. Their meaning is already fixed by the language standard, so you cannot redefine them or use them as variable names. For example, int always means an integer type keyword — you cannot create a variable named int.

Beginners should first memorize the most frequently used keywords, then gradually learn the rest while studying control statements, functions, and storage classes.

• Data-type keywords: int, float, char, double, void
• Control keywords: if, else, for, while, do, switch, case, break, return
• Storage / qualifier keywords: const, static, extern, auto, register
• Other useful keywords: sizeof, typedef, struct, union, enum

Variables

A variable is a named location in memory used to store data during program execution. The value of a variable can change as the program runs. For example, marks may first store 50 and later become 80 after an update.

To create a variable, you must tell the compiler two things: the data type (what kind of value it holds) and the name (how you will refer to it). Optionally, you can also give an initial value at the time of declaration.

• Declaration: int age; — creates an integer variable named age
• Initialization: int age = 20; — creates and assigns 20 immediately
• Assignment later: age = 21; — updates the stored value
• Naming rules: start with a letter or underscore; then letters, digits, underscore; no spaces; no keywords
• Valid names: marks, total_sum, _temp, student1
• Invalid names: 2sum (starts with digit), total sum (space), int (keyword)

Always choose meaningful names. totalMarks is clearer than t or x1 when you revisit the program later.

Constants

A constant is a named value that should not change while the program is running. Use constants for fixed information such as maximum seats, pass marks, tax rate, or the value of π.

In beginner C, constants are commonly created in two ways:

• Using const: const int MAX = 100; — typed and checked by the compiler
• Using #define: #define PI 3.14159 — replaced by the preprocessor before compilation
• Constants make programs easier to read and maintain (change the value in one place only)
• They also protect you from accidentally overwriting an important fixed value

Literals

A literal is a raw fixed value written directly in the source code. Literals are the actual numbers, characters, and text that appear in your statements. Constants often store literals, and variables are frequently initialized using literals.

• Integer literals: 25, 0, 0x1A (hex), 010 (octal)
• Floating literals: 3.14, 2.5e2 (scientific form)
• Character literals: 'A', '1', '\\n' (newline escape)
• String literals: "C Fundamentals", "Hello\\n"

Quick relation: in const int MAX = 100;, MAX is a constant name, and 100 is an integer literal assigned to it.

Program structure — what the compiler really expects

An executable C project must provide an entry point. In hosted environments (normal desktop/console programs), that entry point is main. You may write many helper functions, but execution still begins at main. Statements inside a function are usually terminated by a semicolon. Related statements are grouped using braces to form a block.

• Every normal executable needs exactly one main definition
• Most statements end with ; — missing semicolon is a classic compile error
• Blocks use curly braces { } to group declarations and statements
• Comments: /* multi-line */ and // single-line (C99 and later)
• Header inclusion and macros are handled in the preprocessing stage, before true compilation

How tokenization works (with flowchart)

Tokenization is the compiler’s first important reading pass. It scans characters left to right and forms the longest valid token when possible. Spaces separate tokens, but the number of spaces does not change meaning. That is why int a=10; and int a = 10 ; are treated the same.

Statement: int sum = a + 10;

Interview practice: count tokens in short lines like printf("Hi"); and x+=++y;. This skill shows that you understand how the compiler reads code.

Variables — scope, lifetime, and type safety

A variable is more than a name. It has a type (what it can store), a scope (where it is visible), and a lifetime (how long it exists in memory). Local variables declared inside main or any block are usually automatic: they are created when the block starts and destroyed when the block ends. Global variables live for the whole program run.

• Scope: a local variable cannot be used outside its block
• Lifetime: automatic locals appear/disappear with the block
• Type conversion care: assigning 3.9 to int keeps only 3
• Initialization: reading an uninitialized local variable is undefined behavior
• Declaration vs definition: declaration introduces the name; definition allocates storage

Constants — choosing const or #define

Both const and #define can create fixed values, but they work differently. #define PI 3.14 is handled by the preprocessor as text replacement. It has no C type and no true scope in the same way variables do. const float PI = 3.14f; creates a typed read-only object that the compiler can check.

• const int MAX = 50; — typed, scoped, compiler-checked
• #define MAX 50 — textual replace before compilation, no type checking
• Prefer const for most modern C constants
• Keep #define for macros, conditional compilation, and some header flags
• Never assign to a const variable after initialization — that is a compile-time error

Literals — bases, suffixes, and escapes

The same number can be written in different literal forms. This is one of the most common advanced-basics traps in exams and interviews.

• Decimal: 42 means forty-two
• Octal: 052 starts with 0 and means 42 in decimal (5×8 + 2)
• Hexadecimal: 0x2A means 42 in decimal
• Suffixes: 10L (long), 10U (unsigned), 3.14f (float)
• Escape sequences: \\n newline, \\t tab, \\\\ backslash, \\' quote

Also remember: a character literal like 'A' has type int in C, while a string literal like "A" is a character array ending with '\\0'. These two are not the same.