Skip to content

ROADMAP C++¤

1. FOUNDATIONS - CƠ BẢN¤

1.1 Cài đặt và Setup¤

  • Cài đặt compiler (GCC, Clang, MSVC)
  • IDE/Editor (Visual Studio, CLion, VS Code, Qt Creator)
  • Build systems (CMake, Make, Ninja)
  • Compilation process
  • Hello World với cout

1.2 C++ cơ bản (nếu chưa biết C)¤

  • Variables và data types
  • Operators
  • Control flow (if, switch, loops)
  • Functions
  • Arrays
  • Pointers và references
  • Basic I/O (cin, cout)

1.3 C++ vs C - Điểm khác biệt¤

  • cout/cin thay printf/scanf
  • References
  • Function overloading
  • Default parameters
  • Namespace
  • bool type
  • new/delete thay malloc/free
  • Inline functions
  • const correctness

2. OBJECT-ORIENTED PROGRAMMING (OOP)¤

2.1 Classes và Objects¤

  • Class definition
  • Member variables (attributes)
  • Member functions (methods)
  • Access specifiers (private, public, protected)
  • Constructors
  • Destructor
  • this pointer
  • const member functions
  • Static members
  • Friend functions và friend classes

2.2 Constructors Deep Dive¤

  • Default constructor
  • Parameterized constructor
  • Copy constructor
  • Move constructor (C++11)
  • Constructor delegation
  • Explicit constructors
  • Constructor initialization lists
  • Uniform initialization (C++11)

2.3 Encapsulation¤

  • Data hiding
  • Getters và setters
  • Private implementation
  • PIMPL idiom (Pointer to Implementation)

2.4 Inheritance¤

  • Single inheritance
  • Multiple inheritance
  • Protected access specifier
  • Constructor/destructor calling order
  • Diamond problem
  • Virtual inheritance
  • Upcasting và downcasting
  • Object slicing

2.5 Polymorphism¤

  • Function overloading (compile-time)
  • Operator overloading
  • Virtual functions (runtime polymorphism)
  • Pure virtual functions
  • Abstract classes
  • Virtual destructors
  • Virtual function tables (vtable)
  • Override keyword (C++11)
  • Final keyword (C++11)
  • Dynamic binding

2.6 Abstraction¤

  • Interfaces (pure virtual classes)
  • Abstract base classes
  • Design by contract

3. OPERATOR OVERLOADING¤

3.1 Overloadable Operators¤

  • Arithmetic operators (+, -, *, /, %)
  • Comparison operators (==, !=, <, >, <=, >=)
  • Logical operators (&&, ||, !)
  • Bitwise operators
  • Assignment operator (=)
  • Compound assignment (+=, -=, etc.)
  • Increment/decrement (++, --)
  • Subscript operator ([])
  • Function call operator ()
  • Arrow operator (->)
  • Stream operators (<<, >>)

3.2 Rules và Best Practices¤

  • Member vs non-member operators
  • Return types
  • Const correctness
  • Symmetry trong operators
  • Rule of Three/Five/Zero

4. MEMORY MANAGEMENT¤

4.1 Dynamic Memory¤

  • new và delete
  • new[] và delete[]
  • Memory leaks
  • Dangling pointers
  • Placement new
  • nothrow new

4.2 RAII (Resource Acquisition Is Initialization)¤

  • RAII principle
  • Smart pointers preview
  • Automatic cleanup
  • Exception safety

4.3 Copy Control¤

  • Copy constructor
  • Copy assignment operator
  • Move constructor (C++11)
  • Move assignment (C++11)
  • Rule of Three
  • Rule of Five
  • Rule of Zero

5. TEMPLATES¤

5.1 Function Templates¤

  • Template syntax
  • Template parameters
  • Template instantiation
  • Template specialization
  • Function template overloading
  • Type deduction

5.2 Class Templates¤

  • Template class definition
  • Member function templates
  • Template specialization (full)
  • Partial specialization
  • Default template arguments
  • Template template parameters

5.3 Advanced Templates¤

  • Variadic templates (C++11)
  • Template metaprogramming
  • SFINAE (Substitution Failure Is Not An Error)
  • Template constraints (C++20 concepts)
  • Type traits
  • Compile-time computation

6. STANDARD TEMPLATE LIBRARY (STL)¤

6.1 Containers¤

  • Sequence containers:
  • vector
  • deque
  • list
  • forward_list (C++11)
  • array (C++11)
  • Associative containers:
  • set, multiset
  • map, multimap
  • Unordered containers (C++11):
  • unordered_set, unordered_multiset
  • unordered_map, unordered_multimap
  • Container adapters:
  • stack
  • queue
  • priority_queue

6.2 Iterators¤

  • Iterator categories (input, output, forward, bidirectional, random access)
  • begin(), end()
  • Iterator operations
  • Iterator invalidation
  • Reverse iterators
  • const iterators

6.3 Algorithms¤

  • Non-modifying:
  • find, find_if, count, count_if
  • all_of, any_of, none_of
  • for_each
  • Modifying:
  • copy, move, swap
  • fill, generate
  • transform
  • replace, remove
  • Sorting:
  • sort, stable_sort
  • partial_sort
  • nth_element
  • Binary search:
  • binary_search
  • lower_bound, upper_bound
  • Set operations:
  • set_union, set_intersection
  • merge
  • Heap operations:
  • make_heap, push_heap, pop_heap
  • Min/Max:
  • min, max, minmax
  • min_element, max_element

6.4 Function Objects (Functors)¤

  • Function objects
  • Predicate functions
  • Lambda expressions (C++11)
  • std::function (C++11)
  • std::bind (C++11)
  • Callable objects

6.5 Utilities¤

  • pair
  • tuple (C++11)
  • optional (C++17)
  • variant (C++17)
  • any (C++17)
  • string_view (C++17)

7. SMART POINTERS (C++11)¤

7.1 Types¤

  • unique_ptr
  • shared_ptr
  • weak_ptr
  • auto_ptr (deprecated)

7.2 Usage¤

  • make_unique (C++14)
  • make_shared
  • Custom deleters
  • Ownership semantics
  • Circular reference problems
  • Performance considerations

8. EXCEPTION HANDLING¤

8.1 Basics¤

  • try-catch blocks
  • throw statement
  • Exception types
  • Standard exceptions
  • catch-all handler
  • Rethrowing exceptions

8.2 Advanced¤

  • Exception specifications (deprecated)
  • noexcept (C++11)
  • Exception safety guarantees
  • Stack unwinding
  • RAII và exceptions
  • Custom exception classes
  • Exception handling best practices

9. STREAMS AND I/O¤

9.1 Stream Classes¤

  • iostream hierarchy
  • istream, ostream
  • ifstream, ofstream, fstream
  • istringstream, ostringstream, stringstream

9.2 Stream Operations¤

  • Formatted I/O
  • Stream manipulators (setw, setprecision, etc.)
  • Stream states
  • File operations
  • Binary I/O
  • Stream buffers
  • Custom stream manipulators

9.3 File I/O¤

  • Opening/closing files
  • Reading/writing text
  • Reading/writing binary
  • File positioning
  • Error handling

10. MOVE SEMANTICS & RVALUE REFERENCES (C++11)¤

10.1 Rvalue References¤

  • Lvalues vs rvalues
  • Rvalue reference syntax (&&)
  • std::move
  • Perfect forwarding
  • Universal references
  • Reference collapsing

10.2 Move Semantics¤

  • Move constructor
  • Move assignment operator
  • Move-only types
  • Return value optimization (RVO)
  • Named return value optimization (NRVO)

11. MODERN C++ FEATURES¤

11.1 C++11 Features¤

  • auto keyword
  • decltype
  • Range-based for loops
  • nullptr
  • constexpr
  • static_assert
  • Delegating constructors
  • Inheriting constructors
  • Default và deleted functions
  • Enum classes (strongly typed enums)
  • Raw string literals
  • User-defined literals
  • Attributes
  • Initializer lists

11.2 C++14 Features¤

  • Generic lambdas
  • Return type deduction
  • Variable templates
  • Binary literals
  • Digit separators
  • std::make_unique
  • Relaxed constexpr

11.3 C++17 Features¤

  • Structured bindings
  • if/switch with initializer
  • constexpr if
  • Fold expressions
  • std::optional
  • std::variant
  • std::any
  • std::string_view
  • Filesystem library
  • Parallel algorithms
  • Class template argument deduction (CTAD)

11.4 C++20 Features¤

  • Concepts
  • Ranges
  • Coroutines
  • Modules
  • Three-way comparison operator (<=>)
  • consteval, constinit
  • std::span
  • Calendar và timezone
  • std::format
  • Designated initializers

11.5 C++23 Features¤

  • Deducing this
  • if consteval
  • Multidimensional subscript operator
  • std::expected
  • std::mdspan
  • Stack trace library

12. LAMBDA EXPRESSIONS¤

12.1 Lambda Basics¤

  • Lambda syntax
  • Capture lists (by value, by reference)
  • Parameters
  • Return type
  • Mutable lambdas

12.2 Advanced Lambdas¤

  • Generic lambdas (C++14)
  • Init capture (C++14)
  • constexpr lambdas (C++17)
  • Template lambdas (C++20)
  • Lambda capture của this
  • Stateless lambdas

13. CONCURRENCY & MULTITHREADING (C++11)¤

13.1 Threads¤

  • std::thread
  • Thread creation
  • Joining và detaching
  • Thread arguments
  • Thread IDs
  • Hardware concurrency

13.2 Synchronization¤

  • std::mutex
  • std::recursive_mutex
  • std::timed_mutex
  • std::lock_guard
  • std::unique_lock
  • std::scoped_lock (C++17)
  • Deadlock prevention
  • std::call_once

13.3 Condition Variables¤

  • std::condition_variable
  • Wait và notify
  • Spurious wakeups
  • Producer-consumer pattern

13.4 Atomic Operations¤

  • std::atomic
  • Memory ordering
  • Lock-free programming
  • Compare-and-swap
  • Atomic flags

13.5 Async Programming¤

  • std::async
  • std::future
  • std::promise
  • std::packaged_task
  • std::shared_future

13.6 Thread-Safe Containers¤

  • Concurrent queue patterns
  • Lock-free data structures
  • Thread pools

14. TYPE TRAITS & METAPROGRAMMING¤

14.1 Type Traits¤

  • Type categories
  • Type properties
  • Type transformations
  • Type relationships
  • SFINAE với enable_if
  • Constexpr if (C++17)

14.2 Template Metaprogramming¤

  • Compile-time computation
  • Recursive templates
  • Tag dispatching
  • Policy-based design
  • Expression templates

14.3 Concepts (C++20)¤

  • Defining concepts
  • Requires expressions
  • Requires clauses
  • Standard concepts
  • Concept composition

15. DESIGN PATTERNS¤

15.1 Creational Patterns¤

  • Singleton
  • Factory Method
  • Abstract Factory
  • Builder
  • Prototype
  • Object Pool

15.2 Structural Patterns¤

  • Adapter
  • Bridge
  • Composite
  • Decorator
  • Facade
  • Flyweight
  • Proxy
  • PIMPL

15.3 Behavioral Patterns¤

  • Chain of Responsibility
  • Command
  • Iterator
  • Mediator
  • Memento
  • Observer
  • State
  • Strategy
  • Template Method
  • Visitor

15.4 Modern C++ Idioms¤

  • RAII
  • Copy-and-swap
  • Curiously Recurring Template Pattern (CRTP)
  • Barton-Nackman trick
  • Expression templates
  • Type erasure
  • Tag dispatching

16. STANDARD LIBRARY DEEP DIVE¤

16.1 String Processing¤

  • std::string
  • String operations
  • String streams
  • Regular expressions (std::regex)
  • String algorithms

16.2 Numerics¤

16.3 Time & Date¤

  • std::chrono (C++11)
  • Duration
  • Time points
  • Clocks
  • Calendar (C++20)

16.4 Filesystem (C++17)¤

  • Path operations
  • Directory iteration
  • File status
  • File operations
  • Permissions

17. ADVANCED TOPICS¤

17.1 Custom Memory Management¤

  • Overloading new/delete
  • Placement new
  • Custom allocators
  • Memory pools
  • STL allocators
  • Polymorphic allocators (C++17)

17.2 Name Lookup¤

  • Argument-dependent lookup (ADL)
  • Qualified name lookup
  • Unqualified name lookup
  • Two-phase lookup

17.3 Type System¤

  • Type conversions
  • static_cast
  • dynamic_cast
  • const_cast
  • reinterpret_cast
  • RTTI (typeid, type_info)

17.4 Undefined Behavior¤

  • Common UB scenarios
  • How to avoid UB
  • Sanitizers (AddressSanitizer, UBSan)

18. PERFORMANCE & OPTIMIZATION¤

18.1 Optimization Techniques¤

  • Inlining
  • Return value optimization
  • Move semantics
  • constexpr computations
  • Template specialization
  • Cache-friendly code
  • Branch prediction
  • Loop optimization

18.2 Profiling¤

  • Profiling tools (gprof, Valgrind, perf)
  • Benchmarking (Google Benchmark)
  • Memory profiling
  • CPU profiling
  • Cache profiling

18.3 Performance Best Practices¤

  • Pass by reference
  • Reserve capacity
  • Avoid unnecessary copies
  • Use appropriate containers
  • Algorithm selection
  • Compile-time computation

19. TESTING & DEBUGGING¤

19.1 Testing Frameworks¤

  • Google Test
  • Catch2
  • Boost.Test
  • doctest
  • Unit testing
  • Integration testing
  • Mocking (Google Mock)

19.2 Debugging¤

  • GDB
  • LLDB
  • Visual Studio Debugger
  • Debugging techniques
  • Watchpoints
  • Conditional breakpoints
  • Core dumps

19.3 Static Analysis¤

  • Clang-Tidy
  • Cppcheck
  • PVS-Studio
  • Static analyzers

19.4 Code Coverage¤

  • gcov/lcov
  • Coverage tools
  • Coverage-driven testing

20. BUILD SYSTEMS & TOOLS¤

20.1 CMake¤

  • CMakeLists.txt
  • Targets
  • Dependencies
  • Generator expressions
  • Find modules
  • Config files
  • Modern CMake practices

20.2 Package Managers¤

  • Conan
  • vcpkg
  • Hunter

20.3 Development Tools¤

  • Compiler explorers (Godbolt)
  • Code formatters (clang-format)
  • Linters
  • Documentation (Doxygen)
  • Version control (Git)

21. LIBRARIES & FRAMEWORKS¤

21.1 Boost¤

  • Boost overview
  • Smart pointers (legacy)
  • String algorithms
  • Filesystem (legacy)
  • Asio (networking)
  • Spirit (parsing)
  • Graph
  • Multi-threading utilities

21.2 GUI Frameworks¤

  • Qt
  • wxWidgets
  • GTK+
  • Dear ImGui

21.3 Networking¤

  • Boost.Asio
  • POCO
  • Socket programming
  • HTTP libraries

21.4 Database¤

  • SQLite
  • MySQL/MariaDB connectors
  • PostgreSQL
  • ORM libraries

21.5 Graphics¤

  • OpenGL
  • Vulkan
  • DirectX
  • SDL
  • SFML

21.6 Game Development¤

  • Unreal Engine
  • Unity (via bindings)
  • Custom engines

21.7 Scientific Computing¤

  • Eigen (linear algebra)
  • Armadillo
  • Intel MKL
  • BLAS/LAPACK

22. SPECIALIZED DOMAINS¤

22.1 Systems Programming¤

  • OS interaction
  • Process management
  • System calls
  • Low-level programming

22.2 Embedded C++¤

  • Embedded constraints
  • Real-time systems
  • Hardware interfaces
  • Bare metal programming

22.3 High-Performance Computing¤

  • Parallel algorithms
  • OpenMP
  • MPI
  • CUDA (GPU programming)

22.4 Financial Computing¤

  • Low-latency systems
  • Numerical precision
  • Financial libraries

22.5 Game Development¤

  • Game loops
  • Entity-Component Systems
  • Physics engines
  • Rendering pipelines

23. BEST PRACTICES & GUIDELINES¤

23.1 Coding Standards¤

  • C++ Core Guidelines
  • Google C++ Style Guide
  • MISRA C++
  • AUTOSAR C++
  • Company-specific standards

23.2 Modern C++ Best Practices¤

  • Prefer RAII
  • Use smart pointers
  • Prefer algorithms to loops
  • Use const correctness
  • Avoid raw pointers
  • Prefer standard library
  • Use auto judiciously
  • Value semantics

23.3 Code Quality¤

  • SOLID principles
  • DRY (Don't Repeat Yourself)
  • KISS (Keep It Simple, Stupid)
  • YAGNI (You Aren't Gonna Need It)
  • Code reviews
  • Refactoring

24. INTEROPERABILITY¤

24.1 C Interop¤

  • extern "C"
  • Using C libraries
  • Name mangling
  • ABI compatibility

24.2 Other Languages¤

  • Python bindings (pybind11, Boost.Python)
  • C# interop
  • Java JNI
  • JavaScript (Emscripten, WebAssembly)

24.3 Platform-Specific¤

  • Windows API
  • POSIX
  • Platform abstraction layers

25. REAL-WORLD PROJECTS¤

25.1 Project Ideas¤

  • CLI applications
  • Web server
  • Database engine
  • Game engine
  • Compiler/Interpreter
  • Text editor
  • Image processor
  • Network chat application
  • HTTP client/server
  • File compression tool
  • Memory allocator
  • Container library
  • JSON parser
  • HTTP parser
  • Thread pool
  • Logger library

25.2 Open Source¤

  • Contributing to projects
  • Reading large codebases
  • Popular C++ projects (LLVM, Chromium, Qt, etc.)

LỘ TRÌNH HỌC ĐỀ XUẤT¤

Tháng 1-2: Foundations, C++ basics, OOP fundamentals Tháng 3: Advanced OOP, Operator overloading, Memory management Tháng 4: Templates, STL containers và algorithms Tháng 5: Smart pointers, Exception handling, I/O Tháng 6: Move semantics, Modern C++ (C++11/14) Tháng 7: Lambda expressions, Multithreading basics Tháng 8: Advanced concurrency, Type traits Tháng 9: C++17/20/23 features, Design patterns Tháng 10: Performance optimization, Testing Tháng 11: Build systems, Libraries exploration Tháng 12: Specialized domains, Real projects Ongoing: Advanced topics, Best practices, Open source

TÀI LIỆU HỌC¤

Sách cơ bản: - C++ Primer (Lippman) - Programming: Principles and Practice Using C++ (Stroustrup) - A Tour of C++ (Stroustrup)

Sách nâng cao: - Effective C++ (Meyers) - More Effective C++ (Meyers) - Effective Modern C++ (Meyers) - Effective STL (Meyers) - C++ Concurrency in Action (Williams) - The C++ Programming Language (Stroustrup)

Design & Architecture: - Design Patterns (Gang of Four) - Modern C++ Design (Alexandrescu) - C++ Templates: The Complete Guide - Large-Scale C++ Software Design

Best Practices: - C++ Core Guidelines - Exceptional C++ (Sutter) - C++ Coding Standards (Sutter & Alexandrescu)

Online Resources: - cppreference.com - isocpp.org - CppCon talks - Compiler Explorer (godbolt.org)