Cheatsheet

the shortcut one shouldnt prefer

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

#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.
```
printf("Hello, %s!\n", name);
```
scanf(): Used for input.
```
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

if (a > b) {
    printf("a is greater than b\n");
}

if-else Statement

if (a > b) {
    printf("a is greater\n");
} else {
    printf("b is greater\n");
}

Nested if Statement

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

else if Ladder

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

Switch Case

Syntax

switch (expression) {
    case value1:
        // code
        break;
    case value2:
        // code
        break;
    default:
        // default code
}

Use break to prevent fall-through behavior.

Looping Statements

for Loop

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

while Loop

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

do-while Loop

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

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

Example

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.

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

Pass by Reference: The address is passed.

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

Recursive Functions

Definition: Functions that call themselves.

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

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

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;
```
int a = 10;
int *p = &a;
int **pp = &p;
```

Passing Pointers to Functions

Example
```
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

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

Output
```
printf("%s", name);
```

Using gets() and puts()

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

10. Structures in C

Defining a Structure

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.

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

Structure as Function Argument

Passing by Value

void printStudent(struct Student s) {
    printf("%s %d %.2f\n", s.name, s.age, s.gpa);
}

Passing by Reference

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

11. Memory Management in C

Dynamic Memory Allocation

malloc(): Allocates memory.

int *ptr = (int *)malloc(5 * sizeof(int));

calloc(): Allocates memory and initializes to zero.
```
int *ptr = (int *)calloc(5, sizeof(int));
```
realloc(): Resizes memory.
```
ptr = realloc(ptr, 10 * sizeof(int));
```
free(): Frees allocated memory.
```
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
```
FILE *fptr = fopen("filename.txt", "r");
```
- Modes: "r", "w", "a", "r+", "w+", "a+"
Closing a File
```
fclose(fptr);
```

Reading/Writing to Files

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

Character Reading/Writing

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

Random Access in Files

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

fseek(fptr, 0, SEEK_SET); // Move to the beginning of the file

ftell(): Get the current position in the file.
```
long pos = ftell(fptr);
```
rewind(): Move to the beginning of the file.
```
rewind(fptr);
```

13. Preprocessor Directives

Common Directives

#define: Macro definitions.
```
#define PI 3.14159
```
#include: Include a library.
```
#include <stdio.h>
```

Conditional Compilation: #ifdef, #ifndef, #endif

#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

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

typedef

Definition: Create an alias for data types.

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.
```
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

struct Node {
    int data;
    struct Node *next;
};

Basic Operations: Insertion, Deletion, Traversal

PreviousPractices

Last updated 1 year ago

hashtag1. Introduction to C Programming

hashtagFeatures of C

hashtagBasic Structure of a C Program

hashtag2. Data Types and Variables

hashtagPrimary Data Types

hashtagDerived Data Types

hashtagVariable Declaration

hashtagConstants

hashtag3. Input and Output in C

hashtagStandard Input/Output Functions

hashtagEscape Sequences

hashtag4. Control Flow

hashtagConditional Statements

hashtagSwitch Case

hashtagLooping Statements

hashtagControl Statements

hashtag5. Operators in C

hashtagArithmetic Operators

hashtagRelational Operators

hashtagLogical Operators

hashtagBitwise Operators

hashtagAssignment Operators

hashtagMiscellaneous Operators

hashtag6. Functions in C

hashtagTypes of Functions

hashtagSyntax of a Function

hashtagFunction Declaration

hashtagPassing Arguments

hashtagRecursive Functions

hashtag7. Arrays in C

hashtagDeclaring and Initializing Arrays

hashtagMulti-Dimensional Arrays

hashtagArray as Function Argument

hashtag8. Pointers in C

hashtagBasics of Pointers

hashtagPointer Arithmetic

hashtagNull Pointer

hashtagVoid Pointer

hashtagPointer to Pointer

hashtagPassing Pointers to Functions

hashtag9. Strings in C

hashtagDeclaring Strings

hashtagCommon String Functions

hashtagReading and Writing Strings

hashtag10. Structures in C

hashtagDefining a Structure

hashtagAccessing Structure Members

hashtagNested Structures

hashtagStructure as Function Argument

hashtag11. Memory Management in C

hashtagDynamic Memory Allocation

hashtagCommon Errors in Memory Management

hashtag12. File Handling in C

hashtagFile Operations

hashtagReading/Writing to Files

hashtagRandom Access in Files

hashtag13. Preprocessor Directives

hashtagCommon Directives

hashtag14. Debugging and Common Errors

hashtagCompilation Errors

hashtagLogical Errors

hashtagDebugging Tips

hashtagCommon Runtime Errors

hashtag15. Best Practices in C Programming

hashtag16. Advanced Topics

hashtagCommand-Line Arguments

hashtagtypedef

hashtagBit Manipulation

hashtagFunction Pointers

hashtagMacros vs. Functions

hashtagLinked Lists