Introduction to C Language

C is a general-purpose, procedural, compiled programming language developed for writing efficient and portable software. It enables programmers to communicate with a computer using human-readable instructions that are then translated into machine code the hardware executes directly.

Unlike natural languages, computers understand only binary — sequences of 0s and 1s. C acts as a precise bridge: you write instructions a human can read, and the compiler converts them into instructions a machine can run.

Instead of writing raw binary:

010010010101010100110010...

You write readable C code:

printf("Hello");

The compiler automatically converts your C source code into machine-executable instructions.

Why Learn C?

Many of the most important modern programming languages were directly influenced by or built upon C. Learning C means understanding the shared foundation they all rest on.

Before C existed, programmers who needed control over hardware had to write software directly in Assembly Language — machine-specific low-level instructions:

MOV AX, 5
ADD AX, 10
MOV [result], AX

Assembly language was powerful but came with serious problems that limited what programmers could realistically accomplish:

Programmers needed a new language that combined the best of both worlds:

• Easier to write than Assembly Language
• Faster than existing high-level languages like FORTRAN or COBOL
• Portable across different hardware architectures
• Efficient enough to write a complete operating system

Timeline

Dennis Ritchie — Creator of C

Dennis Ritchie developed C at Bell Laboratories in New Jersey. His primary motivation was to rewrite the UNIX operating system in a language that was simultaneously efficient and portable. Before C, operating systems were written entirely in Assembly Language, which meant rewriting them from scratch for every new processor architecture.

Ritchie’s decision to write UNIX in C changed computer science permanently. It proved that a high-level language could produce code efficient enough for systems programming, a belief that had previously been considered impossible.

Language Evolution

C became the dominant systems programming language because of a unique combination of features. Each one addresses a specific engineering need.

Middle-Level Language: The Sweet Spot

One of C’s defining characteristics is that it sits between low-level Assembly and high-level languages like Python. This gives it a unique combination of power and accessibility:

printf("Hello, World!");

int *ptr = (int *)0x40021000;  /* Access hardware register directly */
*ptr = 0xFF;                   /* Write to hardware */

C is used almost everywhere that performance, reliability, or hardware control is required. Here are the major domains where C is irreplaceable:

Real-World Examples

Every language is a set of tradeoffs. Understanding C’s strengths and weaknesses helps you decide when to use it and what pitfalls to watch for.

Advantages vs Disadvantages (Comparison Table)

Frequently Asked Questions

When you write C code and run it, several things happen behind the scenes. The source code you type cannot run directly — it goes through a multi-stage compilation pipeline that transforms it into a machine-executable program.

The Four Stages

Stage 1: Preprocessing

The preprocessor handles all lines starting with #. It copies the contents of header files into your source, expands macros (#define), removes all comments, and handles conditional compilation (#ifdef). The output is a larger, pure C file (.i extension).

Stage 2: Compilation

The compiler takes the preprocessed C code and translates it into assembly language — a human-readable form of the machine’s instruction set. This stage also performs syntax checking and optimization.

Stage 3: Assembly

The assembler converts assembly language into binary machine code (0s and 1s). The output is an object file (.o) that contains machine code but is not yet ready to run because it has unresolved references to library functions.

Stage 4: Linking

The linker combines your object file(s) with the necessary library code (like the C standard library that contains printf()). It resolves all external references and produces the final executable program.

Every C program, no matter how large or complex, follows the same fundamental organizational structure. Think of these as the six layers that make up any C program:

Here is the simplest complete C program that demonstrates this structure:

/*
    Program Name : Hello World
    Author       : Student
    Date         : 2024
*/                              /* 1. Documentation Section */

#include <stdio.h>              /* 2. Link Section          */

#define MAX_SIZE 100            /* 3. Definition Section    */

int total = 0;                  /* 4. Global Declaration    */

int main()                      /* 5. main() Function       */
{
    printf("Hello, World!\n");
    return 0;
}

int add(int a, int b)           /* 6. User-defined Function */
{
    return a + b;
}

The documentation section contains comments — text that is completely ignored by the compiler but is invaluable for human readers. Good comments explain why something is done, not just what.

Single-Line Comments

Use // to comment out everything from that point to the end of the line:

// This is a single-line comment

// Store student marks
marks = 95;

Multi-Line Comments

Use /* to start and */ to end a block comment. Useful for documentation blocks, explanations, and temporarily disabling code:

/*
    Program Name : Student Grade Calculator
    Author       : Naveen Kumar
    Date         : 2024-01-15
    Description  : Reads student marks and calculates grades
*/

/*
    This is
    a multi-line
    comment block.
*/

Writing Good Comments

Comments should add information that isn’t obvious from the code itself. Commenting what the code does (when it’s already clear) is noise. Commenting why adds real value:

The line #include <stdio.h> tells the preprocessor to include a header file. Think of header files as toolboxes that contain declarations for useful functions and types you can use in your program.

#include <stdio.h>    /* Standard Input/Output */
#include <stdlib.h>   /* General Utilities     */
#include <string.h>   /* String Functions      */
#include <math.h>     /* Mathematical Functions */

Common Header Files

Angle Brackets vs. Quotes

The definition section uses #define to create named constants and macros. Unlike variables, #define values are replaced textually by the preprocessor before compilation — they exist at zero runtime cost.

#define PI         3.14159
#define MAX_SIZE   100
#define TRUE       1
#define FALSE      0

When the compiler sees MAX_SIZE, it substitutes the value 100 directly. After preprocessing, the code looks like this:

Variables declared outside all functions are called global variables. They can be accessed by any function in the same file (and with extern, across files).

#include <stdio.h>

int total = 10;          /* Global variable: accessible everywhere */

void printTotal()
{
    printf("Total: %d\n", total);   /* Can access 'total' */
}

int main()
{
    printf("%d\n", total);          /* Can also access 'total' */
    total = 20;                     /* Can modify it too */
    printTotal();                   /* Prints: Total: 20 */
    return 0;
}

Every standard C program must have exactly one main() function. This is the entry point — the operating system calls main() first when your program starts, regardless of how many other functions exist.

int main()
{
    return 0;
}

Anatomy of main()

Every programmer’s journey begins with Hello, World. Here is the complete, minimal C program:

#include <stdio.h>

int main()
{
    printf("Hello World");

    return 0;
}

Line-by-Line Explanation

printf() (print formatted) is the primary output function in C. It displays text and values to the standard output (your terminal screen).

printf("Text to display");
printf("Value: %d", someVariable);

printf("Hello");
printf("World");

printf("Hello\n");
printf("World");

Escape Sequences

Escape sequences are special character combinations that represent non-printable characters or special formatting:

printf("Name\tMarks\n");
printf("Alice\t95\n");
printf("Bob\t88\n");

Format Specifiers

When you want to print values stored in variables, you use format specifiers as placeholders inside the string:

#include <stdio.h>

int main()
{
    int age = 20;
    float gpa = 3.85;
    char grade = 'A';

    printf("Age:   %d\n",   age);
    printf("GPA:   %.2f\n", gpa);
    printf("Grade: %c\n",   grade);

    return 0;
}

scanf() (scan formatted) reads input from the user via the keyboard. It pauses execution and waits for the user to type a value and press Enter.

scanf("format_specifier", &variable);

#include <stdio.h>

int main()
{
    int age;

    printf("Enter your age: ");
    scanf("%d", &age);
    printf("Your age is: %d\n", age);

    return 0;
}

Why the & (Ampersand)?

The & symbol is the address-of operator. It gives scanf() the memory address of the variable, not the variable’s current value. scanf() needs this address so it knows exactly where in memory to write the input value.

Reading Multiple Values

#include <stdio.h>

int main()
{
    int    age;
    float  marks;
    char   grade;

    printf("Enter age, marks, and grade: ");
    scanf("%d %f %c", &age, &marks, &grade);

    printf("Age: %d, Marks: %.1f, Grade: %c\n", age, marks, grade);

    return 0;
}

In C, every statement must end with a semicolon (;). The semicolon is the statement terminator — it tells the compiler that a statement has ended. Think of it as the full stop (period) at the end of an English sentence.

Exceptions — these do NOT end with semicolons:

• Preprocessor directives: #include <stdio.h>
• Function definitions: int main() { ... }
• Control flow blocks: if(...) { ... }, for(...) { ... }

C is a case-sensitive language. This means that uppercase and lowercase letters are treated as completely different characters. The following three are three different identifiers:

marks    /* identifier 1 */
Marks    /* identifier 2 */
MARKS    /* identifier 3 */

Common Beginner Mistakes (Syntax)

Before the compiler can process your code, it must break it down into its smallest meaningful pieces. These pieces are called tokens.

Consider this English sentence: "I love programming." — the individual words I, love, programming are the meaningful units.

Similarly, when the C compiler sees int age = 20;, it breaks it into these tokens:

The Six Types of Tokens

Keywords are reserved words that already have a fixed, predefined meaning in the C language. The compiler uses them to understand program structure. You cannot use them as variable names or identifiers.

int int = 10;     /* Error: "int" is a keyword */
int while = 5;    /* Error: "while" is a keyword */

int number = 10;   /* Correct: "number" is a valid identifier */
int count = 5;     /* Correct: "count" is a valid identifier */

Common C Keywords

Identifiers are names that you create to identify variables, functions, arrays, structures, and other user-defined elements in your program.

age
marks
studentName
totalSalary
calculateAverage

Rules for Naming Identifiers

There are exactly five rules. Violating any one of them causes a compiler error:

Good Naming Style

Meaningful names make your code self-documenting and dramatically easier to maintain:

A variable is a named memory location that stores data. You give the memory location a name (the variable name) so you can refer to it in your program. When the value changes, the contents of that memory location change.

Variable Declaration

Before using a variable you must declare it — tell the compiler its name and data type:

datatype variableName;

int    age;         /* declare an integer variable */
float  salary;      /* declare a float variable    */
char   grade;       /* declare a character variable */
double pi;          /* declare a double variable   */

Initialization

Giving a variable its first value is called initialization. It can be done at declaration or separately:

/* Declaration only */
int age;

/* Initialization after declaration */
age = 20;

/* Declaration AND initialization in one line */
int score = 95;

Declaration vs Initialization

Multiple Variables

/* Separate declarations */
int a = 10;
int b = 20;
int c = 30;

/* Combined on one line */
int a = 10, b = 20, c = 30;

A constant is a value that cannot be changed during program execution. Once defined, it remains fixed for the program’s lifetime. Attempting to modify a const variable causes a compiler error.

const float PI = 3.14159;
const int   MAX = 100;

PI = 5;     /* ERROR: cannot modify a const variable */
MAX = 200;  /* ERROR: cannot modify a const variable */

Types of Constants

/* Integer constant */
const int MAX_STUDENTS = 50;

/* Floating constant */
const float PI = 3.14159;

/* Character constant */
const char PASS_GRADE = 'A';

/* String constant (stored as char array) */
const char SCHOOL_NAME[] = "Embedded Systems Institute";

Variable vs Constant

Writing code that works is the minimum. Writing code that is readable, maintainable, and reliable is the professional standard. These practices apply from your first program onwards:

✓ Use Meaningful Names

✓ Always Initialize Variables

✓ Keep Naming Consistent

✓ Write Comments That Explain Intent

Mistake 1: Using Keywords as Variable Names

Mistake 2: Starting Identifiers with Numbers

Mistake 3: Spaces in Identifiers

Mistake 4: Using Confusing Single-Letter Names

Remember the Six Token Types

Use the mnemonic “Kind Intelligent Cats Sing Opera Softly” to remember all six token types:

Remember Identifier Rules

Ask these four questions before naming an identifier — if you answer YES to all of them, the name is valid:

Remember C Program Structure

These questions frequently appear in entrance tests, university exams, and technical interviews for embedded systems and systems programming roles.

You have completed Chapter 1 and built a solid foundation. Chapter 2 dives into the heart of C programming — the data model that makes the language so expressive and powerful in embedded systems: