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

Was this helpful?