Merge branch 'main' into add-data-visualization-in-UX

Author: AnamolR

content/cpp/concepts/arrays/terms/at/at.md

@@ -0,0 +1,189 @@
+---
+Title: '.at()'
+Description: 'Returns a reference to the element at the specified position with bounds checking in std::array containers.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Arrays'
+  - 'Functions'
+  - 'Methods'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`.at()`** [method](https://www.codecademy.com/resources/docs/cpp/methods) in C++ is a member [function](https://www.codecademy.com/resources/docs/cpp/functions) of the `std::array` container that provides safe access to elements by their position index. Unlike the subscript operator (`[]`), the `.at()` method automatically performs bounds checking and throws an `std::out_of_range` [exception](https://www.codecademy.com/resources/docs/cpp/exceptions) if the specified index is invalid. This makes it a safer alternative for element access when you need to ensure that array bounds are not violated.
+
+The `.at()` method is particularly useful in scenarios where data integrity and [error](https://www.codecademy.com/resources/docs/cpp/errors) handling are critical, such as processing user input, parsing data files, or working with indices that might be calculated dynamically. It provides a balance between safety and performance, making code more robust while maintaining reasonable execution speed.
+
+## Syntax
+
+```pseudo
+array_name.at(i)
+```
+
+**Parameters:**
+
+- `i`: The zero-based index position of the element to access. Must be a non-negative integer value of type `size_type` (typically `std::size_t`). Valid indices range from `0` to `size()-1`. If the index is greater than or equal to the array size, an `std::out_of_range` exception is thrown.
+
+**Return value:**
+
+The `.at()` method returns a reference to the element at the specified position. If the array object is const-qualified, it returns a `const_reference`; otherwise, it returns a `reference` that allows both reading and modifying the element.
+
+**Exception:**
+
+Throws `std::out_of_range` exception if `pos` is greater than or equal to the size of the array.
+
+## Example 1: Basic Element Access
+
+This example demonstrates the fundamental usage of the `.at()` method to safely access elements in a `std::array`:
+
+```cpp
+#include <iostream>
+#include <array>
+
+int main() {
+  // Create an array of integers with 5 elements
+  std::array<int, 5> numbers = {10, 20, 30, 40, 50};
+
+  // Access elements using .at() method
+  std::cout << "Element at index 0: " << numbers.at(0) << std::endl;
+  std::cout << "Element at index 2: " << numbers.at(2) << std::endl;
+  std::cout << "Element at index 4: " << numbers.at(4) << std::endl;
+
+  // Modify an element using .at() method
+  numbers.at(1) = 99;
+  std::cout << "Modified element at index 1: " << numbers.at(1) << std::endl;
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Element at index 0: 10
+Element at index 2: 30
+Element at index 4: 50
+Modified element at index 1: 99
+```
+
+This example shows how `.at()` can be used for both reading and writing array elements. The method provides direct access to elements at valid indices and allows modification of non-const arrays.
+
+## Example 2: Safe Input Processing
+
+This example demonstrates using `.at()` method in a real-world scenario where user input needs to be validated before accessing array elements:
+
+```cpp
+#include <iostream>
+#include <array>
+#include <stdexcept>
+
+int main() {
+  // Array storing daily temperatures for a week
+  std::array<double, 7> weeklyTemps = {22.5, 25.1, 21.8, 24.3, 26.7, 23.9, 20.2};
+  std::array<std::string, 7> dayNames = {"Monday", "Tuesday", "Wednesday",
+                                         "Thursday", "Friday", "Saturday", "Sunday"};
+
+  int dayChoice;
+  std::cout << "Enter day number (1-7) to get temperature: ";
+  std::cin >> dayChoice;
+
+  try {
+    // Convert 1-based input to 0-based index and use .at() for safe access
+    int index = dayChoice - 1;
+    double temperature = weeklyTemps.at(index);
+    std::string dayName = dayNames.at(index);
+
+    std::cout << "Temperature on " << dayName << ": " << temperature << "°C" << std::endl;
+  }
+  catch (const std::out_of_range& e) {
+    std::cout << "Error: Invalid day number. Please enter a number between 1 and 7." << std::endl;
+  }
+
+  return 0;
+}
+```
+
+The output of this code is (If user enters 3):
+
+```shell
+Enter day number (1-7) to get temperature: 3
+Temperature on Wednesday: 21.8°C
+```
+
+Output (if user enters 10):
+
+```shell
+Enter day number (1-7) to get temperature: 10
+Error: Invalid day number. Please enter a number between 1 and 7.
+```
+
+This example demonstrates how `.at()` method's bounds checking helps create robust applications that handle invalid user input gracefully without crashing.
+
+## Codebyte Example: Grade Management System
+
+This example shows the `.at()` method being used in a practical grade management scenario where safe access to student scores is essential:
+
+```cpp
+#include <iostream>
+#include <array>
+#include <iomanip>
+#include <stdexcept>
+
+int main() {
+  // Array storing test scores for 5 students
+  std::array<double, 5> testScores = {85.5, 92.3, 78.9, 96.1, 88.7};
+  std::array<std::string, 5> studentNames = {"Alice", "Bob", "Charlie", "Diana", "Eve"};
+
+  // Function to display a specific student's grade
+  auto displayGrade = [&](int studentId) {
+    try {
+      double score = testScores.at(studentId);
+      std::string name = studentNames.at(studentId);
+
+      std::cout << std::fixed << std::setprecision(1);
+      std::cout << "Student: " << name << ", Score: " << score << "%" << std::endl;
+
+      // Determine grade based on score
+      if (score >= 90) std::cout << "Grade: A" << std::endl;
+      else if (score >= 80) std::cout << "Grade: B" << std::endl;
+      else if (score >= 70) std::cout << "Grade: C" << std::endl;
+      else std::cout << "Grade: F" << std::endl;
+    }
+    catch (const std::out_of_range& e) {
+      std::cout << "Error: Student ID " << studentId << " not found." << std::endl;
+    }
+  };
+
+  // Display all students
+  std::cout << "=== Class Grades ===" << std::endl;
+  for (size_t i = 0; i < testScores.size(); ++i) {
+    displayGrade(i);
+    std::cout << std::endl;
+  }
+
+  // Test invalid access
+  std::cout << "Attempting to access invalid student ID:" << std::endl;
+  displayGrade(10);
+
+  return 0;
+}
+```
+
+This example illustrates how the `.at()` method enables the creation of robust data management systems where array bounds are automatically validated, preventing potential crashes and providing clear error feedback.
+
+## Frequently Asked Questions
+
+### 1. What is the difference between `.at()` and the subscript operator `[]`?
+
+The `.at()` method performs bounds checking and throws an `std::out_of_range` exception for invalid indices, while the subscript operator `[]` does not check bounds and may result in undefined behavior if an invalid index is used.
+
+### 2. When should I use `.at()` instead of `[]`?
+
+Use `.at()` when you need guaranteed bounds checking, especially when dealing with user input, dynamic indices, or when building robust applications where safety is more important than maximum performance.
+
+### 3. What happens if I try to access an element beyond the array size?
+
+The `.at()` method will throw an `std::out_of_range` exception, which you can catch and handle appropriately in your code.

content/cpp/concepts/pointers/terms/swap/swap.md

@@ -0,0 +1,167 @@
+---
+Title: '.swap()'
+Description: 'Exchanges the values of two pointers or container elements, allowing efficient data manipulation without deep copies.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Functions'
+  - 'Memory'
+  - 'Pointers'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`.swap()`** function in C++ is used to exchange the values or contents of two [variables](https://www.codecademy.com/resources/docs/cpp/variables), including [pointers](https://www.codecademy.com/resources/docs/cpp/pointers) and [objects](https://www.codecademy.com/resources/docs/cpp/objects). When used with pointers, `std::swap()` simply exchanges the memory addresses they store, not the values pointed to. It is especially useful for efficiently reassigning ownership of dynamically allocated memory or switching references between data structures.
+
+Swapping pointers is a common practice in algorithms (e.g., linked lists, trees), memory management, and system-level programming. It provides an efficient way to manipulate references without copying or reallocating the underlying data.
+
+## Syntax
+
+```pseudo
+std::swap(ptr1, ptr2);
+```
+
+**Parameters:**
+
+- `ptr1`, `ptr2`: Two pointer variables (e.g., `int*`, `char*`, `MyClass*`, etc.)
+  - These must be of the same type.
+  - After swapping, the memory addresses stored in `ptr1` and `ptr2` are exchanged.
+
+**Return value:**
+
+No return value. The swap is done in-place by modifying the pointer variables.
+
+## Example 1: Swapping Integer Pointers
+
+In this example, `std::swap()` is used to exchange the memory addresses stored in two integer pointers, changing which variables the pointers reference:
+
+```cpp
+#include <iostream>
+#include <utility> // For std::swap
+
+int main() {
+  int a = 10, b = 20;
+  int* ptr1 = &a;
+  int* ptr2 = &b;
+
+  std::cout << "Before swap:\n";
+  std::cout << "ptr1 points to: " << *ptr1 << "\n";
+  std::cout << "ptr2 points to: " << *ptr2 << "\n";
+
+  std::swap(ptr1, ptr2);
+
+  std::cout << "After swap:\n";
+  std::cout << "ptr1 points to: " << *ptr1 << "\n";
+  std::cout << "ptr2 points to: " << *ptr2 << "\n";
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Before swap:
+ptr1 points to: 10
+ptr2 points to: 20
+After swap:
+ptr1 points to: 20
+ptr2 points to: 10
+```
+
+Here, the memory addresses stored in `ptr1` and `ptr2` were swapped, so the variables they point to were exchanged without moving or modifying the original data.
+
+## Example 2: Swapping Pointers in Dynamic Memory
+
+In this example, `std::swap()` is applied to pointers referencing dynamically allocated memory, enabling efficient exchange of their targets without copying values:
+
+```cpp
+#include <iostream>
+#include <utility>
+
+int main() {
+  int* p1 = new int(5);
+  int* p2 = new int(15);
+
+  std::cout << "Before swap: *p1 = " << *p1 << ", *p2 = " << *p2 << "\n";
+
+  std::swap(p1, p2);
+
+  std::cout << "After swap: *p1 = " << *p1 << ", *p2 = " << *p2 << "\n";
+
+  delete p1;
+  delete p2;
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Before swap: *p1 = 5, *p2 = 15
+After swap: *p1 = 15, *p2 = 5
+```
+
+This shows that the values pointed to by the two heap-allocated pointers are swapped efficiently. Always ensure proper memory cleanup using `delete` or smart pointers.
+
+## Codebyte Example: Swapping Class Pointers
+
+In this example, two pointers to `Student` class instances are swapped using `std::swap()`, transferring ownership of the object references without modifying the objects themselves:
+
+```codebyte/cpp
+#include <iostream>
+#include <string>
+#include <utility>
+
+class Student {
+public:
+  std::string name;
+  Student(std::string n) : name(n) {}
+  void display() const {
+    std::cout << "Student: " << name << std::endl;
+  }
+};
+
+int main() {
+  Student* s1 = new Student("Alice");
+  Student* s2 = new Student("Bob");
+
+  std::cout << "Before swap:\n";
+  s1->display();
+  s2->display();
+
+  std::swap(s1, s2);
+
+  std::cout << "After swap:\n";
+  s1->display();
+  s2->display();
+
+  delete s1;
+  delete s2;
+
+  return 0;
+}
+```
+
+This demonstrates pointer swapping with class objects. The actual student objects are untouched—only the pointers are exchanged.
+
+## Frequently Asked Questions
+
+### 1. Is `.swap()` a member function of pointers?
+
+No, raw pointers do not have a `.swap()` member function. You should use `std::swap()` from the `<utility>` header to swap them.
+
+### 2. What’s the difference between swapping pointers vs. values?
+
+Swapping pointers exchanges memory addresses, not the values pointed to. To swap actual values, dereference the pointers:
+
+```cpp
+std::swap(*ptr1, *ptr2);
+```
+
+### 3. Can I use `.swap()` with smart pointers?
+
+Yes, `std::swap()` works with `std::unique_ptr`, `std::shared_ptr`, and other smart pointers. These types may also provide their own `.swap()` member methods for more efficient swapping.