Module 1: Introduction to C

A Brief History of C

The C programming language was created by Dennis Ritchie at Bell Labs in the early 1970s, originally implemented on a DEC PDP-11 computer running the UNIX operating system. It evolved from earlier programming languages that influenced its design.

Language Evolution

• BCPL (Basic Combined Programming Language): Created by Martin Richards — simple, machine-independent system language.
• B: Developed by Ken Thompson, based on BCPL — used for early UNIX development.
• C: Introduced by Dennis Ritchie — added types, structures, and efficiency suitable for system programming.
• Used to rewrite UNIX: C replaced assembly language for the UNIX kernel, improving portability.
• Designed for efficiency: Offers low-level memory access with high-level language features.
• Foundation for many languages: Influenced C++, Java, C#, Objective-C, and more.

Key Milestones in C Standardization

• Portability: C programs can run on multiple hardware platforms with minimal changes.
• Legacy and Longevity: C remains one of the most widely used languages in system and embedded programming.
• Influence: Most modern programming languages have roots in or are heavily inspired by C.

C as a Middle-Level Language

C combines the best elements of high-level languages with the control and flexibility of assembly language.

Programming Language Spectrum:

Key Characteristics of C as Middle-Level Language:

• Hardware Access: Allows manipulation of bits, bytes, and addresses
• Portability: Easy to adapt software for different systems
• Flexible Typing: Not strongly typed; permits type conversions
• Minimal Runtime Checking: No automatic array bounds checking
• Direct Memory Manipulation: Ideal for system-level programming
• Compact Keyword Set: C89 has 32 keywords, C99 adds only 5 more

C as a Structured Language

C is a structured programming language that emphasizes compartmentalization of code and data.

Structured vs. Non-structured Languages:

Key Structural Features of C:

• Compartmentalization: C allows you to isolate code and data related to specific tasks, improving clarity and reducing errors.
• Functions: Functions are the main structural unit in C, enabling modular design and reusability of code.
• Code Blocks: Logical groups of statements are enclosed in curly braces { }, treated as one unit of execution.
• Structured Control: C supports while, do-while, and for loops. The use of goto is discouraged, unlike older languages such as BASIC or FORTRAN.
• Local Variables: Subroutines and functions in C can use local variables, preventing side effects in other parts of the program.
• Modularity: Functions can be written, tested, and reused independently, making C suitable for large projects involving multiple programmers.
• Reusability of Code: Once a function is created, it can be reused in different parts of a program or even across multiple programs, without modification.
• Reduced Use of Global Variables: Unlike BASIC, which relied heavily on global variables, C promotes controlled scope to avoid unintended interactions between program sections.
• Clarity of Algorithms: Code blocks and structured constructs allow complex algorithms to be expressed with simplicity, clarity, and efficiency.
• Freedom of Layout: Unlike old FORTRAN versions, C does not require strict field positions; statements can be placed flexibly in the code for readability.
• Modern Practice: Structured languages like C are widely used today. Non-structured languages are considered outdated and rarely used for serious new projects.

C as a Programmer's Language

Unlike languages designed for non-programmers (like COBOL and BASIC), C was created by and for working programmers.

Advantages for Programmers:

Historical Applications:

• Systems Programming: Operating systems, compilers, editors, linkers
• Embedded Systems: Still predominantly programmed in C
• Foundation for C++: C forms the basis for object-oriented C++
• Continuing Innovation: C99 standard shows ongoing language development

Compilers vs. Interpreters

Understanding the difference between compilation and interpretation is crucial for C programming, as C was specifically designed as a compiled language.

Comparison Table:

C as a Compiled Language:

• Optimized for Compilation: C was specifically designed as a compiled language
• Object Code: Source code translated into machine-executable binary code
• Efficiency: Compiled programs run faster than interpreted ones
• Stand-alone Executables: No need for interpreter during execution
• Limited Use of Interpreters: Mainly for debugging or experimental platforms

C Keywords and Reserved Words

C89 Standard Keywords (32 Keywords)

Complete List of C Keywords (32 Keywords)

C99 Additional Keywords (5 Keywords)

Storage Class Specifiers in C

Storage classes define how and where a variable is stored, its scope (where it can be used), and its lifetime (how long it exists).

• There are four main storage classes in C:
• auto
• register
• static
• extern

1. auto

• Default for local variables inside functions.
• Created when function starts, destroyed when it ends.
• Stored in memory (RAM).
• No need to write auto explicitly.

2. register

• Stored in CPU register for faster access.
• Used for frequently used variables like loop counters.
• You cannot use & to get its address.

3. static

• Remembers its value between function calls.
• Local static → keeps value across calls.
• Global static → visible only inside the file.

4. extern

• Used to declare a variable defined in another file.
• Does not create new memory.
• Used for sharing global variables between files.

Summary

Structure of a C Program or Basic Concepts of a C Program

All C programs consist of one or more functions, with main() being the essential starting point.

General Form of a C Program:

1. Comments

   • At the beginning of each program is a comment with a short description of the problem to be solved.
   • We can use the comments anywhere in the program.
   • The comments section is optional.
     Ex: 1. /* Program1: To find the sum of two numbers*/
     2. // Program2: To calculate the area and perimeter of circle
   • The symbol /* and ends with */ represents the multiline comment.
   • The symbol // can also be used for representing single line comment.

2. Preprocessor directives

   • The preprocessor statements start with # symbol.
   • These statements instruct the compiler to include some of the files in the beginning of the program.
     Ex: #include<stdio.h>
     #include<math.h>
     are the files that the compiler includes in the beginning of the program.
   • The line containing #include<stdio.h> tells the compiler to allow our program to perform standard input and output 'stdio' operations.
   • The '#include' directive tells the compiler that we will be using parts of the standard function library.
   • Information about these functions is contained in a series of 'header files' (stdio.h).  .h says this file is a header file.
   • The pointed brackets < and > tell the compiler the exact location of this header file.
   • Using the preprocessor directives the user can define the constants also.
     Ex: #define PI 3.142

3. Global Declarations

   • The variables that are declared above (before) the main program are called global variables.
   • The global variables can be accessed anywhere in the main program and in all the other functions.

4. Function declarations and Definitions

   • In this section the functions are declared.
   • Immediately after the functions are declared, the functions can be defined.

5. The program header: main()

   • Every program must have a main function.
   • Always the C program begins its execution from main.

6. Body of the program

   • After the header or top lines is a set of braces ({ and }) containing a series of 'C' statements which comprise the 'body'- this is called the action portion of the program.
     #include <stdio.h>
main(void) {
   /* action portion of the program*/
}

   • The global variables can be accessed anywhere in the main program and in all the other functions.

7. Declaration section

   • The variables that are used inside the function should be declared in the declaration section.
   • For example, consider the declaration shown below:
     int sum=0;
     int a;
     float b;
     Here, the variable sum is declared as an integer variable and it is initialized to zero.
     The variable a is declared as an integer variable whereas the variable b is declared as a floating point variable.

8. Executable section

   • They represent the instructions given to the computer to perform a specific task.
   • The instructions can be input/output statements, expressions to be evaluated, simple assignment statements, control statements such as if statement, for statement etc.
   • Each executable statement ends with “;”. Example: Write a C program to display “Hello World”.
     #include <stdio.h>
void main(void) {
   printf(“Hello World”);
}


Key Structural Elements:

• main() function: Required starting point of execution
• Function-based: Programs are organized around functions
• Modular design: main() typically calls other functions
• Top-down organization: main() provides program outline

The C Standard Library and Linking

Why Libraries Are Essential

C provides very few built-in features through its keywords alone. Most useful tasks — such as input/output, math, or string handling — come from the Standard C Library. Without these libraries, even simple programs like printf("Hello World"); wouldn’t work!

• Input/Output operations: Functions like printf() and scanf() come from <stdio.h>.
  ➤ Example:
  #include <stdio.h>
printf("Enter a number: ");
scanf("%d", &n);
• Mathematical computations: Functions such as sqrt(), pow(), sin(), cos() are in <math.h>.
  ➤ Example:
  #include <math.h>
double root = sqrt(25);
// root = 5.0
• Character handling: Functions like toupper(), tolower(), isdigit() come from <ctype.h>.
  ➤ Example:
  #include <ctype.h>
char upper = toupper('a');
// upper = 'A'
• String manipulation: Functions like strcpy(), strlen(), strrev() (not standard everywhere) are in <string.h>.
  ➤ Example:
  #include <string.h>
char name[20];
strcpy(name, "C Programming");
• Memory management: Functions such as malloc(), calloc(), and free() come from <stdlib.h>.
  ➤ Example:
  #include <stdlib.h>
int *ptr = (int *)malloc(5 * sizeof(int));
free(ptr);

The Linking Process

When you compile and run your C program, the compiler and linker work together to include both your code and the necessary library functions.

Library Characteristics

• Relocatable Format: Library functions use memory offsets (not fixed addresses) so they can work in any program.
• Standard Minimal Set: Every C compiler provides core libraries like stdio.h, stdlib.h, string.h, and math.h.
• Compiler Extensions: Some compilers add extra libraries (e.g., graphics, sound, or system utilities).
• Custom Libraries: You can create your own libraries of reusable functions for future projects.
  ➤ Example: You can compile your own mylib.c into mylib.a or mylib.lib and reuse it.

Building Blocks of C Programming

Essential Components Summary

Best Practices for C Program Structure

Separate Compilation in C

What is Separate Compilation?

Separate compilation allows a C program to be divided across multiple source files, with each file compiled independently before being linked together.

Traditional vs Separate Compilation:

Benefits of Separate Compilation:

project/
├── main.c          (main program)
├── utils.c         (utility functions)
├── math_ops.c      (mathematical operations)
├── io_handlers.c   (input/output functions)
└── headers/
    ├── utils.h
    ├── math_ops.h
    └── io_handlers.h

The C Program Compilation Process

Three-Step Compilation Process:

Compilation Environments:

C Program Memory Map

Four Logical Memory Regions:

Detailed Memory Regions:

Quick Summary (Easy to Remember)

• The memory of a C program is divided into 4 main parts — Code, Data, Stack, and Heap.
• Code Segment → contains your compiled program instructions.
• Data Segment → stores global and static variables.
• Stack → used for function calls and local variables (works like a stack of plates).
• Heap → used for dynamic memory (malloc, calloc, etc.), can grow and shrink at runtime.

Important Points to Remember

• Code Segment: Read-only, fixed once the program starts.
• Data Segment: Divided into two parts:
  • Initialized Data → stores variables with assigned values.
  • Uninitialized Data (BSS) → stores variables declared but not initialized.
• Stack:
  • Each function call creates a new stack frame.
  • Automatically cleaned when the function ends.
  • Too many function calls cause a stack overflow.
• Heap:
  • Used with malloc(), calloc(), free().
  • Programmer must release memory manually using free().
  • Not released automatically — can cause memory leaks.
• Direction of Growth:
  • Stack → grows downward (towards lower memory).
  • Heap → grows upward (towards higher memory).
• Lifetime:
  • Code & Data → exist for the entire program.
  • Stack → temporary, per function call.
  • Heap → as long as you allocate (until free()).
• Easy Way to Remember: "Code writes the logic, Data holds memory, Stack handles calls, Heap grows freely."

Detailed Memory Regions:

Stack and Heap Memory Management

Stack Memory Characteristics:

Heap Memory Characteristics:

Memory Management Functions:

Practical Compilation Example (Fedora)

Separate Compilation Workflow:

Key Advantages in Practice:

• Incremental Compilation: Modify only utils.c? Just recompile utils.c and relink.
• Simple Editing: Use gedit or any editor to manage code easily.
• Faster Build: Avoid recompiling unchanged files.
• Clear Output: Separate object files and final executable.

Review of Terms: