C++ Programming
Start Date: February 27, 2026
Duration: 12 weeks
Total Seats: N/A
Seats Left: N/A
Master modern C++ in 3 months — go from complete beginner to confident intermediate developer ready for systems programming, games, or competitive coding! This structured, hands-on course builds rock-solid C++ skills with clear weekly progression, frequent mini-projects, and a powerful 15-day capstone where you design and build your own substantial application. Why choose this course: → Step-by-step from basics to OOP and STL — no prior experience needed → Emphasis on clean code, memory safety, and modern C++ features (C++11/14/17) → Mini-projects every 2 weeks to apply concepts immediately → Ends with a real capstone project: plan, code, debug, document, and present your own program (e.g., game, tool, simulator) Perfect for aspiring: - Systems programmers, game developers, or embedded engineers - Competitive programmers preparing for interviews or contests - Students/professionals needing high-performance language skills By the end you'll be able to: - Write efficient, readable C++ code with proper memory management - Use STL containers and algorithms fluently - Design object-oriented systems with classes, inheritance, polymorphism - Handle files, exceptions, and modular projects - Build and showcase a complete capstone application No coding background required
Who this course is for
- Absolute beginners with no prior programming experience
- Career switchers aiming for high-performance roles in software engineering, game development, or systems programming
- Computer science students building strong foundations for university or interviews
- Professionals from other languages wanting to learn C++ for speed-critical applications
- Competitive programming enthusiasts preparing for platforms like Codeforces, LeetCode, or contests
- Anyone interested in low-level control, memory management, and modern C++ best practices
- Self-motivated learners who want structured guidance + real projects over 3 months
What you’ll learn
- Build solid C++ programs from scratch using modern standards and best practices
- Master fundamental syntax: variables, data types, operators, I/O streams
- Control program execution with conditionals, loops, and switch statements
- Create reusable code with functions, overloading, references, and recursion
- Understand and safely use pointers, dynamic memory, and basic smart pointers
- Work fluently with arrays, strings, and STL containers (vector, map, set)
- Apply algorithms from the standard library (sort, find, etc.)
- Design object-oriented systems with classes, constructors, inheritance, polymorphism
- Implement encapsulation, abstraction, and basic operator overloading
- Handle errors and exceptions effectively in real applications
- Organize larger projects with multiple files, headers, and build tools
- Read from/write to files and persist data in simple formats
- Complete a full capstone project: from planning and design to implementation, testing, and documentation
- Debug C++ code using tools and techniques common in industry
- Gain confidence to continue with advanced topics like templates, concurrency, or game engines
Course Structure
- Introduction to C++: history, why C++ is still relevant (performance, systems programming, games)
- Setting up environment: compilers (g++, clang), IDEs (VS Code, CLion, Code::Blocks)
- First program: Hello World, basic structure (#include, int main(), cout, return 0)
- Variables and data types: int, float, double, char, bool, std::string
- Input/output: cin, cout, getline, formatting with setw/manipulators
- Operators: arithmetic, relational, logical, assignment, increment/decrement
- Comments, naming conventions, basic debugging with print statements
- Conditional statements: if, else if, else, switch
- Ternary operator and short-circuit evaluation
- Loops: while, do-while, for, range-based for (C++11+)
- Loop control: break, continue, nested loops
- Random numbers with <random> and <ctime>
- Mini-project: Number guessing game with hints and limited attempts
- Defining functions: parameters, return types, void functions
- Pass by value vs pass by reference (&)
- Function overloading and default parameters
- Scope and lifetime: local, global, static variables
- Recursion basics (factorial, Fibonacci)
- Organizing code: header files (.h/.hpp), source files, multiple files compilation
- Mini-project: Modular calculator with menu-driven interface
- Arrays: fixed-size, initialization, accessing elements
- Multi-dimensional arrays (2D for matrices)
- std::string operations: length, substr, find, concatenation
- Pointers: declaration, dereferencing (*), address-of (&)
- Pointer arithmetic and array-pointer relationship
- Dynamic memory: new/delete, avoiding leaks (intro to smart pointers later)
- Mini-project: Simple student grade tracker using arrays
- Vectors: dynamic arrays (push_back, size, at, erase)
- Pairs and tuples
- Maps and unordered_maps: key-value storage
- Sets and unordered_sets: unique elements
- Basic algorithms: sort, find, accumulate (from <algorithm>)
- Range-based loops with STL containers
- Mini-project: Contact book with search/add/remove using vectors/maps
- Classes and objects: member variables, member functions
- Constructors (default, parameterized, copy), destructors
- Access specifiers: public, private, protected
- Encapsulation and data hiding
- Inheritance: single, multi-level, base/derived classes
- Polymorphism: virtual functions, overriding, abstract classes (pure virtual)
- Operator overloading basics (e.g., << for output)
- Mini-project: Library management system (Book, User, Library classes)
- Project planning: requirements, design classes/diagrams, choose scope
- Setting up project: CMake or simple Makefile, folder structure, version control intro
- Core implementation – part 1: data models, classes, file I/O (save/load)
- Core implementation – part 2: main logic, user interface (console menu)
- Advanced features: error handling, exceptions, basic smart pointers (unique_ptr)
- Input validation, edge cases, debugging with gdb or IDE debugger
- Testing: manual tests, simple unit tests (intro to Google Test if time)
- Documentation: README, code comments, usage guide
- Refactoring and code cleanup for readability/performance
- Final polish: add features like search/filter, statistics
- Project presentation & self-review (record demo or write report)
Instructor
Vansh Thakur
Student Reviews
No reviews yet. Be the first to review!
No approved reviews yet.
Login to Enroll