This C++ learning guide is incredibly precise! The combination of high-quality courses on Bilibili and classic books perfectly addresses the issue of “beginners learning chaotically and becoming more confused”. It is especially suitable for those with zero foundation or those who want to systematically improve. The core key is “deepening by stages + hands-on practice”, breaking down the goals of each stage into actionable steps to help you avoid six months of detours.

1. Basic Introduction (Friendly for Beginners): Master Core Syntax in 3 Months and Establish Object-Oriented Thinking

Core Goal: Transition from “not knowing how to code” to “being able to write simple programs independently”, focusing on “syntax proficiency + understanding of object-oriented concepts”.

• How to Use the Courses:
• “C++20 from Beginner to Expert”: Spend the first week setting up the development environment (recommended VS2022/Clion), and follow the course to code examples step by step—such as variables, loops, functions. For each knowledge point learned, write 3 small demos (printing prime numbers, sorting arrays, simple calculators);
• “Detailed Explanation of Modern C++ Features”: After mastering the basic syntax, focus on lambda expressions and smart pointers (shared_ptr/unique_ptr). Rewrite previous small projects using smart pointers to avoid memory leaks.
• Book Pairing:
• “C++ Primer”: No need to read it word for word; study the corresponding chapters according to the course schedule. For example, when learning about “classes and objects”, refer to Chapter 7, focusing on understanding the practical applications of “encapsulation, inheritance, and polymorphism”;
• “Effective C++”: Read this after getting started, memorizing 10 core guidelines (such as “prefer using const and enum” and “avoid returning references to local objects”) to cultivate good coding habits.
• Hands-On Practice:
• Write a “Student Management System” to implement “add/delete/query student information”, using classes, inheritance, and containers (vector) to practice syntax while understanding object-oriented concepts.

2. Data Structures and Algorithms (Core for Interviews): Solidify “Job Market Currency” in 2 Months

Core Goal: Master the underlying STL containers + classic algorithms to handle medium-difficulty questions in major company written tests.

• How to Use the Courses:
• “STL Source Code Analysis”: First learn to use containers (vector, map, list), then look at the underlying implementations—such as the dynamic expansion mechanism of vector and the red-black tree structure of map, understanding “why vector has fast random access and list has fast insertion and deletion”;
• “LeetCode High-Frequency Algorithm Intensive”: Practice problems tagged by “array → linked list → binary tree → dynamic programming”, tackling one medium problem each day. For example, after learning binary trees, practice “level order traversal of binary trees”; after learning DP, practice “longest increasing subsequence”.
• Book Pairing:
• “Introduction to Algorithms”: No need to delve deeply into mathematical derivations; focus on the core ideas of “divide and conquer, greedy algorithms, dynamic programming”, and understand algorithm logic in conjunction with the course;
• “Cracking the Coding Interview”: After practicing basic LeetCode problems, tackle the problems in this book, which are closely aligned with interviews at major companies, ensuring to write at least 2 solutions for each problem (brute force + optimized).
• Hands-On Practice:
• Implement a “hash table” and a “binary search tree” using STL containers, then use these structures to solve algorithm problems (e.g., optimize “two-sum” using a hash table), reinforcing the connection between “data structures + algorithms”.

3. System Design (1-2 Years of Foundation): Break Through the Bottleneck of “System-Level Development” in 3 Months

Core Goal: Master multithreading, memory management, and high-performance optimization, transitioning from “writing features” to “writing stable and efficient code”.



• How to Use the Courses:
• “C++ Concurrency in Action”: Learn about atomic operations, mutexes, and condition variables, and write a “multithreaded ticket selling system” to understand thread synchronization and data race issues;
• “High-Performance C++ Development”: Focus on cache optimization (principle of locality) and SIMD instruction acceleration, using these techniques to optimize previous algorithm problems (e.g., cache optimization for sorting algorithms), comparing performance differences before and after optimization.
• Book Pairing:
• “C++ Concurrency in Action”: Read this alongside the course to gain a deeper understanding of thread pools and the implementation principles of asynchronous tasks;
• “Computer Systems: A Programmer’s Perspective (CSAPP)”: Study the chapters on memory management and concurrent programming, combining C++ features to understand the underlying logic of “stack/heap” and “process/thread”.
• Hands-On Practice:
• Implement a “simple thread pool” that supports task submission and thread reuse, utilizing mutexes and condition variables to experience programming techniques in high-concurrency scenarios.

4. Project Practice (Essential for High Salaries): Accumulate “Enterprise-Level Experience” in 2 Months

Core Goal: Complete projects with technical increments to make your resume stand out and meet workplace demands.

• How to Use the Courses:
• “Implementing STL from Scratch”: Handwrite a mini version of vector, map, and string containers to understand the core interfaces and underlying implementations of containers, enhancing coding skills;
• “High-Concurrency Server Development”: Learn epoll, socket programming, and thread pools, and implement an “HTTP server” from scratch—supporting client request reception, HTTP protocol parsing, and static page returns, mastering network programming and high-concurrency handling techniques.
• Book Pairing:
• “Linux Multithreaded Server Programming”: Focus on “thread pool design” and “network IO models”, understanding the norms and techniques of enterprise-level development in conjunction with the server project.
• Hands-On Practice:
• Project 1: Handwrite miniSTL, implementing the construction, destruction, iterators, and core interfaces (push_back, erase, etc.) of containers;
• Project 2: High-concurrency HTTP server, integrating thread pools and epoll IO multiplexing, deploying to a Linux server, testing concurrent connection numbers, and recording performance metrics (such as QPS).
• Bonus Techniques:
• Upload projects to GitHub, write clear READMEs (technology stack, functional modules, optimization points), and note “thread pool optimized concurrency performance” and “epoll improved IO efficiency”.

5. Cutting-Edge Technologies (Advanced Improvement): Learn as Needed to Broaden Technical Boundaries

Core Goal: Master new features of C++20/23 to adapt to cutting-edge development needs and enhance competitiveness.

• How to Use the Courses:
• “C++ Coroutines in Action”: Learn co_await/co_yield, rewrite “asynchronous network requests” using coroutines, and understand the advantages of coroutines in high-concurrency scenarios;
• “Advanced Template Metaprogramming”: Learn SFINAE and Concepts, write generic template functions (such as a generic sorting function that supports different types of arrays), enhancing code reusability.
• Book Pairing:
• “C++ Template Metaprogramming”: Understand the core ideas of template metaprogramming without delving into complex syntax, focusing on the application scenarios of “compile-time computation”;
• “Practical C++20”: Master new features such as modules, ranges, and concepts, and rewrite previous small projects using C++20 to experience the efficiency improvements brought by new features.

Core Pitfall Reminders:

1. Don’t just watch the courses without coding: C++ syntax is complex, especially pointers and memory management. Hands-on coding is essential to discover issues (such as memory leaks and dangling pointers);
2. Don’t blindly chase new features: First solidify the core features of C++11/14 (smart pointers, lambda), then learn C++20/23 to avoid having a weak foundation while being obsessed with obscure features;
3. Don’t work on “toy projects”: Prioritize projects with “technical increments” (such as thread pools and HTTP servers) over “student management systems” to better showcase your abilities.

Final Thoughts:

The key to learning C++ is “deepening by stages + continuous hands-on practice”. The courses on Bilibili can help you avoid detours, while classic books can solidify your foundation. However, true improvement comes from “every line of code you write and every bug you solve”. From zero foundation to practical skills, six months is sufficient, but it requires 1-2 hours of effective learning every day, rejecting “pretending to work hard”.