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

About this course

Streams and iostream, modern types (auto/const), std::string and std::vector, references and overloading, through to encapsulated classes with constructors, destructors and validated getters/setters.

This is a 6-week short course - enough depth to build real projects and a portfolio piece, without a long commitment. Learn online at your own pace. Practice the concepts with the listed assessments.

What's included

• Self-paced lessons and practice (12 estimated hours).
• 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 satisfy the course requirements.
• Completely free - no fee, just create an account and start.

What you will learn

Course outline - level by level

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

• Level 1. C++ Compilation & iostream - Real-life analogy: Think of upgrading an old mechanical typewriter to an automated publishing console. Instead of manually feeding characters, you connect an organized communication tube (iostream) that handles bidirectional text pipelines smoothly. C++ builds on C with stronger type safety, namespaces, and object abstractions. The preprocessor header #include <iostream> provides access to the standard input/output stream objects. Code is compiled by modern C++ compilers (like g++ or clang++) into high-performance native executables.
• Level 2. Namespaces & std::cout - Real-life analogy: In a school with two students named "Alex," calling "Alex" creates confusion. Adding their family surname - "Smith::Alex" or "Miller::Alex" - identifies the exact person. A namespace prevents name collisions across large software libraries. C++ organizes standard library symbols inside the std namespace. We access output streams using the scope resolution operator as std::cout with the stream insertion operator <<. The stream manipulator std::endl inserts a newline and immediately flushes the terminal output buffer.
• Level 3. std::cin Stream Input - Real-life analogy: Think of a mail conveyor belt pointing straight into your sorting bin. The stream extraction operator >> points toward the variable, seamlessly directing whatever comes off the conveyor directly into that storage slot without needing memory addresses. Unlike C's scanf which requires memory format specifiers (%d) and ampersands (&), C++ uses type-safe stream extraction with std::cin >> var. The compiler automatically determines variable types at compile-time and extracts tokens separated by whitespace.
• Level 4. Types, auto & const - Real-life analogy: A smart digital scale automatically knows whether it is measuring grams or kilograms based on what you drop onto the sensor plate. The auto keyword lets the compiler deduce the exact type automatically from its initial assignment value. C++ includes standard primitives (int, double, char, bool with literal true/false). Modern C++ introduces auto for automatic type deduction at compile-time. Constants declared with const or constexpr enforce compile-time immutability and optimize runtime memory layout.
• Level 5. std::string & Operations - Real-life analogy: A traditional C-string is like individual wooden alphabet blocks glued to a fixed 10-slot plank (it can easily overflow). A std::string is like magnetic alphabet letters on an infinitely expandable strip that grows or shrinks automatically. The std::string class provides dynamic, memory-managed string handling. It supports intuitive concatenation with the + operator, size querying via .length(), and robust line extraction with std::getline(std::cin, str) to read entire sentences with spaces.
• Level 6. std::vector Dynamic Arrays - Real-life analogy: Think of an accordion filing folder. When you add a new document, the folder stretches open another pocket automatically. You never need to declare a fixed size in advance. The std::vector<T> is a sequential, contiguous dynamic container from the Standard Template Library (STL). Elements are appended dynamically at the end in O(1) amortized time using .push_back(), indexed safely using .at() or [], and queried with .size().
• Level 7. Range-based for Loops - Real-life analogy: Think of a conveyor belt at airport baggage claim. Instead of counting "Bag 0, Bag 1, Bag 2," you simply stand in place and say "For every bag that rolls past me on this belt, inspect it." Modern C++ (C++11 and beyond) introduces range-based for loops: for (const auto& item : container). This eliminates manual indexing, off-by-one errors, and boundary checks by iterating directly over every element in an array, string, or vector cleanly.
• Level 8. C++ References (&ref) - Real-life analogy: Think of a nickname. "Robert" and "Bob" are two different names referring to the exact same human being. Giving Robert a glass of water is identical to giving Bob a glass of water. A reference (int& ref = x;) creates an alias for an existing variable. Unlike raw pointers, references cannot be NULL, cannot be uninitialized, and cannot be reseated to point to another object. They provide direct memory access with clean syntax without dereferencing syntax (*).
• Level 9. Function Overloading - Real-life analogy: Think of the word "Charge." If you are at an electronics store, "charge" means plug in a battery. If you are at a checkout counter, "charge" means debit an invoice. The context and parameters dictate the exact action. In C++, multiple functions can share the exact same name as long as their parameter lists differ in type or count. The compiler performs overload resolution at compile-time by inspecting argument signatures, eliminating ugly C-style workarounds like printInt(), printFloat().
• Level 10. Classes, Objects & Access - Real-life analogy: Think of an ATM machine. The money vault inside is private (customers cannot open it directly). The keypad and cash slot are public (authorized interfaces that safely interact with the internal cash). A class is a blueprint that combines state (member variables) and behavior (member methods). Encapsulation is enforced using access specifiers: private members are hidden from external access, while public members expose the safe interaction interface.
• Level 11. Constructors & Destructors - Real-life analogy: Buying a new smartphone automatically runs its initial setup wizard (a Constructor). When the phone is recycled years later, its internal storage is factory wiped clean (a Destructor). A Constructor has the same name as the class and runs automatically when an object is instantiated to initialize member variables. A Destructor (prefixed with ~) runs automatically when the object goes out of scope to release resources (the RAII pattern).
• Level 12. Getters, Setters & 'this' - Real-life analogy: A car's speedometer dial gives you a view of current speed (a Getter), while the gas pedal adjusts speed within safe engine limits (a Setter). The car's internal engine computer knows it is regulating this specific vehicle. Getters and Setters provide controlled access to private members, enforcing validation rules before updating state. The hidden this pointer points to the current calling object instance, allowing explicit disambiguation between member variables and constructor parameters.

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

Pass every required assessment at its stated threshold to earn your verified certificate. Optional practice and watching videos do not determine eligibility. Anyone can scan its QR code to verify it on our site. You can add it to your CV or share it to LinkedIn in one click.