Introduction to C Programming Language

• C is a high-level, general-purpose programming language widely used for system programming and application development.
• It was developed by Dennis Ritchie at Bell Labs in the early 1970s.
• C has greatly influenced other popular programming languages, such as C++, Java, and C#.

Key Features of C

• Procedural: C is a procedural language, meaning programs are structured as a sequence of procedures or functions.
• Portable: C code can be compiled and executed on different platforms with minimal changes.
• Efficient: C allows direct memory manipulation, resulting in highly efficient and fast-executing programs.
• Low-level Access: C provides low-level access to system hardware, making it suitable for system programming.
• Standard Library: C includes a rich standard library with functions for input/output, string manipulation, and more.

Basic Syntax

• A C program consists of functions and variables.
• The main function is the entry point of every C program.
• Statements are terminated by semicolons (;).
• Code blocks are enclosed in curly braces {}.
• Comments are written using /* ... */ for multiline comments and // for single-line comments.

Data Types

• Basic data types include int (integer), float (floating-point), double (double-precision floating-point), and char (character).
• Modifiers like short, long, signed, and unsigned can be used to alter the range and storage of basic data types.
• void is a special data type representing the absence of a type.

Variables

• Variables must be declared before they are used, specifying their data type and name.
• Example: int age; declares an integer variable named age.
• Variables can be initialized when they are declared or later in the program.
• Example: int age = 25; initializes the age variable to 25.

Operators

• Arithmetic operators: +, -, *, /, % (modulus).
• Relational operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).
• Logical operators: && (logical AND), || (logical OR), ! (logical NOT).
• Assignment operators: =, +=, -=, *=, /=, %=.
• Increment/decrement operators: ++ (increment), -- (decrement).
• Bitwise operators: &, |, ^, ~, <<, >>.

Control Flow

• Conditional statements:
  • if statement: Executes a block of code if a condition is true.
  • if-else statement: Executes one block of code if a condition is true and another block if it is false.
  • else if statement: Allows for multiple conditions to be checked.
  • switch statement: Selects one of several code blocks to execute based on the value of a variable.
• Loop statements:
  • for loop: Repeats a block of code a specific number of times.
  • while loop: Repeats a block of code as long as a condition is true.
  • do-while loop: Repeats a block of code at least once and then continues as long as a condition is true.
• break statement: Terminates the current loop or switch statement.
• continue statement: Skips the rest of the current iteration of a loop and proceeds to the next iteration.
• goto statement: Transfers control to a labeled statement within the same function (use discouraged).

Functions

• A function is a block of code that performs a specific task.
• Functions can take arguments (input) and return a value (output).
• Function declaration: Specifies the function's name, return type, and parameters.
• Function definition: Provides the actual code that the function executes.
• Function call: Invokes the function to execute its code.
• Example:

int add(int a, int b) {
    return a + b;
}
int result = add(5, 3); // Function call

• return statement: Returns a value from a function to the caller.
• void return type: Indicates that the function does not return a value.

Arrays

• An array is a collection of elements of the same data type stored in contiguous memory locations.
• Array elements are accessed using an index, starting from 0.
• Example: int numbers[5]; declares an integer array named numbers with 5 elements.
• Array initialization: int numbers[5] = {1, 2, 3, 4, 5}; initializes the array elements.
• Multidimensional arrays: Arrays with more than one dimension (e.g., int matrix[3][3];).

Pointers

• A pointer is a variable that stores the memory address of another variable.
• Pointer declaration: int *ptr; declares a pointer to an integer.
• Address-of operator (&): Returns the memory address of a variable (e.g., ptr = &age;).
• Dereference operator (*): Accesses the value stored at the memory address pointed to by a pointer (e.g., int value = *ptr;).
• Pointer arithmetic: Performing arithmetic operations on pointers to navigate memory locations.
• Pointers and arrays: Array names can be used as pointers to the first element of the array.
• Dynamic memory allocation: Using malloc() and calloc() to allocate memory at runtime and free() to release allocated memory.

Strings

• A string is an array of characters terminated by a null character ('\0').
• String manipulation functions are available in the string.h library, such as strcpy(), strcat(), strlen(), and strcmp().
• Example: char name[] = "John"; declares a string variable named name.

Structures

• A structure is a composite data type that groups together variables of different data types under a single name.
• Structure definition: Defines the structure's members.
• Structure declaration: Creates a variable of the structure type.
• Accessing structure members: Using the dot (.) operator to access members of a structure variable.
• Example:

struct Person {
    char name[50];
    int age;
};
struct Person person1;
strcpy(person1.name, "John");
person1.age = 30;

• Pointers to structures: Using pointers to access structure members (e.g., struct Person *ptr = &person1; and ptr->age = 30;).

Unions

• Similar to structures, but all members share the same memory location.
• Useful when only one member needs to be used at a time.
• union keyword is used to define a union.

File I/O

• Functions for reading from and writing to files are available in the stdio.h library.
• fopen(): Opens a file in a specific mode (e.g., "r" for reading, "w" for writing, "a" for appending).
• fclose(): Closes a file.
• fprintf(): Writes formatted output to a file.
• fscanf(): Reads formatted input from a file.
• fgets(): Reads a line from a file.
• fputs(): Writes a string to a file.
• fread(): Reads binary data from a file.
• fwrite(): Writes binary data to a file.

Preprocessor Directives

• Instructions to the preprocessor, which modifies the source code before compilation.
• #include: Includes header files containing function declarations and macro definitions.
• #define: Defines a macro (a symbolic name for a constant or expression).
• #ifdef, #ifndef, #else, #endif: Conditional compilation directives.

Memory Management

• malloc(): Allocates a block of memory on the heap. Takes size in bytes as an argument.
• calloc(): Allocates a block of memory and initializes all bytes to zero. Takes number of elements and size of each element as arguments.
• realloc(): Resizes a previously allocated block of memory.
• free(): Releases dynamically allocated memory back to the system.
• Memory leaks: Occur when dynamically allocated memory is not freed after use, leading to memory exhaustion.

Standard Library Functions

• stdio.h: Input/output functions (e.g., printf(), scanf(), fopen(), fclose()).
• stdlib.h: General utility functions (e.g., malloc(), free(), atoi(), rand()).
• string.h: String manipulation functions (e.g., strcpy(), strcat(), strlen(), strcmp()).
• math.h: Mathematical functions (e.g., sqrt(), pow(), sin(), cos()).
• time.h: Time and date functions (e.g., time(), clock()).

Common Errors

• Syntax errors: Violations of the C language syntax rules.
• Semantic errors: Errors in the meaning of the code (e.g., type mismatches, using an uninitialized variable).
• Runtime errors: Errors that occur during program execution (e.g., division by zero, accessing memory out of bounds).
• Logical errors: Errors in the program's logic, leading to incorrect results.
• Memory leaks: Failure to free dynamically allocated memory.
• Segmentation faults: Attempting to access memory that the program does not have permission to access.

Compilation

• C code is compiled into machine code.
• Compiler: A program that translates C source code into object code.
• Linker: A program that combines object code files and libraries into an executable program.
• GCC (GNU Compiler Collection) is a popular C compiler.
• Compilation process:
  • Preprocessing: Handles preprocessor directives (e.g., #include, #define).
  • Compilation: Translates the preprocessed code into assembly code.
  • Assembly: Converts assembly code into object code.
  • Linking: Combines object code files and libraries into an executable program.