C Language Study Notes: Data Types & Structures

Basic Data Types:
- int: Integer type, typically 4 bytes.
- float: Single-precision floating point, typically 4 bytes.
- double: Double-precision floating point, typically 8 bytes.
- char: Character type, typically 1 byte.
Derived Data Types:
- Arrays: Collection of elements of the same type (e.g., int arr[10];).
- Structures: User-defined type that groups variables (e.g., struct Person { char name[50]; int age; };).
- Unions: Similar to structures but share memory (e.g., union Data { int i; float f; char c; };).
- Pointers: Variables that store memory addresses (e.g., int *ptr;).
Enumeration: User-defined type consisting of a set of named integer constants (e.g., enum Color { RED, GREEN, BLUE };).

Conditional Statements:
- if: Executes a block if the condition is true.
- else: Executes a block if the if condition is false.
- else if: Allows multiple conditions.
- switch: Selects a block of code to execute based on the value of a variable.
Loops:
- for: Repeats a block a set number of times.
- while: Repeats a block as long as a condition is true.
- do while: Executes a block at least once, then repeats based on a condition.
Control Flow Modifiers:
- break: Exits from the nearest loop or switch statement.
- continue: Skips the current iteration of a loop and continues with the next iteration.
- goto: Jumps to a labeled statement (generally discouraged due to readability issues).

Function Definition:
- Structure: return_type function_name(parameter_type1 parameter_name1, parameter_type2 parameter_name2) { /* code */ }
- Example: int add(int a, int b) { return a + b; }
Function Declaration: Specifies the function's return type and parameters without the body (e.g., int add(int, int);).
Function Prototype: A declaration placed before the main function to inform the compiler about the function's existence.
Scope and Lifetime:
- Local Variables: Declared within a function, not accessible outside.
- Global Variables: Declared outside any function, accessible from any function.
Recursion: A function that calls itself to solve smaller instances of the same problem. Must have a base case to terminate.
Parameter Passing:
- By Value: Copies the actual value (changes in the function do not affect the original).
- By Reference: Passes the address (changes in the function affect the original). Achieved using pointers.

Basic Data Types:
- int: Represents integers, typically occupies 4 bytes.
- float: Represents single-precision floating-point numbers, typically occupies 4 bytes.
- double: Used for double-precision floating-point numbers, typically occupies 8 bytes.
- char: For character representation, typically occupies 1 byte.
Derived Data Types:
- Arrays: A collection of elements all of the same type, e.g., int arr[10];.
- Structures: Custom data types that group different variables, e.g., struct Person { char name[20]; int age; };.
- Unions: Similar to structures but allocate a single shared memory space, e.g., union Data { int i; float f; char c; };.
- Pointers: Variables that hold the memory address of another variable, e.g., int *ptr;.
- Enumeration: A user-defined type that consists of a set of named constants, e.g., enum Color { RED, GREEN, BLUE };.

Conditional Statements:
- if: Executes a code block if the condition evaluates to true.
- else: Followed by a code block executed if the if condition is false.
- else if: Allows checking multiple conditions sequentially.
- switch: Facilitates selection of a block of code based on a variable's value.
Loops:
- for: Repeats a block of code a predetermined number of times.
- while: Continues executing a block as long as a specified condition is true.
- do while: Ensures the code block executes at least once before evaluating the condition for further repetitions.
Control Flow Modifiers:
- break: Exits the nearest enclosing loop or switch statement.
- continue: Skips the current iteration of a loop and proceeds with the next iteration.
- goto: Transfers control to a labeled statement, though usage is generally discouraged due to potential readability issues.

Function Definition:
- Structure is defined as return_type function_name(parameter_type1 parameter_name1, parameter_type2 parameter_name2) { /* function body */ }.
- Example: int add(int a, int b) { return a + b; } defines a simple addition function.
Function Declaration: Involves stating the return type and parameter types without providing the body, e.g., int add(int, int);.
Function Prototype: A declaration that informs the compiler about a function's existence, typically placed before its use in the main function.
Scope and Lifetime:
- Local Variables: Variables declared within a function, inaccessible outside of it.
- Global Variables: Declared outside any function, accessible throughout the program.
- Recursion: A function that calls itself to solve smaller subproblems, requiring a base case to prevent infinite loops.
Parameter Passing:
- By Value: Copies the actual value into the function's parameter; changes do not affect the original variable.
- By Reference: Passes the address of the variable; changes made within the function can affect the original variable. Implemented using pointers.