CS-102: Fundamentals of C++ (with OOP)

About this course

Streams, references, classes, inheritance and STL containers - full object-oriented programming, building an expense tracker called LedgerLens.

This is a 6-week short course - enough depth to build real projects and a portfolio piece, without a long commitment. It runs online in the August 2026 cohort (starting 1 August 2026) and is taught the EchoLens way: you learn by doing real, gradeable work rather than just watching lectures.

What's included

• Live, instructor-led online sessions across 4 weeks (10 hours total).
• Hands-on coding quests you solve inside the EchoLens browser compiler - nothing to install.
• Gems, stages and a leaderboard that keep you moving instead of grade anxiety.
• A verified certificate with a scannable QR code, ready to share on LinkedIn, when you finish.
• Completely free - no fee, just create an account and start.

What you will learn

Course outline - level by level

11 leveles, each with hands-on quests you clear in the portal.

• Level 1. cout / cin & Program Structure - In C++, cout prints to the screen and cin reads input, both using << and >>. Every program runs from main(). This replaces C's printf/scanf with a cleaner style. #include <iostream> using namespace std; int main() { cout << "LedgerLens ready" << endl; return 0; }
• Level 2. Variables, Types & Operators - Variables hold typed values: int (whole), double (decimal, best for money math here), bool (true/false), string (text). Operators do arithmetic and comparison. #include <iostream> #include <string> using namespace std; int main() { double amount = 49.99; string category = "Food"; cout << category << ": " << amount << endl; return 0; }
• Level 3. Decisions & Loops - if/else-if/switch choose paths; for/while/do-while repeat. Together they drive the interactive menu that keeps running until the user exits. #include <iostream> using namespace std; int main() { bool running = true; while (running) { cout << "1) Add 2) Exit" << endl; running = false; } return 0; }
• Level 4. Functions, Overloading & Default Arguments - Functions group reusable logic. Overloading lets two functions share a name but take different parameters. Default arguments let a parameter fall back to a preset value if the caller omits it. #include <iostream> using namespace std; void addExpense(double amount) { cout << amount << endl; } int main() { addExpense(50); return 0; }
• Level 5. References vs Pointers - Both let you work with the original variable instead of a copy. A pointer stores an address and uses * and &; a reference is a simpler alias to an existing variable using &. References are cleaner for passing big data without copying. This is a Memory Radar lesson. #include <iostream> using namespace std; void addExpense(double amount, double &total) { total += amount; } int main() { double total = 0; addExpense(50, total); cout << total << endl; return 0; }
• Level 6. std::string & Vectors - std::string handles text safely with built-in methods (length, comparison, concatenation). std::vector is a resizable array that grows on demand with push_back - no fixed size limit. #include <iostream> #include <vector> using namespace std; int main() { vector<double> expenses; expenses.push_back(49.99); cout << expenses.size() << endl; return 0; }
• Level 7. Structs vs Classes & Encapsulation - A class bundles data AND the functions that act on it. Encapsulation means keeping data private and exposing controlled public methods, so nothing can corrupt an object's state from outside. This is where OOP begins. #include <iostream> using namespace std; class Expense { double amount; public: double getAmount() { return amount; } };
• Level 8. Inheritance & Polymorphism - Inheritance lets a class reuse another's members (a RecurringExpense IS-A Expense). Polymorphism lets the same method call behave differently depending on the actual object type, via virtual functions. #include <iostream> using namespace std; class Expense { public: virtual void describe() { cout << "Expense" << endl; } }; class RecurringExpense : public Expense { public: void describe() override { cout << "Recurring" << endl; } };
• Level 9. Range Loops, auto & Dynamic Memory - Range-based for loops and auto make iteration clean and readable. new/delete are C++'s manual memory tools - useful to understand, though vector usually handles it for you. #include <iostream> #include <vector> using namespace std; int main() { vector<double> expenses = {10, 20}; for (auto &e : expenses) e *= 1.1; return 0; }
• Level 10. STL Algorithms - The Standard Template Library gives ready-made algorithms - sort, accumulate, max_element, count_if - that work on vectors so you don't hand-write common operations. #include <numeric> #include <vector> using namespace std; int main() { vector<double> v = {10, 20, 30}; double total = accumulate(v.begin(), v.end(), 0.0); return 0; }
• Level 11. File Handling (fstream) - ofstream writes to a file, ifstream reads from one. This is how LedgerLens saves your expenses on exit and loads them again next time. #include <fstream> using namespace std; int main() { ofstream out("expenses.txt"); out << "50,Food,Lunch\n"; out.close(); return 0; }

How you submit: Coding quests solved in the built-in EchoLens compiler.

Who it's for

CS-102: Fundamentals of C++ (with OOP) suits learners at a beginner to intermediate level who want a practical, project-based route into CS-102. You need only a browser and an internet connection - all coding runs inside the EchoLens compiler, so there is nothing to set up.

Certificate

Finish every stage and EchoLens issues a verified certificate carrying a QR code anyone can scan to confirm it on our site. You can add it to your CV or share it to LinkedIn in one click.