Updates from Overleaf

HappyCerberus · HappyCerberus · commit 66863c68fbd0 · 2022-09-19T10:11:13.000+02:00
diff --git a/book.tex b/book.tex
@@ -38,13 +38,17 @@
 \mainmatter
 \tableofcontents
 
-\input{chapters/02_introduction} % In review
+%\input{chapters/02_introduction} % In review
 %\input{chapters/03_algorithms_00_main} % In review
 %\input{chapters/04_ranges_in_depth} % In review
 
+\input{chapters/90_theory} % TODO
+
 \appendix
 \input{chapters/XX_index}
 
+% Section on iterator invalidation
+
 \backmatter
 
 \end{document}
diff --git a/chapters/02_introduction.tex b/chapters/02_introduction.tex
@@ -10,11 +10,12 @@ \section{History of standard \texorpdfstring{\CC}{C++} algorithms}
 
 The \CC98 standard introduced most of the algorithms. However, it was the \CC11 standard with its introduction of lambdas that made algorithms worthwhile. Before lambdas, the time investment of writing a custom function object made the usefulness of algorithms dubious.
 
-\begin{box-note}
+\raggedbottom
+\begin{box-nobreak}
 \footnotesize Example of \cpp{std::for_each}\index{\cpp{std::for_each}} algorithm with a custom function object, calculating the number of elements and their sum.
 \tcblower
 \cppfile{code_examples/introduction/history_cc98_code.h}
-\end{box-note}
+\end{box-nobreak}
 
 \begin{box-note}
 \footnotesize Example of \cpp{std::for_each}\index{\cpp{std::for_each}} algorithm with a capturing lambda, calculating the number of elements and their sum.
@@ -153,3 +154,8 @@ \section{A simpler mental model for iterators}
 
 Even when the algorithm returns an iterator to a specific element, it might be worth considering the implied range.
 
+\begin{box-note}
+\footnotesize Example of \cpp{std::find} establishing a prefix range that doesn't contain the searched-for element.
+\tcblower
+\cppfile{code_examples/introduction/mental_find_code.h}
+\end{box-note}
diff --git a/chapters/03_algorithms_01_foreach.tex b/chapters/03_algorithms_01_foreach.tex
@@ -7,7 +7,7 @@ \section{Introducing the algorithms}
 \begin{enumerate}[label=\protect\circled{\arabic*}]
     \item The presentation of each algorithm will start with a short description.
     \item The margin will contain information about the history of the algorithm: which C++ standard introduced it and whether it has constexpr, parallel and range variants and including versions of the standard that introduced them.
-    \item Following that will be the description of constraints. Algorithms that write data to a distinct output range are denoted with an arrow: \cpp{input_range -> output_range}.
+    \item Following that will be the description of constraints. Algorithms that write data to a distinct output range are denoted with an arrow: \newline\cpp{input_range -> output_range}.
     \item Finally, each description will conclude with one or more examples with explanations.
 \end{enumerate}
 
@@ -36,7 +36,7 @@ \subsection{\texorpdfstring{\cpp{std::for_each}}{\texttt{std::for\_each}}}
 \end{tabular}
 \end{center}
 
-\circled{4} The C++11 standard introduced the range loop, which mostly replaced the uses of \cpp{std::for_each}.
+\circled{4} The C++11 standard introduced the range-based for loop, which mostly replaced the uses of \cpp{std::for_each}.
 
 \begin{box-note}
 \footnotesize Example of a range loop over all elements of a \cpp{std::vector}.
@@ -52,7 +52,7 @@ \subsection{\texorpdfstring{\cpp{std::for_each}}{\texttt{std::for\_each}}}
 
 However, there are still a few corner cases when using \cpp{std::for_each} is preferable.
 
-The first case is straightforward parallelization. Invoking an expensive operation for each element in parallel is trivial with \cpp{std::for_each}. On top of that, as long as the operations are independent, there is no need for synchronization primitives.
+The first case is straightforward parallelization. Invoking an expensive operation for each element in parallel is trivial with \cpp{std::for_each}. As long as the operations are independent, there is no need for synchronization primitives.
 
 \begin{box-note}
 \footnotesize Example of a parallel \cpp{std::for_each} invoking a method on each element independently in parallel.
@@ -63,7 +63,7 @@ \subsection{\texorpdfstring{\cpp{std::for_each}}{\texttt{std::for\_each}}}
 Second, the range version can provide a more concise and explicit syntax in some cases because of the projection support introduced in C++20.
 
 \begin{box-note}
-\footnotesize Example of the range version \cpp{std::ranges::for_each} utilizing a projection to iterate over the result of invoking the method \cpp{getValue()} on each element.
+\footnotesize Example of the range version of \cpp{std::ranges::for_each}  utilizing a projection to invoke the method \cpp{getValue()} (line 13) on each element and summing the resulting values using a lambda (line 12).
 \tcblower
 \cppfile{code_examples/algorithms/for_each_code_cpp20.h}
 \end{box-note}
diff --git a/chapters/90_theory.tex b/chapters/90_theory.tex
@@ -0,0 +1,13 @@
+\chapter{In-depth}
+
+In this chapter, we will go over relevant in-depth topics referenced throughout the rest of the book.
+
+\section{Argument-dependent lookup (ADL)}
+
+When calling a method without qualification (i.e. not specifying the namespace), the compiler needs to determine the set of candidate functions. As a first step, the compiler will do an unqualified name lookup, which starts at the local scope and examines the parent scopes until it finds the first instance of the name (at which point it stops).
+
+\begin{box-note}
+\footnotesize Example of unqualified lookup. Both calls to \cpp{some_call} will resolve to \cpp{::A::B::some_call} since this is the first instance discovered by the compiler.
+\tcblower
+\cppfile{code_examples/theory/adl_unqualified.h}
+\end{box-note}
diff --git a/packages/color_blocks.tex b/packages/color_blocks.tex
@@ -12,4 +12,17 @@
     after skip = 0.5cm,      % add extra space after the box
     drop fuzzy shadow = black!35,
     fontupper=\sffamily
+}
+
+\newtcolorbox{box-nobreak}{
+    sharpish corners, % better drop shadow
+    boxrule = 0pt,
+    toprule = 4.5pt, % top rule weight
+    enhanced,
+    enlarge top by=5pt,
+    colback = white,
+    before skip = 0.2cm,    % add extra space before the box
+    after skip = 0.5cm,      % add extra space after the box
+    drop fuzzy shadow = black!35,
+    fontupper=\sffamily
 }
