Introduction to C Programming

• C is a general-purpose programming language initially developed by Dennis Ritchie at Bell Labs between 1969 and 1973.
• Widely used due to its efficiency, flexibility, and portability.
• C has significantly influenced other popular programming languages, such as C++, Java, and C#.
• C is a compiled language, so the source code is translated into machine code before execution.

Key Features of C

• C is a procedural language that focuses on dividing a program into functions, otherwise known as procedures or subroutines.
• C provides low-level access to memory through pointers, allowing direct manipulation of hardware resources.
• C code can be compiled and run on various platforms with minimal changes, which enhances its portability.
• C allows for efficient code execution due to its direct memory manipulation and minimal runtime overhead.
• C supports modular programming, where code is organized into reusable functions and modules.
• C has a standard library that provides functions for input/output, string manipulation, and other common tasks.

Basic Structure of a C Program

• Include header files using the #include directive to access predefined functions and data types.
• The main function (int main()) is the entry point of the program.
• Declare variables to store data.
• Write statements to perform operations, control program flow, and interact with the user.
• The main function typically returns an integer value to the operating system to indicate the program's exit status.

Variables and Data Types

• Variables store data values.
• Basic data types in C:
  • int: Integer numbers
  • float: Floating-point numbers
  • double: Double-precision floating-point numbers
  • char: Single characters
  • void: Represents the absence of a type
• Data type modifiers:
  • short: Reduces the amount of storage allocated to the variable
  • long: Increases the amount of storage allocated to the variable
  • signed: Variable can store both positive and negative values
  • unsigned: Variable can only store non-negative values
• Variables must be declared before use, specifying their data type and name.
• Variables can be initialized when declared or later in the program.

Operators

• Arithmetic Operators: Perform basic arithmetic operations (+, -, *, /, %).
• Relational Operators: Compare two values (==, !=, >, =, - right shift).
• Special Operators: sizeof returns the size of a variable or data type in bytes; the comma operator evaluates two expressions and returns the result of the second expression; pointer operators such as & gives the address of, and * will dereference.

Input and Output

• Use functions from the stdio.h header for input and output operations.
• printf() prints formatted output to the console.
• scanf() reads formatted input from the console.
• Common format specifiers include:
  • %d: Integer
  • %f: Float
  • %lf: Double
  • %c: Character
  • %s: String

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 the condition is false.
  • if-else if-else statement: Tests multiple conditions in sequence.
  • switch statement: Selects one of several code blocks to execute based on the value of a variable.
• Loops:
  • for loop: Repeats a block of code a specified 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 loop or switch statement.
• continue statement: Skips the current iteration of the loop and proceeds to the next iteration.
• goto statement: Transfers control to a labeled statement (generally discouraged due to potential for creating unstructured code).

Functions

• Functions perform a specific task.
• Function Declaration: Specifies the function's name, return type, and parameters.
• Function Definition: Contains the actual code that the function executes.
• Function Call: Executes the function.
• Return Value: A function can return a value to the caller using the return statement.
• Function Parameters: Values passed to the function when it is called.
• Types of Functions:
  • Standard Library Functions: Predefined functions provided by the C standard library (e.g., printf(), scanf()).
  • User-Defined Functions: Functions created by the programmer.
• Recursion: A function can call itself.

Arrays

• Arrays are a collection of elements of the same data type stored in contiguous memory locations.
• Declaration: Specify the data type and the number of elements in the array.
• Initialization: Array elements can be initialized when declared or later in the program.
• Accessing Elements: Use the index to access individual elements of the array (index starts at 0).
• Types of Arrays:
  • One-Dimensional Arrays: A single row of elements.
  • Multi-Dimensional Arrays: Arrays with multiple rows and columns (e.g., 2D arrays for matrices).

Pointers

• Pointers store the memory address of another variable.
• Declaration: Specify the data type of the variable that the pointer will point to.
• Initialization: Initialize the pointer with the address of a variable using the & operator.
• Dereferencing: Access the value stored at the memory address pointed to by the pointer using the * operator.
• Pointer Arithmetic: Perform arithmetic operations on pointers to move them to different memory locations.
• Pointers and Arrays: Array names are treated as pointers to the first element of the array.
• Dynamic Memory Allocation: Use functions like malloc() and calloc() to allocate memory dynamically at runtime.
• Freeing Memory: Use the free() function to release dynamically allocated memory.

Strings

• Strings are an array of characters terminated by a null character (\0).
• String Literals: Strings enclosed in double quotes.
• String Functions: Use functions from the string.h header to manipulate strings (e.g., strlen(), strcpy(), strcat(), strcmp()).

Structures

• Structures are a user-defined data type that groups together variables of different data types.
• Declaration: Define the structure using the struct keyword, specifying the members (variables) of the structure.
• Accessing Members: Use the dot operator . to access individual members of the structure.
• Structure Pointers: Use pointers to access structure members using the arrow operator ->.
• Nested Structures: Structures can be nested within other structures.

Unions

• Unions are a user-defined data type that can store different data types in the same memory location.
• Only one member of a union can be used at a time.
• Declaration: Define the union using the union keyword, specifying the members.
• Accessing Members: Use the dot operator . to access union members.

File I/O

• Use functions from the stdio.h header to perform file input/output operations.
• File Handling Functions:
  • fopen(): Opens a file.
  • fclose(): Closes a file.
  • fprintf(): Writes formatted output to a file.
  • fscanf(): Reads formatted input from a file.
  • fgetc(): Reads a single character from a file.
  • fputc(): Writes a single character to a file.
  • fgets(): Reads a line from a file.
  • fputs(): Writes a string to a file.
  • fread(): Reads a block of data from a file.
  • fwrite(): Writes a block of data to a file.
  • fseek(): Moves the file pointer to a specified position.
  • ftell(): Returns the current position of the file pointer.
  • rewind(): Resets the file pointer to the beginning of the file.
• File Modes: Specify the mode in which the file is opened (e.g., "r" for read, "w" for write, "a" for append).

Preprocessor Directives

• Preprocessor directives are commands that are processed by the C preprocessor before compilation.
• #include: Includes header files.
• #define: Defines macros (textual substitutions).
• #ifdef, #ifndef, #endif: Conditional compilation directives.
• #undef: Undefines a macro.

Memory Management

• Static Memory Allocation: Memory is allocated at compile time.
• Dynamic Memory Allocation: Memory is allocated at runtime using functions like malloc() and calloc().
• Memory Leaks: Occur when dynamically allocated memory is not freed.
• Dangling Pointers: Pointers that point to memory locations that have been freed.

Learn the basics of C, a general-purpose programming language developed by Dennis Ritchie at Bell Labs. Known for its efficiency, flexibility, and portability, C has influenced many other languages. It is a compiled language that provides low-level access to memory and supports modular programming.