C++ Notes A Comprehensive Guide From Classic To Modern C++

Hey guys! Welcome to this comprehensive guide outlining C++ notes, spanning from the classic versions all the way to Modern C++ (including C++23). This guide is designed to help you navigate the C++ landscape, whether you're a beginner or an experienced developer looking to brush up on the latest features. So, let’s dive in and explore what this powerful language has to offer!

UPDATED: 2025.08

PART A: C++ Release ~ C++ 11

This section focuses on the foundational aspects of C++ up to the C++11 standard. We'll cover the core concepts and features that have made C++ a staple in software development for decades. Understanding these basics is crucial before moving on to the more modern features.

第一部分: 基本介绍 (Part 1: Basic Introduction)

In this basic introduction to C++, we'll lay the groundwork for your C++ journey. We'll start with the history and evolution of C++, highlighting its significance in the programming world. Knowing the background helps appreciate the design choices and the reasons behind certain features. This section will cover the fundamental syntax, data types, and operators in C++. We’ll delve into how to declare variables, perform arithmetic operations, and understand the basic building blocks of a C++ program. The goal is to get you comfortable writing simple C++ programs. We'll also cover preprocessors and header files, explaining how they are used to include libraries and manage code. Understanding these elements is essential for organizing larger projects. Setting up your development environment is the first practical step. We’ll guide you through installing a C++ compiler (like g++ or Clang) and an IDE (such as Visual Studio Code, Code::Blocks, or CLion). A properly configured environment is vital for a smooth coding experience. Finally, we’ll write your first “Hello, World!” program. This classic example will walk you through the compilation and execution process, solidifying your understanding of the basic workflow. Remember, every great journey starts with a single step, and this program is yours in the C++ world. This foundational knowledge will serve as the bedrock for more advanced topics, so it's crucial to grasp these concepts firmly. As you progress, you'll see how these basic elements combine to create powerful applications. So, stay curious, keep practicing, and you'll be well on your way to mastering C++!

第二部分: 循环与分支结构 (Part 2: Loops and Branching Structures)

Loops and branching structures are the control flow mechanisms that dictate how your program executes. They are the core of any programming language, allowing you to create dynamic and responsive applications. Understanding how to use them effectively is crucial for writing efficient and logical code. We’ll start with if, else if, and else statements, explaining how to create conditions that determine which code blocks execute. Mastering conditional statements is essential for making decisions within your program. We'll then move on to different types of loops: for, while, and do-while loops. Each type has its use cases, and we’ll explore when to use each one for optimal performance and readability. The for loop is perfect for iterating a known number of times, the while loop for repeating a block as long as a condition is true, and the do-while loop for ensuring a block executes at least once. Controlling loop execution is another critical skill. We’ll cover the break and continue statements, explaining how they can alter the flow of a loop. break allows you to exit a loop prematurely, while continue skips the current iteration and moves to the next. Real-world examples will help you see how these control structures are used in practice. We’ll look at scenarios like validating user input, searching through data, and implementing simple algorithms. These practical applications will solidify your understanding. Common pitfalls and best practices will also be discussed. Understanding potential issues, like infinite loops or incorrect conditions, can save you hours of debugging. We'll share tips on writing clean, efficient, and bug-free code. By mastering loops and branching, you’ll gain the ability to create programs that can handle complex logic and adapt to different situations. These control structures are the building blocks of more advanced algorithms and data structures, so make sure you understand them thoroughly!

第三部分: 函数式编程 (Part 3: Functional Programming)

Functional programming in C++ introduces a paradigm shift from imperative programming, focusing on functions as first-class citizens. This approach promotes cleaner, more modular, and easier-to-test code. While C++ is primarily an object-oriented language, it has incorporated many functional programming features, especially since C++11. We’ll begin by defining what a function is and how it works in C++. Functions are the basic units of code, encapsulating a specific task. Understanding how to define, call, and pass data to functions is essential. The concept of function overloading will also be covered, allowing you to define multiple functions with the same name but different parameters. Lambda expressions, a cornerstone of functional programming in C++, will be explored. Lambdas are anonymous functions that can be defined inline, making your code more concise and flexible. We’ll show you how to use them effectively in various scenarios. Function pointers and function objects (functors) will also be discussed. These features allow you to treat functions as data, passing them as arguments to other functions or storing them in variables. This is a powerful technique for creating flexible and generic code. Higher-order functions, which take other functions as arguments or return them as results, will be examined. These functions are crucial for implementing functional programming patterns like map, filter, and reduce. We’ll also look at examples of using functional programming techniques to solve real-world problems. This will include scenarios like data processing, event handling, and asynchronous programming. By embracing functional programming, you can write more maintainable and scalable code. The principles of immutability, pure functions, and avoiding side effects, which are central to functional programming, will be emphasized. These concepts help reduce bugs and make your code easier to reason about. Mastering functional programming in C++ will broaden your programming toolkit and enable you to write more elegant and efficient code. It’s a valuable skill that complements the object-oriented features of C++ and opens up new possibilities in your projects.

第四部分: 类设计与OOP (Part 4: Class Design and OOP)

Class design and Object-Oriented Programming (OOP) are fundamental concepts in C++. Classes are the blueprint for creating objects, and OOP principles allow you to organize your code in a modular, reusable, and maintainable way. This section will dive deep into how to design effective classes and leverage OOP to build robust applications. We'll start with the basics: what a class is, and how to define one in C++. Classes encapsulate data (attributes) and behavior (methods). Understanding this encapsulation is the foundation of OOP. Creating objects (instances of a class) and accessing their members will be covered next. You’ll learn how to create objects, how to use the dot operator to access their attributes and methods, and how memory is managed. Access control (public, private, protected) is crucial for data encapsulation. We’ll explain the differences between these access modifiers and how to use them to control visibility and protect your data. Constructors and destructors, special methods that handle object creation and destruction, are essential for managing resources. We’ll explore how to define these methods and their importance in preventing memory leaks and other issues. The core OOP principles – encapsulation, inheritance, and polymorphism – will be thoroughly discussed. Encapsulation hides internal details, inheritance allows you to create new classes based on existing ones, and polymorphism allows objects of different classes to be treated as objects of a common type. Inheritance, including single and multiple inheritance, will be examined in detail. You’ll learn how to create class hierarchies and how to use inheritance to reuse code and create specialized classes. Polymorphism, achieved through virtual functions and abstract classes, will be another key topic. Understanding polymorphism is crucial for writing flexible and extensible code. We’ll also cover best practices for class design, including the Single Responsibility Principle (SRP), the Open/Closed Principle (OCP), and the Liskov Substitution Principle (LSP). These principles will guide you in creating well-designed, maintainable classes. Practical examples of designing classes for real-world problems will be provided. This will include scenarios like modeling data structures, implementing algorithms, and creating user interfaces. By mastering class design and OOP, you’ll be able to create complex software systems with ease. These concepts are essential for any C++ developer, and a solid understanding will greatly enhance your ability to write high-quality code.

第五部分: C++标准库&STL (Part 5: C++ Standard Library & STL)

Exploring the C++ Standard Library and the Standard Template Library (STL) is like discovering a treasure chest of pre-built tools and functionalities. These libraries provide a vast collection of classes and functions that can significantly speed up your development process and improve the efficiency of your code. We’ll start with an overview of the C++ Standard Library, which includes headers for input/output, string manipulation, algorithms, and more. Understanding the scope of the library is crucial for knowing what tools are available to you. The STL, a subset of the Standard Library, is a collection of template classes for common data structures and algorithms. We’ll dive deep into the STL, exploring its components and how to use them effectively. Containers are a fundamental part of the STL. We’ll cover different types of containers, such as vectors, lists, deques, sets, and maps, and when to use each one. Understanding the strengths and weaknesses of each container is essential for choosing the right tool for the job. Algorithms in the STL provide powerful ways to manipulate data. We’ll explore algorithms for sorting, searching, transforming, and more. Learning how to use these algorithms can save you a lot of time and effort. Iterators are used to traverse containers and provide a generic way to access elements. We’ll cover different types of iterators and how to use them to work with containers and algorithms. Function objects (functors) are another important part of the STL. They allow you to pass functions as arguments to algorithms, providing flexibility and customization. We’ll also cover string manipulation using the std::string class, which provides a powerful and flexible way to work with text. Input/output operations using streams (iostream) will be explored as well. Understanding how to read and write data to files and the console is essential for any program. Error handling and exception handling, using try, catch, and throw, will be discussed. Robust error handling is crucial for writing reliable software. Practical examples of using the STL to solve common programming problems will be provided. This will include scenarios like data processing, algorithm implementation, and more. By mastering the C++ Standard Library and the STL, you’ll significantly enhance your productivity and write more efficient code. These libraries are essential tools for any C++ developer, and a thorough understanding will greatly benefit your projects.

第六部分: 高级特性 (Part 6: Advanced Features)

Advanced C++ features unlock the potential for creating highly efficient, robust, and sophisticated applications. These features delve into more complex aspects of the language, allowing you to optimize performance, manage resources effectively, and implement advanced design patterns. This section will cover several key advanced topics that will elevate your C++ skills. We’ll start with pointers and dynamic memory management, which are crucial for optimizing memory usage and handling complex data structures. Understanding how pointers work, how to allocate memory using new and delete, and how to avoid memory leaks is essential for writing high-performance code. Smart pointers, introduced in C++11, provide a safer way to manage dynamic memory. We’ll cover unique_ptr, shared_ptr, and weak_ptr, and how they help prevent memory leaks and dangling pointers. Multithreading and concurrency, allowing you to run multiple tasks simultaneously, will be explored. Understanding how to create and manage threads, how to use mutexes and locks to prevent race conditions, and how to synchronize threads is crucial for writing concurrent applications. Template metaprogramming (TMP), a powerful technique for generating code at compile time, will be discussed. TMP allows you to write highly generic and efficient code, but it also requires a deep understanding of templates and the C++ type system. We’ll also cover exception handling in detail, including best practices for throwing and catching exceptions, and how to design exception-safe code. Understanding how to handle errors gracefully is essential for writing robust software. Rvalue references and move semantics, introduced in C++11, enable efficient resource transfer and optimization of object copying. We’ll explore how these features work and how they can improve the performance of your code. Custom allocators, which allow you to control memory allocation at a granular level, will be discussed. Understanding how to write custom allocators can be beneficial for optimizing memory usage in specific scenarios. Practical examples of using these advanced features in real-world applications will be provided. This will include scenarios like optimizing performance-critical sections of code, managing large data structures, and implementing concurrent algorithms. By mastering these advanced features, you’ll be able to tackle complex programming challenges and write highly optimized C++ code. These topics are essential for any experienced C++ developer looking to push the boundaries of what’s possible with the language.

第七部分: 杂项拓展 (Part 7: Miscellaneous Extensions)

In this section of miscellaneous extensions, we’ll cover a variety of C++ features and topics that don't fit neatly into the previous categories but are still valuable to know. These extensions can enhance your C++ skills and provide you with a more comprehensive understanding of the language. We’ll start by exploring inline functions, which can improve performance by reducing function call overhead. Understanding when and how to use inline functions can lead to significant optimizations. The const keyword and its various uses will be discussed in detail. const is crucial for writing safer and more predictable code, and we’ll cover how to use it with variables, pointers, member functions, and more. Namespaces, which help organize code and prevent naming conflicts, will be explored. Understanding how to use namespaces is essential for managing large projects. We’ll also cover operator overloading, which allows you to define the behavior of operators for your custom classes. This can make your code more intuitive and readable. Friend functions and classes, which allow you to grant access to private members, will be discussed. Understanding when and how to use friends is important for maintaining encapsulation while allowing flexibility. The preprocessor and preprocessor directives, such as #include, #define, and #ifdef, will be explored. Knowing how to use the preprocessor is essential for conditional compilation and code management. We’ll also cover various coding standards and best practices, including naming conventions, commenting styles, and code formatting. Adhering to coding standards improves code readability and maintainability. Debugging techniques and tools, such as gdb and debuggers in IDEs, will be discussed. Mastering debugging skills is crucial for identifying and fixing errors in your code. We’ll also look at C++ and system-level programming, including topics like system calls, file I/O, and network programming. Understanding how C++ interacts with the operating system can be beneficial for certain types of applications. Practical examples of using these miscellaneous features in real-world scenarios will be provided. This will include scenarios like optimizing performance, managing code complexity, and interacting with the operating system. By exploring these miscellaneous extensions, you’ll gain a more complete understanding of C++ and be better equipped to tackle a wide range of programming challenges. These topics are valuable for any C++ developer looking to expand their knowledge and skills.

PART B: Modern C++ (Including C++23)

This part shifts our focus to Modern C++, encompassing features introduced from C++11 onwards, up to the latest C++23 standard. Modern C++ brings significant improvements in terms of performance, safety, and expressiveness, making it a joy to work with. It's all about writing cleaner, more efficient, and more maintainable code.

第一部分: 重新入门与新特性 (Part 1: Re-entry and New Features)

Re-entering C++ with new features is an exciting journey, especially with the significant advancements introduced in Modern C++. This section will focus on the key features that have transformed C++ since C++11, making it more powerful and user-friendly. We’ll start with an overview of Modern C++, highlighting the major changes and improvements compared to classic C++. Understanding the evolution of the language is crucial for appreciating the new features. Auto type deduction, using the auto keyword, simplifies code and reduces verbosity. We’ll explore how auto works and how it can improve code readability. Range-based for loops provide a more concise and readable way to iterate over containers. We’ll cover how to use range-based for loops and their benefits. Lambda expressions, a cornerstone of functional programming, were introduced in C++11 and have been further enhanced in later standards. We’ll delve into lambda expressions and their use cases. Smart pointers (unique_ptr, shared_ptr, weak_ptr) provide a safer way to manage dynamic memory. We’ll explore how to use smart pointers to prevent memory leaks and dangling pointers. Move semantics and rvalue references enable efficient resource transfer and optimization of object copying. We’ll cover how these features work and how they can improve performance. The std::thread library makes multithreading easier and more portable. We’ll explore how to create and manage threads using std::thread. The constexpr keyword allows you to perform computations at compile time, improving performance. We’ll cover how to use constexpr for compile-time evaluation. Concepts, introduced in C++20, provide a way to constrain template parameters, making template code easier to use and debug. We’ll explore the basics of concepts and how they enhance generic programming. Modules, a major feature introduced in C++20, improve build times and code organization. We’ll cover the basics of modules and how to use them in your projects. Practical examples of using these new features in real-world scenarios will be provided. This will include scenarios like simplifying code, optimizing performance, and improving code safety. By embracing these new features, you’ll be able to write more modern, efficient, and maintainable C++ code. These features are essential for any C++ developer looking to stay current with the language and leverage its full potential.

第二部分: 新的类设计与OOP (Part 2: New Class Design and OOP)

Modern C++ has brought significant enhancements to class design and OOP, making it easier to write clean, efficient, and maintainable object-oriented code. This section will focus on the new features and best practices for designing classes in Modern C++. We’ll start with an overview of the changes in OOP introduced in Modern C++, including new keywords and features that enhance class design. Defaulted and deleted functions allow you to control the generation of special member functions (constructors, destructors, copy/move operators). We’ll explore how to use these features to manage object lifecycle and prevent common errors. Delegating constructors allow one constructor to call another within the same class, reducing code duplication. We’ll cover how to use delegating constructors to simplify class initialization. The override and final keywords improve code safety and readability in inheritance hierarchies. We’ll explore how these keywords help prevent common inheritance-related issues. Strong typing for enums (enum class) provides better type safety and prevents implicit conversions. We’ll cover how to use enum class for safer and more maintainable code. Uniform initialization, using curly braces {}, provides a consistent way to initialize objects. We’ll explore the benefits of uniform initialization and how it simplifies code. Structured bindings, introduced in C++17, allow you to unpack tuples and other complex objects into individual variables. We’ll cover how to use structured bindings to make your code more readable. Compile-time if statements (if constexpr) allow you to conditionally compile code based on compile-time constants. We’ll explore how to use compile-time if statements for advanced template programming. The Rule of Zero, a guideline for class design that simplifies resource management, will be discussed. Adhering to the Rule of Zero can help you write more robust and maintainable classes. Practical examples of designing classes using these new features will be provided. This will include scenarios like creating smart containers, implementing design patterns, and more. By embracing these new features and best practices, you’ll be able to write more modern, efficient, and maintainable object-oriented C++ code. These enhancements are essential for any C++ developer looking to create high-quality software.

第三部分: 新的模板库 (Part 3: New Template Library)

The evolution of the C++ Standard Template Library (STL) in Modern C++ has brought new containers, algorithms, and utilities that significantly enhance the power and flexibility of the language. This section will focus on the additions and improvements to the STL, making it an even more valuable tool for C++ developers. We’ll start with an overview of the new features in the STL, highlighting the additions and improvements since C++11. New containers, such as std::array, std::unordered_map, and std::unordered_set, provide additional options for data storage and retrieval. We’ll explore these new containers and their use cases. Improved algorithms, such as std::for_each_n, std::sample, and parallel algorithms, enhance the efficiency and flexibility of data processing. We’ll cover these new algorithms and how they can simplify your code. The std::tuple class allows you to group multiple values into a single object, providing a powerful way to return multiple values from a function. We’ll explore how to use tuples and structured bindings to simplify code. The std::variant class allows you to hold a value of one of several types, providing a type-safe alternative to unions. We’ll cover how to use variants to write more flexible code. The std::optional class provides a way to represent a value that may or may not be present, making it easier to handle optional values. We’ll explore how to use optionals to avoid null pointer errors. File system library (std::filesystem), introduced in C++17, provides a portable way to interact with the file system. We’ll cover the basics of using the file system library for file and directory manipulation. Concurrency features, such as std::future and std::async, make it easier to write concurrent code. We’ll explore these features and how they can improve the performance of your applications. Ranges, a major addition to the STL in C++20, provide a more composable and efficient way to work with sequences of data. We’ll cover the basics of ranges and how they can simplify your code. Practical examples of using these new template library features in real-world scenarios will be provided. This will include scenarios like data processing, algorithm implementation, and more. By embracing these new features, you’ll be able to write more modern, efficient, and maintainable C++ code. These enhancements are essential for any C++ developer looking to leverage the full power of the language.

PART C: 应用 (PART C: Applications)

This final section focuses on the practical applications of C++ in various domains. We’ll explore how C++ is used in different industries and for different types of projects. Understanding the versatility of C++ is key to appreciating its long-standing relevance in the programming world.