# Cheatsheet

### 1. Introduction to C Programming

C is a general-purpose programming language developed in the 1970s by Dennis Ritchie. It is widely used for system programming, developing operating systems, embedded systems, and more due to its powerful low-level capabilities.

#### Features of C

* **Simple and Efficient**: Basic and understandable syntax that is easy to write and compile.
* **Low-Level Access**: Provides low-level manipulation of data, which is ideal for system programming.
* **Rich Library Support**: Provides a variety of inbuilt functions.
* **Portable**: Code can be compiled and run on different platforms without modifications.
* **Structured Programming**: Supports modularity through functions and block-structured programming.

#### Basic Structure of a C Program

```c
#include <stdio.h> // Header files

int main() {
    // Statements
    return 0;
}
```

* **Header Files**: Include libraries like `<stdio.h>`, `<stdlib.h>`, etc.
* **Main Function**: The entry point of any C program (`int main()`).
* **Statements**: C statements end with a semicolon (`;`).

### 2. Data Types and Variables

#### Primary Data Types

* **int**: Integer data type (`int age = 20;`).
* **float**: Single-precision floating-point (`float price = 12.99;`).
* **double**: Double-precision floating-point (`double distance = 123.456;`).
* **char**: Character data type (`char letter = 'A';`).

#### Derived Data Types

* **Arrays**: Collection of elements of the same type (`int arr[5] = {1, 2, 3, 4, 5};`).
* **Pointers**: Stores the memory address of another variable (`int *ptr = &age;`).
* **Structures**: Group of variables of different types (`struct { int id; char name[20]; } person;`).
* **Unions**: Like structures but share memory (`union { int i; float f; } u;`).
* **Enums**: Enumeration constants (`enum Days { MON, TUE, WED };`).

#### Variable Declaration

* **Syntax**: `data_type variable_name;`
* **Example**: `int a = 10;`

#### Constants

* Use `const` keyword: `const float PI = 3.14159;`
* Preprocessor Directive: `#define MAX 100`

### 3. Input and Output in C

#### Standard Input/Output Functions

* **printf()**: Used for output.

  ```c
  printf("Hello, %s!\n", name);
  ```
* **scanf()**: Used for input.

  ```c
  scanf("%d", &age);
  ```

  * `%d` for integers
  * `%f` for floats
  * `%c` for characters
  * `%s` for strings

#### Escape Sequences

* : Newline
* : Tab
* **\\**: Backslash
* **"**: Double quote

### 4. Control Flow

#### Conditional Statements

* **if Statement**

  ```c
  if (a > b) {
      printf("a is greater than b\n");
  }
  ```
* **if-else Statement**

  ```c
  if (a > b) {
      printf("a is greater\n");
  } else {
      printf("b is greater\n");
  }
  ```
* **Nested if Statement**

  ```c
  if (a > b) {
      if (a > c) {
          printf("a is largest\n");
      }
  }
  ```
* **else if Ladder**

  ```c
  if (a == 10) {
      // code
  } else if (a == 20) {
      // code
  } else {
      // default code
  }
  ```

#### Switch Case

* **Syntax**

  ```c
  switch (expression) {
      case value1:
          // code
          break;
      case value2:
          // code
          break;
      default:
          // default code
  }
  ```
* Use **break** to prevent fall-through behavior.

#### Looping Statements

* **for Loop**

  ```c
  for (int i = 0; i < 10; i++) {
      printf("%d\n", i);
  }
  ```
* **while Loop**

  ```c
  int i = 0;
  while (i < 10) {
      printf("%d\n", i);
      i++;
  }
  ```
* **do-while Loop**

  ```c
  int i = 0;
  do {
      printf("%d\n", i);
      i++;
  } while (i < 10);
  ```

#### Control Statements

* **break**: Exit the loop.
* **continue**: Skip to the next iteration of the loop.
* **return**: Exit from a function.

### 5. Operators in C

#### Arithmetic Operators

* **Addition (`+`)**: `a + b`
* **Subtraction (`-`)**: `a - b`
* **Multiplication (`*`)**: `a * b`
* **Division (`/`)**: `a / b`
* **Modulus (`%`)**: `a % b`

#### Relational Operators

* **Equal (`==`)**: `a == b`
* **Not Equal (`!=`)**: `a != b`
* **Greater Than (`>`)**: `a > b`
* **Less Than (`<`)**: `a < b`
* **Greater Than or Equal To (`>=`)**: `a >= b`
* **Less Than or Equal To (`<=`)**: `a <= b`

#### Logical Operators

* **AND (`&&`)**: `(a > b) && (a < c)`
* **OR (`||`)**: `(a > b) || (a < c)`
* **NOT (`!`)**: `!(a > b)`

#### Bitwise Operators

* **AND (`&`)**: Bitwise AND
* **OR (`|`)**: Bitwise OR
* **XOR (`^`)**: Bitwise XOR
* **NOT (`~`)**: Bitwise NOT
* **Left Shift (`<<`)**: `a << 1`
* **Right Shift (`>>`)**: `a >> 1`

#### Assignment Operators

* `=`: Assign value to a variable (`a = 5;`)
* `+=`: Add and assign (`a += 5;`)
* `-=`: Subtract and assign (`a -= 5;`)
* `*=`: Multiply and assign (`a *= 5;`)
* `/=`: Divide and assign (`a /= 5;`)
* `%=`: Modulus and assign (`a %= 5;`)

#### Miscellaneous Operators

* **Sizeof**: Returns the size of a data type (`sizeof(int)`)
* **Conditional (Ternary) Operator**: `condition ? value_if_true : value_if_false`

### 6. Functions in C

#### Types of Functions

* **Library Functions**: Predefined functions like `printf()`, `scanf()`, etc.
* **User-defined Functions**: Functions created by the programmer.
* **Recursive Functions**: Functions that call themselves (`factorial()` example).

#### Syntax of a Function

```c
return_type function_name(parameter_list) {
    // Function body
    return value;
}
```

* **Example**

  ```c
  int add(int x, int y) {
      return x + y;
  }
  ```

#### Function Declaration

* **Prototype**: `int add(int, int);`
* **Definition**: Implementation of function.
* **Calling**: `result = add(5, 10);`

#### Passing Arguments

* **Pass by Value**: The actual value is passed.

  ```c
  void func(int x) { x = 10; } // Changes will not reflect in main()
  ```
* **Pass by Reference**: The address is passed.

  ```c
  void func(int *x) { *x = 10; } // Changes will reflect in main()
  ```

#### Recursive Functions

* **Definition**: Functions that call themselves.

  ```c
  int factorial(int n) {
      if (n == 0) return 1;
      return n * factorial(n - 1);
  }
  ```

### 7. Arrays in C

#### Declaring and Initializing Arrays

* **Declaration**: `int arr[10];`
* **Initialization**: `int arr[5] = {1, 2, 3, 4, 5};`
* **Access Elements**: `arr[0] = 10;`

#### Multi-Dimensional Arrays

* **2D Arrays**

  ```c
  int matrix[3][3] = {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 9}
  };
  ```
* **Accessing Elements**: `matrix[1][2]`

#### Array as Function Argument

* **Passing Array to Function**

  ```c
  void printArray(int arr[], int size) {
      for(int i = 0; i < size; i++) {
          printf("%d ", arr[i]);
      }
  }
  ```

### 8. Pointers in C

#### Basics of Pointers

* **Declaration**: `int *ptr;`
* **Assigning Address**: `ptr = &variable;`
* **Dereferencing Pointer**: Access value using `*ptr`

#### Pointer Arithmetic

* **Increment**: `ptr++`
* **Decrement**: `ptr--`

#### Null Pointer

* **Definition**: Points to nothing (`int *ptr = NULL;`)

#### Void Pointer

* **Definition**: Generic pointer (`void *ptr;`)

#### Pointer to Pointer

* **Declaration**: `int **ptr;`

  ```c
  int a = 10;
  int *p = &a;
  int **pp = &p;
  ```

#### Passing Pointers to Functions

* **Example**

  ```c
  void increment(int *n) {
      (*n)++;
  }
  ```

### 9. Strings in C

#### Declaring Strings

* **Character Array**: `char str[20] = "Hello";`
* **Using Pointers**: `char *str = "Hello";`

#### Common String Functions

* **`strlen(str)`**: Get length of a string.
* **`strcpy(dest, src)`**: Copy string.
* **`strcat(str1, str2)`**: Concatenate strings.
* **`strcmp(str1, str2)`**: Compare strings.

#### Reading and Writing Strings

* **Input**

  ```c
  char name[20];
  scanf("%s", name); // Stops at whitespace
  ```
* **Output**

  ```c
  printf("%s", name);
  ```
* **Using `gets()` and `puts()`**

  ```c
  char str[50];
  gets(str); // Reads string with spaces
  puts(str); // Prints string
  ```

### 10. Structures in C

#### Defining a Structure

```c
struct Student {
    char name[50];
    int age;
    float gpa;
};
```

#### Accessing Structure Members

* **Dot Operator**: `student.age = 20;`
* **Pointer to Structure**: `struct Student *ptr = &student; ptr->age = 21;`

#### Nested Structures

* **Definition**: Structures within structures.

  ```c
  struct Address {
      char city[50];
      char state[50];
  };
  struct Person {
      char name[50];
      struct Address address;
  };
  ```

#### Structure as Function Argument

* **Passing by Value**

  ```c
  void printStudent(struct Student s) {
      printf("%s %d %.2f\n", s.name, s.age, s.gpa);
  }
  ```
* **Passing by Reference**

  ```c
  void updateAge(struct Student *s) {
      s->age = 21;
  }
  ```

### 11. Memory Management in C

#### Dynamic Memory Allocation

* **malloc()**: Allocates memory.

  ```c
  int *ptr = (int *)malloc(5 * sizeof(int));
  ```
* **calloc()**: Allocates memory and initializes to zero.

  ```c
  int *ptr = (int *)calloc(5, sizeof(int));
  ```
* **realloc()**: Resizes memory.

  ```c
  ptr = realloc(ptr, 10 * sizeof(int));
  ```
* **free()**: Frees allocated memory.

  ```c
  free(ptr);
  ```

#### Common Errors in Memory Management

* **Memory Leak**: Forgetting to `free()` allocated memory.
* **Dangling Pointer**: Using a pointer after `free()` has been called.
* **Double Free Error**: Calling `free()` on the same pointer twice.

### 12. File Handling in C

#### File Operations

* **Opening a File**

  ```c
  FILE *fptr = fopen("filename.txt", "r");
  ```

  * Modes: `"r"`, `"w"`, `"a"`, `"r+"`, `"w+"`, `"a+"`
* **Closing a File**

  ```c
  fclose(fptr);
  ```

#### Reading/Writing to Files

* **Writing**: `fprintf(fptr, "Hello\n");`
* **Reading**: `fscanf(fptr, "%s", str);`
* **Character Reading/Writing**

  ```c
  char ch = fgetc(fptr);
  fputc('A', fptr);
  ```

#### Random Access in Files

* **fseek()**: Set the file position to a specific location.

  ```c
  fseek(fptr, 0, SEEK_SET); // Move to the beginning of the file
  ```
* **ftell()**: Get the current position in the file.

  ```c
  long pos = ftell(fptr);
  ```
* **rewind()**: Move to the beginning of the file.

  ```c
  rewind(fptr);
  ```

### 13. Preprocessor Directives

#### Common Directives

* **`#define`**: Macro definitions.

  ```c
  #define PI 3.14159
  ```
* **`#include`**: Include a library.

  ```c
  #include <stdio.h>
  ```
* **Conditional Compilation**: `#ifdef`, `#ifndef`, `#endif`

  ```c
  #ifdef DEBUG
  printf("Debugging is enabled\n");
  #endif
  ```

### 14. Debugging and Common Errors

#### Compilation Errors

* **Syntax Errors**: Missing semicolons, unmatched braces.
* **Data Type Mismatch**: Using incorrect format specifiers in `printf()`/`scanf()`.

#### Logical Errors

* **Infinite Loops**: Incorrect loop conditions.
* **Incorrect Arithmetic**: Misplaced parentheses can lead to unexpected results.

#### Debugging Tips

* Use **printf()** to display variable values.
* Use **gdb** (GNU Debugger) for interactive debugging.

#### Common Runtime Errors

* **Segmentation Fault**: Accessing restricted memory (often due to invalid pointers).
* **Stack Overflow**: Excessive memory usage (e.g., too many recursive calls).

### 15. Best Practices in C Programming

* **Comment Your Code**: Use `//` or `/* */` for multi-line comments.
* **Use Meaningful Names**: Variables should have descriptive names.
* **Avoid Global Variables**: They make code harder to debug.
* **Break Down Functions**: Each function should perform one task.
* **Memory Management**: Always `free()` dynamically allocated memory.
* **Code Readability**: Proper indentation and spacing make the code readable.
* **Error Handling**: Always check return values for functions like `malloc()` or `fopen()`.

### 16. Advanced Topics

#### Command-Line Arguments

* **Main Function with Arguments**

  ```c
  int main(int argc, char *argv[]) {
      printf("Number of arguments: %d\n", argc);
      return 0;
  }
  ```

#### typedef

* **Definition**: Create an alias for data types.

  ```c
  typedef unsigned long ulong;
  ulong num = 100000;
  ```

#### Bit Manipulation

* **Bitwise Operations**: `&`, `|`, `^`, `~`, `<<`, `>>`
* **Use Cases**: Efficient storage, cryptography, etc.

#### Function Pointers

* **Definition**: Pointer that points to a function.

  ```c
  void (*funcPtr)(int) = &function_name;
  ```
* **Use Cases**: Callback mechanisms, dynamic function calls.

#### Macros vs. Functions

* **Macros**: `#define SQUARE(x) ((x) * (x))`
* **Functions**: `int square(int x) { return x * x; }`
* **Difference**: Macros are faster but lack type safety.

#### Linked Lists

* **Definition**: A linear data structure where elements are linked using pointers.
* **Node Structure**

  ```c
  struct Node {
      int data;
      struct Node *next;
  };
  ```
* **Basic Operations**: Insertion, Deletion, Traversal

***