Click any module to expand the full topic list. Every topic includes live trainer instruction, hands-on coding on the platform, and assessment. The syllabus covers C++11/14/17/20 — not just legacy C++.
What C++ adds to C, setting up the toolchain, and writing your first C++ program
Bjarne Stroustrup's vision. How C++ evolved from "C with classes" to a modern multi-paradigm language. Key standards: C++11 (the big one), C++14, C++17, C++20. What each standard added and why it matters.
Namespaces, references, bool type, function overloading, new/delete vs malloc/free. When to use C++ features vs C-style code. Understanding "zero-cost abstractions."
g++ compiler, compilation flags (-std=c++17, -Wall, -O2), linking. Understanding the build process. CMake basics for multi-file projects. Setting up VS Code / CLion / Code::Blocks.
std:: namespace, why "using namespace std" exists, when it's acceptable and when it's harmful (header files). Creating custom namespaces. Namespace aliasing.
Stream-based I/O vs printf. Chaining operators (<<, >>). Input buffer issues. Using getline() for string input. Formatting output with setw, setprecision, fixed.
What a reference IS (an alias, not a pointer). Reference declaration (&), pass-by-reference, const references. When to use references vs pointers — a decision that comes up in every code review.
Type system, control structures, and building modular code with functions
Primitive types, type modifiers, const correctness. The auto keyword (C++11) — type deduction for variables, iterators, and lambda return types. decltype for expression type deduction.
static_cast, dynamic_cast, const_cast, reinterpret_cast — what each does, when to use which. Why C-style casts are discouraged in C++. Compile-time vs runtime casting.
if/else, switch, for, while, do-while — C++ additions: if with initialiser (C++17), range-based for loops (C++11) for containers. Structured bindings in if/switch (C++17).
Function overloading (same name, different parameters), default parameter values, inline functions. How the compiler resolves overloaded calls (name mangling).
Three ways to pass arguments — trade-offs of each. const reference for large objects (avoiding copy without allowing modification). Return by value vs reference.
Recursive patterns in C++. constexpr (C++11/14) — compile-time function evaluation. Writing functions that compute at compile time: constexpr factorial, Fibonacci. if constexpr (C++17).
Classes, objects, encapsulation, constructors, destructors, and the this pointer
Class definition, member variables, member functions. Object creation (stack vs heap). Accessing members with dot (.) and arrow (->). Struct vs class in C++ (default access).
Constructor types, initialiser lists (why they matter for const/reference members), delegating constructors (C++11). Deep copy vs shallow copy — the classic interview question.
When destructors are called, manual resource cleanup, virtual destructors (critical for inheritance). What happens without virtual destructors — memory leaks in polymorphic code.
private, protected, public — information hiding principles. Getter/setter pattern. Why encapsulation matters for large-scale software. Access control with inheritance.
What this is (pointer to current object), when to use it (disambiguation, method chaining, returning *this). this in constructors and destructors.
Class-level data and functions. Static member initialisation. Use cases: counters, singleton pattern, utility functions. Static const members.
Breaking encapsulation deliberately — when and why. Operator overloading with friend functions. Friend class access. Why overusing friend is a design smell.
Marking methods as const (promise not to modify the object). mutable keyword. Why const correctness matters — "const is a contract with the caller." Interview favourite.
Code reuse, runtime dispatch, and designing extensible class hierarchies
Base and derived classes, protected members, constructor chaining. IS-A relationship. When to use inheritance vs composition (favour composition — the design principle).
Inheriting from multiple base classes. The ambiguity problem (diamond inheritance). Virtual inheritance as the solution. Why Java avoided multiple class inheritance entirely.
Compile-time: function overloading + operator overloading. Runtime: virtual functions + vtable mechanism. How the compiler implements dynamic dispatch under the hood.
virtual keyword, override specifier (C++11), final keyword (C++11). How vtable works — the pointer-to-function-table mechanism. Performance implications of virtual calls.
Declaring pure virtual functions (= 0). Abstract classes as interfaces. Why you can't instantiate abstract classes. Designing class hierarchies with abstract base classes.
Overloading +, -, ==, <<, >>, [], (). Member function vs non-member (friend) overloading. Rules: can't create new operators, can't change precedence. Overloading << for custom output.
If you define a destructor, copy constructor, or copy assignment — define all three (Rule of Three). With move semantics, add move constructor and move assignment (Rule of Five). Or let the compiler do everything (Rule of Zero).
Heap allocation, RAII pattern, and modern C++ ownership semantics
C++ dynamic allocation — constructor invocation, type safety, array allocation with new[]. Why new is preferred over malloc in C++. Placement new for advanced use.
The most important C++ idiom. Tying resource lifetime to object lifetime. Why RAII eliminates memory leaks by design. Examples: file handles, mutex locks, database connections.
Lvalues vs rvalues. Rvalue references (&&). std::move — transferring ownership instead of copying. Why move semantics make C++ dramatically faster for large objects (vectors, strings).
Exclusive ownership — one owner, automatic cleanup. std::make_unique (C++14). Moving unique_ptr (can't copy). The default smart pointer for single ownership.
Reference-counted shared ownership. std::make_shared. Circular reference problem and how weak_ptr breaks cycles. Performance: reference counting overhead. When to use shared vs unique.
Dangling pointers, double delete, use-after-free, memory leaks. Using Valgrind, AddressSanitizer, and -fsanitize=leak. Why raw owning pointers are considered a code smell in modern C++.
Writing type-independent code — the foundation of STL
Writing one function for any type — template<typename T>. Template argument deduction. Explicit specialisation. Templates vs function overloading — when to use which.
Generic classes: template<class T> class Stack {}; Member function definitions outside the class. Template parameters: type and non-type (int N). Default template arguments.
Full specialisation for specific types. Partial specialisation for class templates. Why specialisation matters — optimising for specific types (e.g., vector<bool>).
Templates accepting any number of arguments — template<typename... Args>. Parameter pack expansion. Building type-safe printf, tuple implementation basics.
Containers, iterators, algorithms, and functors — the competitive programming toolkit
vector (dynamic array), deque (double-ended), list (doubly linked), array (fixed). When to use each. Internal implementation, time complexities, and iterator invalidation rules.
Ordered containers backed by red-black trees. O(log n) insert/find. Key uniqueness rules. Custom comparators. Practical use: frequency maps, sorted storage, interval problems.
Hash-table-backed O(1) average insert/find. Hash functions, bucket structure, load factor. When unordered beats ordered (and when it doesn't — worst case O(n)). Custom hash for pairs/structs.
Stack (LIFO), queue (FIFO), priority_queue (max-heap by default). Custom comparator for min-heap: priority_queue<int, vector<int>, greater<int>>. Dijkstra's algorithm uses this.
Iterator categories: input, output, forward, bidirectional, random access. begin/end, rbegin/rend, cbegin/cend. Iterator arithmetic. Range-based for as iterator sugar.
sort, stable_sort, binary_search, lower_bound, upper_bound, find, count, accumulate, transform, for_each, next_permutation, min_element, max_element. The 20 algorithms every competitive programmer memorises.
std::pair for key-value storage, std::tuple for multiple returns, structured bindings (C++17): auto [x, y] = myPair; Practical use in graph edges, coordinate pairs, function returns.
String operations: substr, find, rfind, replace, compare. String streams (stringstream) for parsing. to_string and stoi/stof for conversions. String vs char[] — always prefer std::string in C++.
Lambda expressions, error handling, file operations, and C++17/20 features
Anonymous functions: [capture](params) -> ret { body }. Capture by value [=], by reference [&], specific captures. Lambdas as arguments to STL algorithms. Lambdas as custom comparators for sort and priority_queue.
Throwing and catching exceptions. Standard exception hierarchy (std::exception, std::runtime_error). Custom exception classes. Exception safety guarantees: basic, strong, nothrow. noexcept specifier.
Reading/writing text and binary files. File open modes (ios::in, ios::out, ios::app, ios::binary). Checking file state (is_open, eof, fail). Serialisation patterns.
optional: representing "may or may not have a value" (replacing raw pointers for optional data). variant: type-safe union. any: type-erased container. Modern alternatives to C-style hacks.
Constraining template parameters: template<std::integral T>. Writing custom concepts. How concepts replace SFINAE for readable, maintainable template code. The future of generic programming.
Composable, lazy range operations: views::filter, views::transform, views::take. Pipeline syntax with |. How ranges modernise STL algorithm usage. Practical examples.
Splitting C++ programs across .cpp and .hpp files. #pragma once vs include guards. Separate compilation, forward declarations, and managing dependencies in larger projects.
Design a shape/vehicle/banking class hierarchy with inheritance, polymorphism, and operator overloading.
Implement stack, queue, and linked list as template classes with iterators — understanding how STL works under the hood.
100+ problems solved using vector, map, set, priority_queue, and STL algorithms — competitive coding style.
Build a resource manager using unique_ptr and shared_ptr, demonstrating RAII and automatic cleanup.
Student record system or contact manager using file I/O, custom classes, and exception handling.
Timed coding sessions using C++ STL — 3 problems in 60 minutes, mimicking placement coding rounds.
Expert trainers explain concepts, code live, and solve OOP design problems interactively. 3–5 sessions per week.
Daily C++ problems on our platform — STL-based, OOP-based, and competitive coding problems with g++ compiler and automated testing.
MCQ tests on OOP theory + timed coding challenges. Auto-evaluated with topic-wise analytics showing which concepts need reinforcement.
Student-wise dashboards tracking OOP concept mastery, STL fluency, and coding speed. TPOs see batch-level C++ readiness.
Codeforces, CodeChef, LeetCode — the overwhelming majority of top competitive programmers code in C++. The STL (vectors, maps, sets, priority queues, sort, binary_search) gives a speed advantage no other language matches in contests and timed placement coding round
Google, Amazon, Microsoft, DE Shaw, Flipkart — when interviewers say "write code," C++ is the most accepted language for DSA solutions. Its speed, STL, and precise memory control make it the default for algorithm-heavy interviews.
Virtual functions, vtable, inheritance types, operator overloading, constructors/destructors, friend functions — C++ OOP concepts are the most frequently tested MCQ topics across TCS, Wipro, Cognizant, and Infosys placement tests.
Samsung, Qualcomm, Nvidia, Adobe, Oracle, game studios — systems programming, embedded systems, graphics engines, and high-performance computing are C++ domains. For students targeting these companies, C++ is non-negotiable.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
