Merge pull request #3753 from sivaprasath2004/sivaprasath-closes-issue-3715

[Feature]: Add C Language Course

Author: ajay-dhangar

courses/C/_category_.json

@@ -0,0 +1,8 @@
+{
+    "label": "C Language",
+    "position": 11,
+    "link": {
+      "type": "generated-index",
+      "description": "Learn C Language."
+    }
+  }

courses/C/advance-level/Advance-File-Handling/File-Locking.md

@@ -0,0 +1,191 @@
+---
+id: lesson-1
+title: "Advanced File Handling in C"
+sidebar_label: Advanced File Handling
+sidebar_position: 1
+description: "Learn Advanced File Handling in C"
+tags: [courses,Advance-level,Introduction]
+---  
+  
+
+Advanced file handling techniques are essential for optimizing performance, ensuring data integrity, and working efficiently with large files. Here’s a detailed overview of advanced file handling topics in C:
+
+#### 1. File Locking Mechanisms
+
+File locking is used to control access to files when multiple processes or threads are involved. It helps in preventing data corruption or inconsistency.
+
+- **Types of Locks**:
+  - **Exclusive Lock**: Prevents other processes from reading or writing the file.
+  - **Shared Lock**: Allows other processes to read the file but not write to it.
+
+- **Using `flock()`**:
+  - **Description**: A POSIX function for file locking.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <unistd.h>
+    #include <fcntl.h>
+    #include <sys/file.h>
+
+    int main() {
+        int fd = open("file.txt", O_RDWR | O_CREAT, 0666);
+        if (fd < 0) {
+            perror("open");
+            exit(EXIT_FAILURE);
+        }
+
+        // Acquire an exclusive lock
+        if (flock(fd, LOCK_EX) < 0) {
+            perror("flock");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+
+        printf("File locked. Press Enter to release lock...\n");
+        getchar(); // Wait for user input
+
+        // Release the lock
+        if (flock(fd, LOCK_UN) < 0) {
+            perror("flock");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+
+        close(fd);
+        printf("File unlocked.\n");
+        return 0;
+    }
+    ```
+
+- **Using `fcntl()`**:
+  - **Description**: Provides more control over file locking.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <fcntl.h>
+    #include <unistd.h>
+
+    int main() {
+        int fd = open("file.txt", O_RDWR | O_CREAT, 0666);
+        if (fd < 0) {
+            perror("open");
+            exit(EXIT_FAILURE);
+        }
+
+        struct flock lock;
+        lock.l_type = F_WRLCK; // Write lock
+        lock.l_whence = SEEK_SET;
+        lock.l_start = 0;
+        lock.l_len = 0; // Lock the whole file
+
+        if (fcntl(fd, F_SETLKW, &lock) < 0) {
+            perror("fcntl");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+
+        printf("File locked. Press Enter to release lock...\n");
+        getchar(); // Wait for user input
+
+        lock.l_type = F_UNLCK; // Unlock
+        if (fcntl(fd, F_SETLK, &lock) < 0) {
+            perror("fcntl");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+
+        close(fd);
+        printf("File unlocked.\n");
+        return 0;
+    }
+    ```
+
+#### 2. File I/O Performance Optimization
+
+To optimize file I/O performance, you can use techniques such as buffering, efficient file access, and reducing system calls.
+
+- **Buffered I/O**:
+  - **Description**: Reduces the number of I/O operations by using a buffer.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+
+    int main() {
+        FILE *file = fopen("largefile.txt", "r");
+        if (!file) {
+            perror("fopen");
+            return 1;
+        }
+
+        char buffer[1024];
+        size_t bytesRead;
+
+        while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+            // Process data in buffer
+        }
+
+        fclose(file);
+        return 0;
+    }
+    ```
+
+- **Efficient File Access**:
+  - **Description**: Minimize the number of file open/close operations and use appropriate file modes.
+
+- **Reducing System Calls**:
+  - **Description**: Combine operations where possible to reduce the number of system calls.
+
+#### 3. Handling Large Files
+
+When working with large files, consider techniques for efficient reading, writing, and memory management.
+
+- **Reading Large Files**:
+  - **Description**: Use buffered reading to handle large files in chunks.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+
+    int main() {
+        FILE *file = fopen("largefile.txt", "r");
+        if (!file) {
+            perror("fopen");
+            return 1;
+        }
+
+        char buffer[1024];
+        size_t bytesRead;
+
+        while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+            // Process data
+        }
+
+        fclose(file);
+        return 0;
+    }
+    ```
+
+- **Writing Large Files**:
+  - **Description**: Write data in chunks to avoid memory overflow.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+
+    int main() {
+        FILE *file = fopen("largefile.txt", "w");
+        if (!file) {
+            perror("fopen");
+            return 1;
+        }
+
+        char buffer[1024];
+        for (int i = 0; i < sizeof(buffer); i++) {
+            buffer[i] = 'A'; // Example data
+        }
+
+        fwrite(buffer, 1, sizeof(buffer), file);
+        fclose(file);
+        return 0;
+    }
+    ```

courses/C/advance-level/Advance-File-Handling/_category_.json

@@ -0,0 +1,8 @@
+{
+    "label": "Advanced File Handling",
+    "position": 3,
+    "link": {
+      "type": "generated-index",
+      "description": "Learn Advanced File Handling in C Language."
+    }
+  }

courses/C/advance-level/Advance-File-Handling/working-memory-map.md

@@ -0,0 +1,64 @@
+---
+id: lesson-2
+title: "Working with Memory-Mapped Files"
+sidebar_label: Working with Memory-Mapped Files
+sidebar_position: 2
+description: "Learn Working with Memory-Mapped Files in C"
+tags: [courses,Advance-level,Introduction]
+---   
+
+Memory-mapped files allow you to map a file into memory and access it as if it were an array. This can be more efficient than traditional file I/O.
+
+- **Using `mmap()`**:
+  - **Description**: Maps a file or a portion of a file into memory.
+  - **Example**:
+    ```c
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <sys/mman.h>
+    #include <fcntl.h>
+    #include <unistd.h>
+    #include <string.h>
+
+    int main() {
+        int fd = open("file.txt", O_RDWR | O_CREAT, 0666);
+        if (fd < 0) {
+            perror("open");
+            exit(EXIT_FAILURE);
+        }
+
+        // Resize file to 100 bytes
+        ftruncate(fd, 100);
+
+        // Map file to memory
+        char *mapped = mmap(NULL, 100, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (mapped == MAP_FAILED) {
+            perror("mmap");
+            close(fd);
+            exit(EXIT_FAILURE);
+        }
+
+        // Write data to the mapped memory
+        strcpy(mapped, "Hello, memory-mapped file!");
+
+        // Unmap and close
+        munmap(mapped, 100);
+        close(fd);
+        return 0;
+    }
+    ```
+
+- **Advantages**:
+  - **Efficiency**: Direct access to file data without additional I/O calls.
+  - **Simplicity**: Treats file data like an array.
+
+- **Considerations**:
+  - **File Size**: Be cautious with very large files as mapping the entire file may not be feasible.
+  - **Concurrency**: Ensure proper synchronization if multiple processes or threads are accessing the memory-mapped file.
+
+### Summary
+
+- **File Locking Mechanisms**: Use `flock()` or `fcntl()` to manage file access in concurrent environments.
+- **File I/O Performance Optimization**: Use buffering and efficient access patterns to enhance performance.
+- **Handling Large Files**: Read/write in chunks and manage memory efficiently.
+- **Memory-Mapped Files**: Map files into memory for efficient access and manipulation.