typedef is used to create aliases for data types.

typedef unsigned int uint;

int main() {
    uint x = 10;
    printf("%u\n", x); // Output: 10
    return 0;
}

Enumerations define a set of named constants.

enum Color {
    RED,
    GREEN,
    BLUE
};

int main() {
    enum Color color = GREEN;
    if (color == GREEN) {
        printf("Color is Green\n");
    }
    return 0;
}

Preprocessor directives are instructions to the compiler before actual compilation.
// #define directive for a macro
#define PI 3.14159

// #include directive to include a header file
#include <stdio.h>

// Other preprocessor directives
#ifdef DEBUG
    printf("Debug mode\n");
#else
    printf("Release mode\n");
#endif

File pointers are used to interact with files.

FILE *file = fopen("data.txt", "r");
if (file != NULL) {
    int ch;
    while ((ch = fgetc(file)) != EOF) {
        putchar(ch); // Output: Contents of the file
    }
    fclose(file);
}

C supports both text and binary file handling.

// Writing to a binary file
int data[] = {10, 20, 30, 40, 50};
FILE *binary_file = fopen("data.bin", "wb");
if (binary_file != NULL) {
    fwrite(data, sizeof(int), 5, binary_file);
    fclose(binary_file);
}

// Reading from a binary file
int read_data[5];
binary_file = fopen("data.bin", "rb");
if (binary_file != NULL) {
    fread(read_data, sizeof(int), 5, binary_file);
    fclose(binary_file);
    for (int i = 0; i < 5; i++) {
        printf("%d ", read_data[i]); // Output: 10 20 30 40 50
    }
}
printf("\n");

C provides functions for reading from and writing to files.

// Writing to a file
FILE *file = fopen("data.txt", "w");
if (file != NULL) {
    fprintf(file, "Hello, World!");
    fclose(file);
}

// Reading from a file
char buffer[100];
file = fopen("data.txt", "r");
if (file != NULL) {
    fgets(buffer, 100, file);
    printf("%s\n", buffer); // Output: Hello, World!
    fclose(file);
}

Unions are similar to structures, but they use the same memory location for all their members. Only one member can be active at a time.

union Data {
    int i;
    float f;
    char str[20];
};

int main() {
    union Data data;
    data.i = 10;
    printf("i: %d\n", data.i); // Output: 10

    data.f = 3.14;
    printf("f: %.2f\n", data.f); // Output: 3.14

    strcpy(data.str, "Hello");
    printf("str: %s\n", data.str); // Output: Hello

    printf("Size of union Data: %lu bytes\n", sizeof(data)); // Output: 20 bytes
    return 0;
}

Structures can be nested within each other.

struct Address {
    char city[50];
    char state[50];
};

struct Person {
    char name[50];
    int age;
    struct Address address;
};

int main() {
    struct Person p1;
    strcpy(p1.name, "John");
    p1.age = 30;
    strcpy(p1.address.city, "New York");
    strcpy(p1.address.state, "NY");
    printf("Name: %s, Age: %d, City: %s, State: %s\n", p1.name, p1.age, p1.address.city, p1.address.state);
    return 0;
}

Structures are user-defined data types that allow you to group multiple variables of different data types under a single name.

struct Person {
    char name[50];
    int age;
    float salary;
};

int main() {
    struct Person p1;
    strcpy(p1.name, "John");
    p1.age = 30;
    p1.salary = 50000.0;
    printf("Name: %s, Age: %d, Salary: %.2f\n", p1.name, p1.age, p1.salary);
    return 0;
}

malloc() is used to allocate memory dynamically, and free() is used to release memory when it's no longer needed.

int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL) {
    *ptr = 10;
    printf("Value: %d\n", *ptr); // Output: 10
    free(ptr); // Release memory
}