Add 04-expert memory-management-and-raii module

Author: lucasbellesi

README.md

@@ -43,6 +43,10 @@ Current C++ advanced modules:
 
 - `03-advanced/structs-and-classes`
 
+Current C++ expert modules:
+
+- `04-expert/memory-management-and-raii`
+
 ## Guided Learning Path
 
 1. Complete setup: `languages/cpp/00-setup/README.md`
@@ -51,7 +55,7 @@ Current C++ advanced modules:
    - read `README.md`
    - run `example/main.cpp`
    - solve `exercises/01.cpp` and `exercises/02.cpp`
-   - after foundations, continue with `languages/cpp/02-core`, then `languages/cpp/03-advanced`
+   - after foundations, continue with `languages/cpp/02-core`, then `languages/cpp/03-advanced`, then `languages/cpp/04-expert`
 4. Mark progress in `languages/cpp/CHECKLIST.md`
 5. Repeat until all modules are complete
 

languages/cpp/04-expert/README.md

@@ -1,13 +1,16 @@
 # 04 Expert
 
-This level is reserved for expert-level C++ topics.
+This level focuses on robust C++ design for resource safety and performance.
 
-## Intended Topics
+## Module Order
 
-- Concurrency and synchronization
-- Performance and memory optimization
-- Large-scale C++ patterns and architecture
+1. [memory-management-and-raii](./memory-management-and-raii/README.md)
 
-## Status
+## How To Study This Level
 
-This level folder is ready for future modules.
+For each module:
+
+1. Read `README.md`.
+2. Run `example/main.cpp`.
+3. Complete `exercises/01.cpp` and `exercises/02.cpp`.
+4. Mark progress in `../CHECKLIST.md`.

languages/cpp/04-expert/memory-management-and-raii/README.md

@@ -0,0 +1,56 @@
+# Memory Management and RAII
+
+This module introduces safe ownership patterns in modern C++.
+
+## Why It Matters
+
+Many C++ bugs come from incorrect memory or resource handling.  
+RAII and smart pointers reduce those bugs by tying cleanup to object lifetime.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o memory_raii_example
+./memory_raii_example
+```
+
+On Windows (MSYS2 shell), run:
+
+```bash
+./memory_raii_example.exe
+```
+
+## Topics Covered
+
+### Stack vs Heap
+
+- Stack objects are destroyed automatically at scope end.
+- Heap objects need ownership and cleanup strategy.
+
+### RAII (Resource Acquisition Is Initialization)
+
+Acquire resources in constructors and release them in destructors.
+
+### Smart Pointers
+
+- `std::unique_ptr<T>`: single owner.
+- `std::shared_ptr<T>`: shared ownership (use carefully).
+- Prefer `unique_ptr` unless shared ownership is required.
+
+## Common Pitfalls
+
+- Using raw `new`/`delete` directly in beginner/intermediate code.
+- Copying `unique_ptr` (it must be moved).
+- Creating ownership cycles with `shared_ptr`.
+
+## Exercise Focus
+
+- `exercises/01.cpp`: use `std::unique_ptr<int[]>` for dynamic arrays safely.
+- `exercises/02.cpp`: model RAII with a scope-based guard class.
+
+## Checkpoint
+
+- [ ] I can explain ownership with `unique_ptr`.
+- [ ] I understand how destructors enforce cleanup.
+- [ ] I can model scope-based resource management.
+- [ ] I completed both exercises.

languages/cpp/04-expert/memory-management-and-raii/example/main.cpp

@@ -0,0 +1,58 @@
+#include <cstddef>
+#include <iostream>
+#include <memory>
+#include <string>
+
+class ScopedMessage {
+public:
+    explicit ScopedMessage(const std::string& labelText) : label(labelText) {
+        std::cout << "[acquire] " << label << '\n';
+    }
+
+    ~ScopedMessage() {
+        std::cout << "[release] " << label << '\n';
+    }
+
+private:
+    std::string label;
+};
+
+std::unique_ptr<int[]> makeSequence(std::size_t size) {
+    std::unique_ptr<int[]> data(new int[size]);
+    for (std::size_t i = 0; i < size; ++i) {
+        data[i] = static_cast<int>((i + 1) * 10);
+    }
+    return data;
+}
+
+void printSequence(const std::unique_ptr<int[]>& data, std::size_t size) {
+    std::cout << "Sequence: ";
+    for (std::size_t i = 0; i < size; ++i) {
+        std::cout << data[i];
+        if (i + 1 < size) {
+            std::cout << ' ';
+        }
+    }
+    std::cout << '\n';
+}
+
+int main() {
+    std::cout << "RAII scope demo:\n";
+    {
+        ScopedMessage scoped("temporary operation");
+        std::cout << "Inside scope.\n";
+    }
+
+    const std::size_t size = 5;
+    std::unique_ptr<int[]> values = makeSequence(size);
+    printSequence(values, size);
+
+    std::cout << "Ownership transfer with move:\n";
+    std::unique_ptr<int[]> movedValues = std::move(values);
+    if (!values) {
+        std::cout << "Original pointer is now empty after move.\n";
+    }
+    printSequence(movedValues, size);
+
+    return 0;
+}

languages/cpp/04-expert/memory-management-and-raii/exercises/01.cpp

@@ -0,0 +1,38 @@
+#include <cstddef>
+#include <iostream>
+#include <memory>
+
+int main() {
+    int n = 0;
+    std::cout << "How many integers? ";
+    std::cin >> n;
+
+    if (n <= 0) {
+        std::cout << "Please enter a positive count.\n";
+        return 0;
+    }
+
+    std::unique_ptr<int[]> values(new int[static_cast<std::size_t>(n)]);
+
+    for (int i = 0; i < n; ++i) {
+        std::cout << "Value " << (i + 1) << ": ";
+        std::cin >> values[static_cast<std::size_t>(i)];
+    }
+
+    long long sum = 0;
+    for (int i = 0; i < n; ++i) {
+        sum += values[static_cast<std::size_t>(i)];
+    }
+
+    std::cout << "Sum: " << sum << '\n';
+    std::cout << "Reversed: ";
+    for (int i = n - 1; i >= 0; --i) {
+        std::cout << values[static_cast<std::size_t>(i)];
+        if (i > 0) {
+            std::cout << ' ';
+        }
+    }
+    std::cout << '\n';
+
+    return 0;
+}

languages/cpp/04-expert/memory-management-and-raii/exercises/02.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <string>
+
+class CounterGuard {
+public:
+    explicit CounterGuard(int& sharedCounterRef, const std::string& labelText)
+        : sharedCounter(sharedCounterRef), label(labelText) {
+        ++sharedCounter;
+        std::cout << "[enter] " << label << " | active guards: " << sharedCounter << '\n';
+    }
+
+    ~CounterGuard() {
+        --sharedCounter;
+        std::cout << "[exit]  " << label << " | active guards: " << sharedCounter << '\n';
+    }
+
+private:
+    int& sharedCounter;
+    std::string label;
+};
+
+int main() {
+    int activeGuards = 0;
+
+    std::cout << "Starting scope demo.\n";
+    {
+        CounterGuard first(activeGuards, "first scope");
+        {
+            CounterGuard second(activeGuards, "nested scope");
+            std::cout << "Inside nested scope.\n";
+        }
+        std::cout << "Back to first scope.\n";
+    }
+
+    std::cout << "Final active guards: " << activeGuards << '\n';
+    return 0;
+}

languages/cpp/CHECKLIST.md

@@ -29,3 +29,8 @@
 
 - [ ] structs-and-classes: model entities with constructors and encapsulation.
 - [ ] structs-and-classes exercises completed.
+
+## Expert
+
+- [ ] memory-management-and-raii: apply ownership rules and scope-based cleanup.
+- [ ] memory-management-and-raii exercises completed.

languages/cpp/README.md

@@ -35,6 +35,10 @@ Current concept modules inside `03-advanced`:
 
 - [structs-and-classes](./03-advanced/structs-and-classes/README.md)
 
+Current concept modules inside `04-expert`:
+
+- [memory-management-and-raii](./04-expert/memory-management-and-raii/README.md)
+
 Use the checklist: [CHECKLIST.md](./CHECKLIST.md)
 
 ## Concept Folder Structure
@@ -74,6 +78,10 @@ Then continue with `03-advanced`:
 
 1. `structs-and-classes`
 
+Then continue with `04-expert`:
+
+1. `memory-management-and-raii`
+
 ## Build Command
 
 ```bash