C++ is a high-performance programming language that plays an important role in low-level development and high-performance computing. However, C++ is also a relatively difficult programming language to master; compared to other languages, it is harder to learn and master.
To help more students get started with C++, Deep Blue Academy has compiled this content based on the course “C++ Basics and In-Depth Analysis” by Dr. Li Wei, a senior engineer at Microsoft in the United States. This article aims to discuss the foundational knowledge of C++, focusing on the basic syntax of C++ and the underlying details behind the syntax, hoping to lay a solid foundation for students’ further study and use of C++.
1. What is the difference between initialization and assignment statements? What are the initialization methods for initialization lists?
2. How are data types aligned?
3. How to use pointers? What are the advantages and disadvantages of pointers?
4. Why do we still need vectors when we have arrays?
5. Why do we need expressions?
6. How does the compiler choose the correct version to complete a function call?
7. What types of iterators are there? In what scenarios do iterators become invalid?
8. What is the underlying implementation logic of lambda expressions?
9. What is the difference between metaprogramming and template programming?
10. What are the concepts and differences between scoped and unscoped enumerations?
For students who want to learn the complete course
Scan to addYuxin, and consult for more
11. What is C++’s Zero-Overhead Abstraction? How to achieve Zero-Overhead Abstraction? (Last page of Chapter 1 PPT)
12. What are the initialization methods for initialization lists? (Chapter 3, Section 1, Chapter 12, Section 4)
13. How are data types aligned? (Chapter 3, Section 2, 13-1)
14. Detailed explanation of why pointers are needed, how to use pointers, and the advantages and disadvantages of pointers? (Chapter 3, Section 3, Video at 48 minutes)
15. Why introduce references? What is the relationship between references and pointers? (Chapter 3, Section 3, Video at 48 minutes)
16. How to use pointer references, and what problems do they mainly solve? (Chapter 3, Section 3, Video at 1 hour 14 minutes)
17. Detailed explanation of the rules of type deduction, what are the benefits of type deduction? What is the use of type deduction with references? (Chapter 3, Section 5, 16)
18. Detailed explanation of why type aliases are needed? What are the two ways to use type aliases? What is the relationship between type aliases and pointers and references? (Chapter 3, Section 5, 16)
19. Detailed explanation of the use of arrays and precautions, what are the initialization methods? What problems exist? How to avoid implicit conversion between arrays and pointers? (Chapter 4, Section 1)
20. Why do we still need vectors when we have arrays? (Chapter 4, Section 2, 23)
21. Why do we need expressions? (Chapter 5, Section 2, 26) What is the difference between lvalues and rvalues? (Chapter 5, Section 2, 27) How to use short-circuit logic? (Chapter 5, Section 2, 30)
22. Explanation of the difference between constexpr and consteval functions? How to use them? (Chapter 7, Section 4, 54-3)
23. What is the difference between passing by value, address, and reference? What is type decay in the function parameter process? How does the function pass variable-length arguments? (Chapter 7, Section 2, 50)
24. Why introduce tail return? How to construct functions with different return types? How to use structured bindings for return types? Which return types cannot be structured bound? (Chapter 7, Section 2, 52)
25. How does the compiler choose the correct version to complete a function call? What are the function name lookup rules? (Chapter 7, Section 3)
26. C++ already has new for memory allocation and delete for memory destruction, why is the concept of smart pointers still needed? (Chapter 9, Section 2, 65-1)
27. Detailed explanation of the application scenarios and usage methods of shared_ptr, unique_ptr, and weak_ptr smart pointers. (Chapter 9, Section 2, 65-2, 65-3, 65-4)
28. What types of iterators are there? In what scenarios do iterators become invalid? (Chapter 10, Section 1, 68)
29. Detailed explanation of what associative containers are? What sequence containers are there? What is their underlying logic? How to use them? (Chapter 10, Sections 2 and 3)
30. What sequence and associative containers are there? How are they implemented at the underlying level? (Chapter 10, Sections 1, 2, 3)
31. What improvements have been made to generic algorithms ranges? How are they used? (Chapter 11, Sections 1, 74-1, 74-2, 74-3, 74-4)
32. What is the underlying implementation logic of lambda expressions? What are the ways to capture parameters, and what are their functions? (Chapter 11, Sections 2, 75-2, 75-3)
33. Why do we still need class types when we have struct types? What are the differences between them? (Chapter 12, Sections 1, 2)
34. Detailed explanation of class inheritance and the role and usage of virtual functions, and the underlying implementation logic of the virtual function table. (Chapter 13, Sections 2, 3)
35. What is empty base class optimization and the attribute [[no_unique_address]]? (Chapter 13, Section 3, 87-2)
36. What is the difference between function templates and template functions? Detailed explanation of the type deduction rules for template arguments and the rules for function matching. What is SFINAE? (Chapter 14, Section 1)
37. What are complete specialization and partial specialization of templates? How to specialize templates? How to use alias templates and variadic templates? (Chapter 14, Sections 2, 92-2, 94-2, 94-3)
38. Detailed explanation of concepts and usage of concepts and requires. (Chapter 14, Section 3)
39. Detailed explanation of the concepts of pack expansion and fold expressions, and how to use them? (Chapter 14, Section 4, 94-4)
40. Detailed explanation of the differences between metaprogramming and template programming? What techniques can reduce instantiation? What are the use cases of metaprogramming? (Chapter 15, Section 1)
42. What are the concepts and usage of nested classes and local classes? What are the roles and usage of nested namespaces and anonymous namespaces? (Chapter 16, Sections 3, 4)
43. What is the concept and usage of volatile? (Chapter 16, Section 5)
44. Detailed explanation of the usage and processing flow of exception handling. (Chapter 16, Section 1)
45. We already have enumeration types; why do we still need strong enumeration types? What are the concepts and differences between unscoped and scoped enumerations? (Chapter 16, Section 2, 104-1)
ABOUT
About Us
Deep Blue Academy is an online education platform focused on artificial intelligence, with tens of thousands of partners learning on the platform, many of whom come from well-known universities both domestically and abroad, such as Tsinghua University and Peking University.
