fix: Update correct video links in C++ Strings guide

Author: dev-ai-kar

26.How Strings Work in C++.md

@@ -1,17 +1,17 @@
 ## How Strings Work in C++ (and how to use them)
 
-**Video Link:** [C++ Strings ](https://youtu.be/6OVQ8nh3KP0)
+**Video Link:** [C++ Strings ](https://youtu.be/ijIxcB9qjaU)
 
-**Playlist Link:** [C++ Tutorial Playlist by The Cherno](https://www.youtube.com/watch?v=6OVQ8nh3KP0&list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb&index=10)
+**Playlist Link:** [C++ Tutorial Playlist by The Cherno](https://www.youtube.com/watch?v=ijIxcB9qjaU&list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb&index=10)
 
-### 📌 Prerequisites (Mentioned at [0:06](https://youtu.be/6OVQ8nh3KP0?t=6))
+### 📌 Prerequisites (Mentioned at [0:06](https://youtu.be/ijIxcB9qjaU?t=6))
 
 *   It's helpful to have watched the previous videos on:
     *   Pointers ([Episode 8](https://www.youtube.com/watch?v=DTxHNJHI7Ys&list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb&index=8))
     *   Arrays ([Episode 9](https://www.youtube.com/watch?v=ENDaJi08jCU&list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb&index=9))
     *   Why? Because strings are closely related to both concepts.
 
-### 🤔 What is a String? (General Concept) ([0:21](https://youtu.be/6OVQ8nh3KP0?t=21))
+### 🤔 What is a String? (General Concept) ([0:21](https://youtu.be/ijIxcB9qjaU?t=21))
 
 *   A string is essentially a sequence or group of characters.
 *   Characters can be:
@@ -21,42 +21,42 @@
 *   Basically, a string represents **text**.
 *   Representing text is fundamental in programming for user interfaces, file handling, data processing, etc.
 
-### 💡 How Strings Work: The Basics ([1:08](https://youtu.be/6OVQ8nh3KP0?t=68))
+### 💡 How Strings Work: The Basics ([1:08](https://youtu.be/ijIxcB9qjaU?t=68))
 
 *   To understand strings, you first need to understand how *characters* work.
-*   **Characters (`char`) in C++:** ([1:53](https://youtu.be/6OVQ8nh3KP0?t=113))
+*   **Characters (`char`) in C++:** ([1:53](https://youtu.be/ijIxcB9qjaU?t=113))
     *   The `char` data type is used.
     *   Typically, `char` is **1 byte** (8 bits) of memory.
     *   This 1-byte size is often used for low-level memory manipulation (like pointer arithmetic in bytes or creating memory buffers).
-*   **Character Encoding:** ([2:00](https://youtu.be/6OVQ8nh3KP0?t=120))
+*   **Character Encoding:** ([2:00](https://youtu.be/ijIxcB9qjaU?t=120))
     *   How characters (letters, symbols) are mapped to numbers (and thus, bytes).
     *   **ASCII** is the most basic standard, using 1 byte (technically 7 bits, extended ASCII uses 8). It can represent 256 different characters (0-255).
     *   This is enough for English letters (uppercase/lowercase), numbers, and common symbols.
-    *   **Limitation:** ASCII cannot represent characters from many other languages (e.g., Japanese, Chinese, Russian, Korean) because there are far more than 256 unique characters globally. ([3:22](https://youtu.be/6OVQ8nh3KP0?t=202))
+    *   **Limitation:** ASCII cannot represent characters from many other languages (e.g., Japanese, Chinese, Russian, Korean) because there are far more than 256 unique characters globally. ([3:22](https://youtu.be/ijIxcB9qjaU?t=202))
     *   Other encodings exist (UTF-8, UTF-16, UTF-32 - part of Unicode) to handle this, often using more than 1 byte per character. *This video focuses on the basic ASCII/`char` concept.*
 
-### ⛓️ C-Style Strings: Character Pointers & Arrays ([2:59](https://youtu.be/6OVQ8nh3KP0?t=179))
+### ⛓️ C-Style Strings: Character Pointers & Arrays ([2:59](https://youtu.be/ijIxcB9qjaU?t=179))
 
 *   Traditionally (in C, and still usable in C++), strings are represented as arrays of characters, often manipulated via pointers.
 *   **String Literals:** When you write text in double quotes like `"Cherno"`, this is a string literal.
     *   Example: `const char* name = "Cherno";`
     *   `name` is a pointer (`char*`) pointing to the first character ('C') of a sequence of characters stored somewhere in the program's memory.
     *   This memory location for string literals is often **read-only**.
-*   **Why `const`?** ([5:54](https://youtu.be/6OVQ8nh3KP0?t=354))
+*   **Why `const`?** ([5:54](https://youtu.be/ijIxcB9qjaU?t=354))
     *   Because string literals are often in read-only memory, trying to modify them can cause a crash.
     *   Declaring the pointer as `const char*` makes the *data pointed to* constant (read-only from the perspective of this pointer). This helps prevent accidental modification attempts.
     *   Example of what **NOT** to do:
         ```c++
         char* name = "Cherno"; // Problematic: Assigning literal to non-const pointer
         name[2] = 'a'; // CRASH! Trying to write to read-only memory.
         ```
-*   **Null Termination:** ([8:07](https://youtu.be/6OVQ8nh3KP0?t=487))
+*   **Null Termination:** ([8:07](https://youtu.be/ijIxcB9qjaU?t=487))
     *   How does the program know where a C-style string ends if it only has a pointer to the start?
     *   Answer: A special **null terminator character** (`\0`) is automatically added at the end of string literals.
     *   This character has an ASCII value of **0**.
     *   Functions working with C-style strings (like printing) read characters sequentially from the starting address until they encounter this null byte (value 0).
-    *   Memory View: `"Cherno"` in memory looks like `C h e r n o \0` (represented by their byte values, with the last one being `00`). ([7:21](https://youtu.be/6OVQ8nh3KP0?t=441))
-*   **Manual Char Arrays:** ([8:48](https://youtu.be/6OVQ8nh3KP0?t=528))
+    *   Memory View: `"Cherno"` in memory looks like `C h e r n o \0` (represented by their byte values, with the last one being `00`). ([7:21](https://youtu.be/ijIxcB9qjaU?t=441))
+*   **Manual Char Arrays:** ([8:48](https://youtu.be/ijIxcB9qjaU?t=528))
     *   You can create strings using explicit char arrays.
     *   Example (Incorrect - Missing Null Terminator):
         ```c++
@@ -74,7 +74,7 @@
         ```
     *   **Key takeaway:** If manually creating char arrays for strings, always allocate one extra byte for the null terminator and ensure it's set to 0 or `\0`.
 
-### ✨ The C++ `std::string` Way ([11:03](https://youtu.be/6OVQ8nh3KP0?t=663))
+### ✨ The C++ `std::string` Way ([11:03](https://youtu.be/ijIxcB9qjaU?t=663))
 
 *   C++ provides a much more convenient and safer way to handle strings via the Standard Library.
 *   **Include Header:**
@@ -100,7 +100,7 @@
     *   **Easier:** Simpler syntax, less manual memory management.
     *   **Safer:** Reduces risks of buffer overflows and memory errors common with C-style strings.
     *   **Functionality:** Provides many useful member functions (e.g., finding length, appending, searching).
-*   **Concatenation (Appending Strings):** ([14:08](https://youtu.be/6OVQ8nh3KP0?t=848))
+*   **Concatenation (Appending Strings):** ([14:08](https://youtu.be/ijIxcB9qjaU?t=848))
     *   **Problem:** `std::string name = "Cherno" + " hello!";` // ERROR!
         *   Reason: Both `"Cherno"` and `" hello!"` are `const char*` (C-style string literals/pointers). C++ doesn't define how to add two `const char*` pointers together in this context.
     *   **Solution 1 (Using `+=`):**
@@ -116,7 +116,7 @@
         std::cout << name << std::endl; // Outputs "Cherno hello!"
         ```
         *   This works because `std::string("Cherno")` creates a `std::string` object. The `+` operator *is* overloaded for `std::string` + `const char*`.
-*   **Finding Substrings:** ([15:14](https://youtu.be/6OVQ8nh3KP0?t=914))
+*   **Finding Substrings:** ([15:14](https://youtu.be/ijIxcB9qjaU?t=914))
     *   Use the `.find()` member function.
     *   Example:
         ```c++
@@ -128,7 +128,7 @@
             std::cout << "Found 'no'!" << std::endl;
         }
         ```
-*   **Getting Size/Length:** ([13:45](https://youtu.be/6OVQ8nh3KP0?t=825))
+*   **Getting Size/Length:** ([13:45](https://youtu.be/ijIxcB9qjaU?t=825))
     *   Use the `.size()` member function.
     *   Example:
         ```c++
@@ -137,7 +137,7 @@
         ```
     *   This is much easier than using C-style functions like `strlen()`.
 
-### 👉 Passing Strings to Functions ([16:13](https://youtu.be/6OVQ8nh3KP0?t=973))
+### 👉 Passing Strings to Functions ([16:13](https://youtu.be/ijIxcB9qjaU?t=973))
 
 *   How should you pass `std::string` objects to functions?
 *   **Option 1: Pass by Value (Generally BAD for strings)**
@@ -162,7 +162,7 @@
     *   **Benefit:** Highly efficient (no copying) and safe (prevents accidental modification).
     *   **Rule of Thumb:** If a function only needs to *read* a string, pass it by `const std::string&`.
 
-### 🙏 Conclusion ([17:54](https://youtu.be/6OVQ8nh3KP0?t=1074))
+### 🙏 Conclusion ([17:54](https://youtu.be/ijIxcB9qjaU?t=1074))
 
 *   Strings are fundamental for text representation.
 *   C-style strings (`char*`, char arrays) require manual null termination and careful memory management.