Add 03-advanced structs-and-classes module

Author: lucasbellesi

README.md

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

languages/cpp/03-advanced/README.md

@@ -1,13 +1,16 @@
 # 03 Advanced
 
-This level is reserved for advanced C++ topics after core proficiency.
+This level introduces object modeling and design patterns after core proficiency.
 
-## Intended Topics
+## Module Order
 
-- Object-oriented design and class modeling
-- Resource management and RAII
-- Generic programming foundations
+1. [structs-and-classes](./structs-and-classes/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/03-advanced/structs-and-classes/README.md

@@ -0,0 +1,62 @@
+# Structs and Classes
+
+This module introduces object modeling with `struct` and `class` in C++.
+
+## Why It Matters
+
+As programs grow, related data and behavior should be grouped together.  
+`struct` and `class` help you model real entities clearly.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o structs_and_classes_example
+./structs_and_classes_example
+```
+
+On Windows (MSYS2 shell), run:
+
+```bash
+./structs_and_classes_example.exe
+```
+
+## Topics Covered
+
+### `struct` vs `class`
+
+- `struct` members are `public` by default.
+- `class` members are `private` by default.
+- Both can have fields, methods, and constructors.
+
+### Constructors
+
+Constructors initialize objects when they are created.
+
+```cpp
+class Account {
+public:
+    Account(const std::string& ownerName, double initialBalance);
+};
+```
+
+### Encapsulation
+
+Keep object state private and expose safe methods (`deposit`, `withdraw`, getters).
+
+## Common Pitfalls
+
+- Exposing all fields publicly in classes that should protect state.
+- Forgetting `const` on methods that do not modify object state.
+- Not validating values in constructors or mutating methods.
+
+## Exercise Focus
+
+- `exercises/01.cpp`: model a rectangle with a `struct` and member methods.
+- `exercises/02.cpp`: create a small class with private state and controlled updates.
+
+## Checkpoint
+
+- [ ] I can explain default access in `struct` and `class`.
+- [ ] I can write and use constructors.
+- [ ] I can protect state with private fields and public methods.
+- [ ] I completed both exercises.

languages/cpp/03-advanced/structs-and-classes/example/main.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+struct Student {
+    std::string name;
+    int age;
+    double grade;
+
+    void print() const {
+        std::cout << "Student{name=\"" << name << "\", age=" << age
+                  << ", grade=" << grade << "}\n";
+    }
+};
+
+class BankAccount {
+public:
+    BankAccount(const std::string& ownerName, double initialBalance)
+        : owner(ownerName), balance(initialBalance) {
+        if (balance < 0.0) {
+            balance = 0.0;
+        }
+    }
+
+    bool deposit(double amount) {
+        if (amount <= 0.0) {
+            return false;
+        }
+        balance += amount;
+        return true;
+    }
+
+    bool withdraw(double amount) {
+        if (amount <= 0.0 || amount > balance) {
+            return false;
+        }
+        balance -= amount;
+        return true;
+    }
+
+    const std::string& getOwner() const {
+        return owner;
+    }
+
+    double getBalance() const {
+        return balance;
+    }
+
+private:
+    std::string owner;
+    double balance;
+};
+
+int main() {
+    std::vector<Student> students{
+        {"Alex Johnson", 19, 8.7},
+        {"Maya Patel", 20, 9.1}
+    };
+
+    std::cout << "Students (struct example):\n";
+    for (const Student& student : students) {
+        student.print();
+    }
+
+    BankAccount account("Alex Johnson", 100.0);
+    account.deposit(40.0);
+    account.withdraw(25.0);
+
+    std::cout << "\nBank account (class example):\n";
+    std::cout << "Owner: " << account.getOwner() << '\n';
+    std::cout << "Balance: " << account.getBalance() << '\n';
+
+    return 0;
+}

languages/cpp/03-advanced/structs-and-classes/exercises/01.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+
+struct Rectangle {
+    double width;
+    double height;
+
+    double area() const {
+        return width * height;
+    }
+
+    double perimeter() const {
+        return 2.0 * (width + height);
+    }
+};
+
+int main() {
+    Rectangle rectangle{0.0, 0.0};
+
+    std::cout << "Enter width and height: ";
+    std::cin >> rectangle.width >> rectangle.height;
+
+    if (rectangle.width <= 0.0 || rectangle.height <= 0.0) {
+        std::cout << "Width and height must be positive.\n";
+        return 0;
+    }
+
+    std::cout << "Area: " << rectangle.area() << '\n';
+    std::cout << "Perimeter: " << rectangle.perimeter() << '\n';
+    return 0;
+}

languages/cpp/03-advanced/structs-and-classes/exercises/02.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+#include <limits>
+#include <string>
+
+class Counter {
+public:
+    Counter() : value(0) {}
+
+    void increment() {
+        ++value;
+    }
+
+    void decrement() {
+        --value;
+    }
+
+    void reset() {
+        value = 0;
+    }
+
+    int getValue() const {
+        return value;
+    }
+
+private:
+    int value;
+};
+
+int main() {
+    Counter counter;
+    std::string command;
+
+    std::cout << "Commands: inc, dec, reset, stop\n";
+    while (true) {
+        std::cout << "Enter command: ";
+        if (!(std::cin >> command)) {
+            std::cin.clear();
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        if (command == "inc") {
+            counter.increment();
+        } else if (command == "dec") {
+            counter.decrement();
+        } else if (command == "reset") {
+            counter.reset();
+        } else if (command == "stop") {
+            break;
+        } else {
+            std::cout << "Unknown command.\n";
+            continue;
+        }
+
+        std::cout << "Current value: " << counter.getValue() << '\n';
+    }
+
+    std::cout << "Final value: " << counter.getValue() << '\n';
+    return 0;
+}

languages/cpp/CHECKLIST.md

@@ -24,3 +24,8 @@
 - [ ] input-validation exercises completed.
 - [ ] algorithms-basics: implement linear search, counting, and min/max patterns.
 - [ ] algorithms-basics exercises completed.
+
+## Advanced
+
+- [ ] structs-and-classes: model entities with constructors and encapsulation.
+- [ ] structs-and-classes exercises completed.

languages/cpp/README.md

@@ -31,6 +31,10 @@ Current concept modules inside `02-core`:
 - [input-validation](./02-core/input-validation/README.md)
 - [algorithms-basics](./02-core/algorithms-basics/README.md)
 
+Current concept modules inside `03-advanced`:
+
+- [structs-and-classes](./03-advanced/structs-and-classes/README.md)
+
 Use the checklist: [CHECKLIST.md](./CHECKLIST.md)
 
 ## Concept Folder Structure
@@ -66,6 +70,10 @@ After finishing all concepts in `01-foundations`, continue with `02-core` in thi
 1. `input-validation`
 2. `algorithms-basics`
 
+Then continue with `03-advanced`:
+
+1. `structs-and-classes`
+
 ## Build Command
 
 ```bash