# C Programming Language Cheatsheet

## Program Structure

```c
#include <stdio.h>  // Include standard I/O library

// Function prototype declaration
void myFunction(int param);

// Global variables
int globalVar = 10;

// Main function - program entry point
int main() {
    // Code statements
    printf("Hello, World!\n");
    
    return 0; // Return value to OS (0 = success)
}

// Function definition
void myFunction(int param) {
    // Function body
}
```

## Data Types

| Type | Description | Format Specifier | Example |
|------|-------------|------------------|---------|
| `int` | Integer | `%d` or `%i` | `int x = 10;` |
| `float` | Single-precision floating point | `%f` | `float y = 10.5f;` |
| `double` | Double-precision floating point | `%lf` | `double z = 10.5;` |
| `char` | Single character | `%c` | `char c = 'A';` |
| `char[]` | String (character array) | `%s` | `char str[] = "hello";` |
| `short` | Short integer | `%hd` | `short s = 10;` |
| `long` | Long integer | `%ld` | `long l = 10L;` |
| `long long` | Long long integer | `%lld` | `long long ll = 10LL;` |
| `unsigned int` | Unsigned integer | `%u` | `unsigned int ui = 10u;` |
| `unsigned char` | Unsigned character | `%c` | `unsigned char uc = 255;` |
| `size_t` | Size type (for sizes) | `%zu` | `size_t size = sizeof(int);` |

## Variable Declaration

```c
// Basic declaration
int a;           // Declaration
int b = 10;      // Declaration with initialization
const int MAX = 100;  // Constant (cannot be modified)

// Multiple variables
int x, y, z;
int p = 1, q = 2, r = 3;

// Type modifiers
unsigned int positive;  // Only non-negative values
signed int withSign;    // Can be positive or negative
long int bigNumber;     // Larger range of values
short int smallNumber;  // Smaller range of values
```

## Operators

### Arithmetic Operators

| Operator | Description | Example | Result |
|----------|-------------|---------|--------|
| `+` | Addition | `a + b` | `13` |
| `-` | Subtraction | `a - b` | `7` |
| `*` | Multiplication | `a * b` | `30` |
| `/` | Division | `a / b` | `3` (integer division) |
| `%` | Modulus (remainder) | `a % b` | `1` |
| `-` | Negation | `-a` | `-10` |
| `++` | Increment | `a++` | `a` becomes `11` |
| `--` | Decrement | `b--` | `b` becomes `2` |

### Comparison Operators

| Operator | Description | Example |
|----------|-------------|---------|
| `==` | Equal to | `a == b` |
| `!=` | Not equal to | `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

| Operator | Description | Example |
|----------|-------------|---------|
| `&&` | Logical AND | `a && b` |
| `\|\|` | Logical OR | `a \|\| b` |
| `!` | Logical NOT | `!a` |

### Bitwise Operators

| Operator | Description | Example | Notes |
|----------|-------------|---------|-------|
| `&` | Bitwise AND | `a & b` | |
| `\|` | Bitwise OR | `a \| b` | |
| `^` | Bitwise XOR | `a ^ b` | |
| `~` | Bitwise NOT | `~a` | |
| `<<` | Left shift | `a << 2` | Multiply by 2² |
| `>>` | Right shift | `a >> 2` | Divide by 2² |

### Assignment Operators

| Operator | Description | Equivalent |
|----------|-------------|------------|
| `=` | Simple assignment | `a = b` |
| `+=` | Add and assign | `a = a + b` |
| `-=` | Subtract and assign | `a = a - b` |
| `*=` | Multiply and assign | `a = a * b` |
| `/=` | Divide and assign | `a = a / b` |
| `%=` | Modulus and assign | `a = a % b` |
| `&=` | Bitwise AND and assign | `a = a & b` |
| `\|=` | Bitwise OR and assign | `a = a \| b` |
| `^=` | Bitwise XOR and assign | `a = a ^ b` |
| `<<=` | Left shift and assign | `a = a << b` |
| `>>=` | Right shift and assign | `a = a >> b` |

## Control Structures

### Conditional Statements

| Statement | Syntax | Description |
|-----------|--------|-------------|
| If | `if (condition) { statements }` | Executes statements if condition is true |
| If-else | `if (condition) { statements1 } else { statements2 }` | Executes statements1 if condition is true, otherwise statements2 |
| If-else if-else | `if (condition1) { statementsA } else if (condition2) { statementsB } else { statementsC }` | Tests multiple conditions in sequence |
| Ternary operator | `result = (condition) ? valueIfTrue : valueIfFalse;` | Shorthand for simple if-else assignment |
| Switch | `switch (expression) { case value1: statements1; break; case value2: statements2; break; default: statementsDefault; }` | Multi-way branch based on expression value |

### Switch Statement Example

```c
switch (grade) {
    case 'A':
        printf("Excellent!\n");
        break;
    case 'B':
        printf("Good job!\n");
        break;
    case 'C':
        printf("Average performance.\n");
        break;
    default:
        printf("Need improvement.\n");
}
```

### Loops

| Loop Type | Syntax | Description |
|-----------|--------|-------------|
| For | `for (initialization; condition; update) { statements }` | Repeats statements while condition is true, with initialization before first iteration and update after each iteration |
| While | `while (condition) { statements }` | Repeats statements while condition is true |
| Do-while | `do { statements } while (condition);` | Executes statements at least once, then repeats while condition is true |

### Loop Control

| Statement | Description |
|-----------|-------------|
| `break;` | Exits the innermost loop or switch |
| `continue;` | Skips to the next iteration of the loop |

## Arrays

```c
// Declaration and initialization
int numbers[5];              // Uninitialized array of 5 integers
int scores[5] = {90, 85, 88, 92, 76};  // Initialized array
int partial[5] = {90, 85};   // Remaining elements initialized to 0
int auto_size[] = {1, 2, 3}; // Size determined automatically (3)

// Accessing elements (0-indexed)
int first = scores[0];       // 90
scores[4] = 95;              // Modify element

// Multidimensional arrays
int matrix[3][4];            // 3×4 matrix (3 rows, 4 columns)
int grid[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
int value = grid[1][0];      // 4 (row 1, column 0)
```

## Strings

```c
// String declaration and initialization
char greeting[] = "Hello";  // Includes null terminator '\0' automatically
char name[10] = "John";     // Array size should be at least string length + 1
char empty[10] = "";        // Empty string

// Accessing characters
char first = name[0];       // 'J'
name[0] = 'j';              // Modify character

// Common string functions (include <string.h>)
strlen(str);       // String length (excludes null terminator)
strcpy(dest, src); // Copy string src to dest
strcat(dest, src); // Concatenate src to the end of dest
strcmp(s1, s2);    // Compare strings (0 if equal, <0 if s1<s2, >0 if s1>s2)
strchr(str, ch);   // Find first occurrence of character ch in str
strstr(str, sub);  // Find first occurrence of substring sub in str
```

## Pointers

```c
// Declaration and initialization
int x = 10;
int *ptr = &x;  // ptr contains the memory address of x

// Dereferencing (accessing the value at the address)
int value = *ptr;  // value = 10

// Pointer arithmetic
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;      // p points to the first element of arr
int second = *(p + 1);  // 20 (second element)

// Null pointer
int *nullPtr = NULL;  // Points to nothing (always check before dereferencing)

// Pointers and arrays
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;  // Points to first element
// These are equivalent:
int val1 = arr[2];
int val2 = *(arr + 2);
int val3 = ptr[2];
int val4 = *(ptr + 2);
```

## Functions

### Function Syntax

| Component | Syntax | Description |
|-----------|--------|-------------|
| Declaration | `return_type function_name(parameter_type param1, ...);` | Function prototype (declares the function) |
| Definition | `return_type function_name(parameter_type param1, ...) { statements }` | Actual function code |
| Call | `function_name(argument1, argument2, ...);` | Invoking the function |
| Return | `return value;` | Exit function and return a value (if not void) |

### Function Types and Examples

| Function Type | Example | Description |
|---------------|---------|-------------|
| With return value | `int add(int a, int b) { return a + b; }` | Returns calculated result |
| Without return value | `void printMessage(const char *msg) { printf("%s\n", msg); }` | Performs action, returns nothing |
| Pass by value | `void increment(int x) { x++; }` | Changes only affect local copy |
| Pass by reference | `void increment(int *x) { (*x)++; }` | Changes affect original variable |
| Recursive | `int factorial(int n) { if (n <= 1) return 1; return n * factorial(n-1); }` | Function calls itself |

### Parameter Passing

| Method | Example Call | Effect on Original |
|--------|--------------|-------------------|
| By value | `increment(num);` | No change to original |
| By reference | `increment(&num);` | Original can be modified |
| Array | `process(array);` | Original array can be modified |
| Const reference | `display(const int *arr, int size);` | Prevents modification of original |

```c
// Example of function usage
int num = 5;
incrementByValue(num);      // num remains 5
incrementByReference(&num); // num becomes 6
```

## Structures

```c
// Structure definition
struct Person {
    char name[50];
    int age;
    float height;
};

// Declaration and initialization
struct Person person1;
struct Person person2 = {"John", 25, 1.75};

// Accessing members
strcpy(person1.name, "Jane");
person1.age = 22;
person1.height = 1.65;

// Structure pointer
struct Person *ptr = &person1;
printf("%s\n", ptr->name);  // Arrow operator for pointer access
// Equivalent to: printf("%s\n", (*ptr).name);

// Typedef for simpler naming
typedef struct {
    char title[100];
    char author[50];
    int year;
} Book;

Book novel = {"The Great Gatsby", "F. Scott Fitzgerald", 1925};
```

## Memory Management

```c
// Dynamic memory allocation (include <stdlib.h>)
int *ptr = malloc(5 * sizeof(int));  // Allocate memory for 5 integers
if (ptr == NULL) {
    // Allocation failed
}

// Initialize allocated memory
memset(ptr, 0, 5 * sizeof(int));  // Set all bytes to 0 (include <string.h>)

// Reallocation
ptr = realloc(ptr, 10 * sizeof(int));  // Resize to 10 integers

// Free allocated memory (prevent memory leaks)
free(ptr);
ptr = NULL;  // Good practice to avoid dangling pointers
```

## File I/O

### File Operations

| Operation | Function | Description |
|-----------|----------|-------------|
| Open | `FILE *file = fopen(filename, mode);` | Open a file with specified mode |
| Close | `fclose(file);` | Close a file and flush buffers |
| Check EOF | `feof(file)` | Check if end-of-file is reached |
| Get error | `ferror(file)` | Check if an error occurred |
| Flush | `fflush(file)` | Flush output buffer |
| Reposition | `fseek(file, offset, origin)` | Move file position indicator |
| Get position | `ftell(file)` | Get current file position |
| Rewind | `rewind(file)` | Set position to beginning of file |

### File Open Modes

| Mode | Description |
|------|-------------|
| `"r"` | Read (file must exist) |
| `"w"` | Write (create new or truncate existing) |
| `"a"` | Append (create new or append to existing) |
| `"r+"` | Read and write (file must exist) |
| `"w+"` | Read and write (create new or truncate existing) |
| `"a+"` | Read and append (create new or append to existing) |
| `"b"` | Binary mode (add to modes above, e.g., `"rb"`, `"wb"`) |

### Text File I/O

| Operation | Function | Description |
|-----------|----------|-------------|
| Read formatted | `fscanf(file, format, ...)` | Read formatted data |
| Write formatted | `fprintf(file, format, ...)` | Write formatted data |
| Read line | `fgets(buffer, size, file)` | Read a line of text |
| Write string | `fputs(string, file)` | Write a string |
| Read character | `fgetc(file)` or `getc(file)` | Read a character |
| Write character | `fputc(c, file)` or `putc(c, file)` | Write a character |

### Binary File I/O

| Operation | Function | Description |
|-----------|----------|-------------|
| Read | `fread(buffer, size, count, file)` | Read binary data |
| Write | `fwrite(buffer, size, count, file)` | Write binary data |

### Example

```c
// Writing to a text file
FILE *file = fopen("data.txt", "w");
if (file == NULL) {
    perror("Error opening file");
    return 1;
}
fprintf(file, "Name: %s, Age: %d\n", "John", 25);
fclose(file);

// Reading from a text file
char name[50];
int age;
file = fopen("data.txt", "r");
if (file != NULL) {
    fscanf(file, "Name: %s, Age: %d", name, &age);
    fclose(file);
}
```

## Preprocessor Directives

### Basic Preprocessor Directives

| Directive | Syntax | Description |
|-----------|--------|-------------|
| Include | `#include <filename>` | Include system header file |
| Include | `#include "filename"` | Include local header file |
| Define | `#define NAME value` | Define a macro constant |
| Define function | `#define NAME(params) expression` | Define a function-like macro |
| Undefine | `#undef NAME` | Remove a macro definition |
| Error | `#error message` | Force compilation error with message |
| Pragma | `#pragma token` | Implementation-specific instructions |

### Conditional Compilation

| Directive | Syntax | Description |
|-----------|--------|-------------|
| If defined | `#ifdef SYMBOL` | True if SYMBOL is defined |
| If not defined | `#ifndef SYMBOL` | True if SYMBOL is not defined |
| If expression | `#if EXPRESSION` | True if EXPRESSION is non-zero |
| Else if | `#elif EXPRESSION` | Alternative condition |
| Else | `#else` | Default condition |
| End if | `#endif` | End conditional block |

### Predefined Macros

| Macro | Description |
|-------|-------------|
| `__FILE__` | Current source filename (string) |
| `__LINE__` | Current line number (integer) |
| `__DATE__` | Compilation date (string) |
| `__TIME__` | Compilation time (string) |
| `__STDC__` | 1 if compiler conforms to ANSI C |
| `__cplusplus` | Defined when compiled with C++ compiler |
| `__func__` | Current function name (string) |

### Macro Examples

```c
// Simple constant macro
#define PI 3.14159

// Function-like macro with arguments
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// Stringification operator (#)
#define STRINGIFY(x) #x
// Usage: STRINGIFY(hello) becomes "hello"

// Token concatenation operator (##)
#define CONCAT(a, b) a##b
// Usage: CONCAT(num, 123) becomes num123
```

## Error Handling

```c
// Error handling with return values
if (function() == -1) {
    // Handle error
}

// Using errno (include <errno.h>)
#include <errno.h>
if (func() == -1) {
    printf("Error: %d\n", errno);
    perror("Error message");  // Print error message based on errno
}

// Exit program (include <stdlib.h>)
exit(EXIT_SUCCESS);  // Normal termination
exit(EXIT_FAILURE);  // Error termination
```

## Command Line Arguments

```c
int main(int argc, char *argv[]) {
    // argc: Number of arguments (including program name)
    // argv: Array of argument strings
    
    printf("Program name: %s\n", argv[0]);
    
    for (int i = 1; i < argc; i++) {
        printf("Argument %d: %s\n", i, argv[i]);
    }
    
    return 0;
}
```

## Common Library Functions

### Standard I/O (stdio.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `printf` | `printf("Format", args...);` | Formatted output to stdout |
| `scanf` | `scanf("%d", &variable);` | Formatted input from stdin |
| `puts` | `puts("string");` | Output string with newline |
| `gets` | `gets(string);` | Input string (unsafe, avoid using) |
| `putchar` | `putchar('c');` | Output character |
| `getchar` | `getchar();` | Input character |
| `fprintf` | `fprintf(file, "Format", args);` | Formatted output to file |
| `fscanf` | `fscanf(file, "%d", &var);` | Formatted input from file |
| `fgets` | `fgets(str, size, file);` | Input line from file (safe) |
| `sprintf` | `sprintf(str, "Format", args);` | Formatted output to string |

### String Handling (string.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `strlen` | `strlen(str);` | String length |
| `strcpy` | `strcpy(dest, src);` | String copy |
| `strncpy` | `strncpy(dest, src, n);` | Copy up to n characters |
| `strcat` | `strcat(dest, src);` | String concatenation |
| `strncat` | `strncat(dest, src, n);` | Concatenate up to n characters |
| `strcmp` | `strcmp(s1, s2);` | String comparison |
| `strncmp` | `strncmp(s1, s2, n);` | Compare up to n characters |
| `strchr` | `strchr(str, c);` | Find character in string |
| `strstr` | `strstr(str, substr);` | Find substring in string |
| `strtok` | `strtok(str, delim);` | Tokenize string |

### Memory Functions (string.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `memcpy` | `memcpy(dest, src, n);` | Memory copy |
| `memmove` | `memmove(dest, src, n);` | Safe memory copy (handles overlap) |
| `memset` | `memset(ptr, value, n);` | Fill memory with value |
| `memcmp` | `memcmp(ptr1, ptr2, n);` | Compare memory blocks |

### Math Functions (math.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `sqrt` | `sqrt(x);` | Square root |
| `pow` | `pow(x, y);` | x raised to power y |
| `ceil` | `ceil(x);` | Round up to integer |
| `floor` | `floor(x);` | Round down to integer |
| `round` | `round(x);` | Round to nearest integer |
| `fabs` | `fabs(x);` | Absolute value (float) |
| `sin`, `cos`, `tan` | `sin(x);` | Trigonometric functions |
| `asin`, `acos`, `atan` | `asin(x);` | Inverse trigonometric functions |
| `log`, `log10` | `log(x);` | Natural and base-10 logarithms |
| `exp` | `exp(x);` | e raised to power x |

### Character Functions (ctype.h)

| Function | Syntax | Returns true if character is... |
|----------|--------|--------------------------------|
| `isalpha` | `isalpha(c);` | Alphabetic (a-z, A-Z) |
| `isdigit` | `isdigit(c);` | Decimal digit (0-9) |
| `isalnum` | `isalnum(c);` | Alphanumeric (a-z, A-Z, 0-9) |
| `isspace` | `isspace(c);` | Whitespace (space, tab, newline, etc.) |
| `islower` | `islower(c);` | Lowercase (a-z) |
| `isupper` | `isupper(c);` | Uppercase (A-Z) |
| `tolower` | `tolower(c);` | Convert to lowercase |
| `toupper` | `toupper(c);` | Convert to uppercase |

### Memory Management (stdlib.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `malloc` | `malloc(size);` | Allocate memory |
| `calloc` | `calloc(n, size);` | Allocate and zero memory |
| `realloc` | `realloc(ptr, size);` | Resize memory allocation |
| `free` | `free(ptr);` | Free allocated memory |

### Other Utility Functions (stdlib.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `atoi` | `atoi(str);` | Convert string to int |
| `atof` | `atof(str);` | Convert string to double |
| `rand` | `rand();` | Generate random number |
| `srand` | `srand(seed);` | Seed random number generator |
| `qsort` | `qsort(arr, n, size, cmp);` | Sort array |
| `bsearch` | `bsearch(key, arr, n, size, cmp);` | Binary search |
| `exit` | `exit(status);` | Terminate program |
| `abs` | `abs(n);` | Integer absolute value |

### Time Functions (time.h)

| Function | Syntax | Description |
|----------|--------|-------------|
| `time` | `time(NULL);` | Current time (seconds since epoch) |
| `clock` | `clock();` | Processor time used |
| `difftime` | `difftime(time2, time1);` | Time difference in seconds |
| `localtime` | `localtime(&time_t);` | Convert to local time struct |
| `strftime` | `strftime(str, size, format, tm);` | Format time as string |