==============================
== What I have learnt today ==
==============================

A list of C++ topics

In Jason Turner’s C++ Weekly Ep 348, he listed out an extensive C++ topics. Understanding these topics makes equips you with expert level C++ knowledge. BUT DOES NOT make you in C++ (programming). The entire video is about building a lambda function, from simple to complex, and different versions.

Here is list of topics:

  1. lambdas (C++11)
  2. struct (C++98)
  3. constexpr (C++11)
  4. operator overloading (C++98)
  5. call operator (C++98)
  6. const member functions (C++98)
  7. braced initialization (C++11)
  8. auto return type deduction (C++14)
  9. “compiler magic” at 3:33 he says “because inside our the call operator overload we cannot see the *this pointer of the lambda”
  10. function parameters (C++98)
  11. pass-by-value (C++98)
  12. attributes on parameters (C++11) e.g. [[maybe_unsed]]
  13. pass-by-reference (C++98)
  14. pass-by-value vs pass-by-reference (C++98)
  15. pre-increment vs post-increment
  16. trailing return types (C++11)
  17. class vs struct (C++98)
  18. private vs public (C++98)
  19. implicit conversions (C++98)
  20. function pointers (C++98)
  21. static member functions (C++98)
  22. using aliases (C++11)
  23. efficiency when chaining functions, 6:35 generic lambdas (C++14)
  24. templates (C++98)
  25. template argument type deduction (C++98)
  26. aias templates (C++11)
  27. template instantiations (C++98)
  28. noexcept (C++11)
  29. noexcept in the type system (C++17)
  30. variadic templates (C++11)
  31. variadic lambdas (C++14)
  32. fold expressions (C++17)
  33. function attributes (C++11)
  34. concepts (C++20) 8:47 to constrain the lambdas
  35. non-type template parameters (C++98)
  36. integer sequences (C++11)
  37. template parameter pattern matching (C++98)
  38. explicit lambda templates (C++17)
  39. tuples (C++11)
  40. unpacking of tuples (C++11)
  41. variadic sizeof...() operator (C++11)
  42. direct-initialization of members (C++11)
  43. mutable keyword (C++98)
  44. non-const member functions (C++98)
  45. reference members (C++98)
  46. member copies (C++98)
  47. object layout (C++98)
  48. member padding (C++98)
  49. order of construction/destruction (C++98)
  50. generalized lambda capture (C++14)
  51. immediately invoked lambdas (C++11)
  52. return value optimization (C++98)
  53. guaranteed return value optimization (C++17)
  54. initializer_list (C++11)
  55. recursive lambda (C++23)
  56. deducing this (C++23)
  57. recursive functions
  58. trivially copyable types (C++98)
  59. higher order functions
  60. dangling references
  61. undefined behavior 16:10 overloaded lambdas
  62. inheritance (C++98)
  63. multiple inheritance (C++98)
  64. function hiding (C++98)
  65. variadic using declarations (C++17)
  66. scoping / lookup rules (C++98)
  67. class template argument deduction (C++17/C++20)
  68. deduction guides (C++17)
  69. algorithms (C++11)
  70. ranges (C++20)
  71. <functional> (C++11)
  72. virtual member functions (C++98)
  73. member function pointers (C++98)
  74. special member functions (C++98/11)
  75. member function call syntax (C++98)
  76. type erasure (C++98)
  77. dynamic vs automatic storage (C++98)
  79. Missing
  81. writing your own concepts?
  82. type traits?
  83. operator <=>?
  84. protected?
  85. virtual inheritance
  86. compilation model
  87. ODR violations
  88. preprocessor
  89. project structure and layout
  90. the breadth of the standard library
  91. variable templates
  92. coroutines
  93. modules

From the comments of an user @darkmagic543, there are additional topics:

  1. exceptions, catch ellipse
  2. structured binding
  3. forward declaration
  4. namespaces
  5. rules of 5, default and nontrivial/virtual destructors
  6. memory, pointers and smart pointers
  7. iterators and writing your own iterator
  8. multithreading
  9. numeric
  10. explicit/implicit conversions
  11. castings, slicing
  12. variant & visitor
  13. abstract class (pure virtual), delete, final // default as well?
  14. consteval
  15. packages & libraries, cmake
  16. signed/unsigned arithmetic, bitwise operations, bitset

That is quite a list of topics.Jason has concluded at the end of the video, “and hopefully you can use this as a starting point for getting that expert levels C++ knowledge that you’ve been looking for”. This is what I am trying to achieve.

I know some of these topics, but it is my goal to know them all. I will use this as a check list of the progression of my C++ learning journey.