C Fundamentals and Program Structure¶

Introduction to Programming Languages¶

High-level vs Low-level Languages¶

High-level languages:

Designed for human readability and ease of use
Closer to natural language syntax
Include features like automatic memory management
Examples: Python, Java, C++, JavaScript

Low-level languages:

Closer to machine code and hardware architecture
Require understanding of computer architecture
Provide direct control over hardware resources
Examples: Assembly language, Machine code

Key differences:

Aspect	High-level	Low-level
Abstraction	High abstraction from hardware	Direct hardware control
Portability	Platform independent	Platform specific
Development time	Faster development	Slower development
Performance	Generally slower	Generally faster
Memory management	Automatic	Manual

Compiled vs Interpreted Languages¶

Compiled languages:

Source code translated to machine code before execution
Complete conversion before program runs
Examples: C, C++, Rust, Go

Interpreted languages:

Source code executed line by line during runtime
No separate compilation step
Examples: Python, JavaScript, Ruby

Hybrid approaches:

Some languages use both compilation and interpretation
Java: bytecode compilation followed by JVM interpretation
C#: compilation to IL followed by JIT compilation

[insert image on programming language compilation vs interpretation here]

Structure of a C Program¶

A well-structured C program typically follows this organization:

Preprocessor directives

Include headers like #include
Macro definitions using #define

Global declarations

Global variables
Function prototypes

Main function

Entry point of the program
Program execution starts here

User-defined functions

Additional functionality
Called from main or other functions

Example basic structure:

#include <stdio.h>  // Preprocessor directive

// Global variable declaration
int global_var = 0;

// Function prototype
void display_message();

int main() {
    // Local variable declarations
    int local_var = 1;

    // Statements
    printf("Hello, World!\n");
    display_message();

    return 0;  // Return statement
}

// User-defined function
void display_message() {
    printf("This is a user-defined function.\n");
}

Introduction to Header Files¶

Header files serve several purposes:

Function declarations:

Prototypes for standard library functions
User-defined function prototypes

Macro definitions:

Constants and symbolic names
Example: #define PI 3.14159

Data type definitions:

Custom structures and unions
Typedef statements

Header guards:

Prevent multiple inclusions

Example:

#ifndef HEADER_FILE_H
#define HEADER_FILE_H
// Content
#endif

Common standard headers:

<stdio.h> - Input/output functions
<stdlib.h> - Memory allocation and process control
<string.h> - String manipulation
<math.h> - Mathematical functions
<conio.h> - Console input/output (non-standard)

[insert image on C header files structure here]

Main Function and Simple Program Execution¶

The main function is the entry point of every C program:

int main() {
    // Program statements
    return 0;
}

Key aspects of the main function:

Return type:

int indicates the function returns an integer
Returning 0 indicates successful execution
Non-zero values indicate errors

Parameters:

void main() - No parameters
int main(void) - Explicitly no parameters
int main(int argc, char *argv[]) - With command-line arguments

Simple execution flow:

Program starts at main()
Statements are executed sequentially
The return statement ends the function
Operating system receives return value

[insert image on C program execution flow here]

Compiling and Executing a Program¶

The compilation process involves several stages:

Compilation Stages¶

Preprocessing:

Handles preprocessor directives
Expands macros and includes header files
Command: gcc -E program.c -o program.i

Compilation:

Translates code to assembly language
Command: gcc -S program.i -o program.s

Assembly:

Converts assembly to machine code
Command: gcc -c program.s -o program.o

Linking:

Combines object files with libraries
Creates executable file
Command: gcc program.o -o program

Complete Compilation Command¶

gcc -o program program.c
./program  # Execute the program

Common Compiler Options¶

Option	Description
`-o <file>`	Specify output file name
`-Wall`	Show all warnings
`-g`	Include debugging information
`-O2`	Optimize code
`-std=c11`	Specify C11 standard

[insert image on C compilation process here]

Common Compilation Errors and Solutions¶

Syntax Errors:

Missing semicolons
Incorrect parentheses or brackets
Undefined variables

Linker Errors:

Missing function definitions
Incorrect function declarations
Missing libraries

Runtime Errors:

Division by zero
Array out of bounds
Null pointer dereference

Debugging Tips:

Use compiler warnings (-Wall)
Add print statements to trace execution
Use debugging tools like gdb

Best Practices for C Programming¶

Consistent indentation and formatting
Meaningful variable and function names
Code comments for complex logic
Modular programming with separate functions
Error checking for input/output operations
Memory management and leak prevention