style: C++ style revised in chapter two, three, four and five

Author: oraqlle

src/appendix/B-operators.md

@@ -33,7 +33,7 @@ This page is a high level overview of C++ operators and other symbols and what t
 |    `%=`    |                 `var %= expr`                 |           Arithmetic remainder and assignment           |       ✅      |
 |    `~`     |                    `~expr`                    |                    Bitwise Complement                   |       ✅      |
 |    `&`     |                    `&expr`                    |                        Address of                       |       ✅      |
-|    `&`     |      `type ident&`, `type ident const&`       |                      Reference type                     |       ❌      |
+|    `&`     |      `type ident&`, `const type ident&`       |                      Reference type                     |       ❌      |
 |    `&`     |                 `expr & expr`                 |                       Bitwise AND                       |       ✅      |
 |    `&=`    |                 `var &= expr`                 |                Bitwise AND and assignment               |       ✅      |
 |    `&&`    |                 `expr && expr`                |                       Logical AND                       |       ☑️       |
@@ -72,7 +72,7 @@ This page is a high level overview of C++ operators and other symbols and what t
 |   Operator  |            Example           |                                Description                               |
 |:-----------:|:----------------------------:|:------------------------------------------------------------------------:|
 |    `new`    |    `new type (init-list)`    | Allocate a heap memory object constructed with parameters in *init-list* |
-|   `new []`  | `new type[size] {init-list}` |   Allocate a heap memory block initialized with elements in *init-list*  |
+|   `new []`  | `new type[size]{init-list}`  |   Allocate a heap memory block initialized with elements in *init-list*  |
 |   `delete`  |         `delete expr`        |                         Delete heap memory object                        |
 | `delete []` |       `delete [] expr`       |                         Deletes heap memory block                        |
 

src/ch02-guessing-game/guessing-game.md

@@ -241,9 +241,9 @@ which contains a bunch of facilities for generating random numbers. Update your
 auto main() -> int {
     std::cout << "Guessing Game!\n";
 
-    auto rd = std::random_device {};
-    auto gen = std::mt19937 { rd() };
-    auto distrib = std::uniform_int_distribution<unsigned> { 1u, 100u };
+    auto rd = std::random_device{};
+    auto gen = std::mt19937{rd()};
+    auto distrib = std::uniform_int_distribution<unsigned>{1u, 100u};
     const auto secret_number = distrib(gen);
 
     std::cout << "The secret number is: " << secret_number << '\n';
@@ -263,8 +263,8 @@ number generation types. Next we add the lines
 
 ```cpp,icon=%cplusplus,fp=main.cxx:8:10
     auto rd = std::random_device{};
-    auto gen = std::mt19937{ rd() };
-    auto distrib = std::uniform_int_distribution{ 1, 100 };
+    auto gen = std::mt19937{rd()};
+    auto distrib = std::uniform_int_distribution<unsigned>{1u, 100u};
 ```
 
 The first line (default) constructs a new `std::random_device`[^14]. This is a uniformly
@@ -280,7 +280,7 @@ This sets up our random number generator. To obtain a random number we can call
 distribution object, passing in the generator and returning a new random value.
 
 ```cpp,icon=%cplusplus,fp=main.cxx:11
-    auto const secret_number = distrib(gen);
+    const auto secret_number = distrib(gen);
 ```
 
 ## Comparing the Guess to the Secret Number
@@ -297,9 +297,9 @@ auto main() -> int {
     std::cout << "Guessing Game!\n";
 
     auto rd = std::random_device{};
-    auto gen = std::mt19937{ rd() };
-    auto distrib = std::uniform_int_distribution{ 1, 100 };
-    auto const secret_number = distrib(gen);
+    auto gen = std::mt19937{rd()};
+    auto distrib = std::uniform_int_distribution<unsigned>{1u, 100u};
+    const auto secret_number = distrib(gen);
 
     std::cout << "The secret number is: " << secret_number << '\n';
     std::cout << "Please input your guess: ";
@@ -407,9 +407,9 @@ auto main() -> int {
 $    std::cout << "Guessing Game!\n";
 $
 $    auto rd = std::random_device{};
-$    auto gen = std::mt19937{ rd() };
-$    auto distrib = std::uniform_int_distribution{ 1, 100 };
-$    auto const secret_number = distrib(gen);
+$    auto gen = std::mt19937{rd()};
+$    auto distrib = std::uniform_int_distribution{1, 100};
+$    const auto secret_number = distrib(gen);
 $
 $    std::cout << "The secret number is: " << secret_number << '\n';
 $    std::cout << "Please input your guess: ";
@@ -420,10 +420,10 @@ $
 
     try {
         guess = std::stoi(input);
-    } catch (std::invalid_argument const&) {
+    } catch (const std::invalid_argument&) {
         std::cerr << "Invalid input " << std::quoted(input) << "!\n";
         std::exit(0);
-    } catch (std::out_of_range const&) {
+    } catch (const std::out_of_range&) {
         std::cerr << "Input " << std::quoted(input) << " is too large!" << '\n';
         std::exit(0);
     }
@@ -484,9 +484,9 @@ auto main() -> int {
 $    std::cout << "Guessing Game!\n";
 $
 $    auto rd = std::random_device{};
-$    auto gen = std::mt19937{ rd() };
-$    auto distrib = std::uniform_int_distribution{ 1, 100 };
-$    auto const secret_number = distrib(gen);
+$    auto gen = std::mt19937{rd()};
+$    auto distrib = std::uniform_int_distribution{1, 100};
+$    const auto secret_number = distrib(gen);
 $
 $    std::cout << "The secret number is: " << secret_number << '\n';
 $    auto input = std::string{};
@@ -501,10 +501,10 @@ $        std::getline(std::cin, input);
 $
         try {
             guess = std::stoi(input);
-        } catch (std::invalid_argument const&) {
+        } catch (const std::invalid_argument&) {
             std::cerr << "Invalid input " << std::quoted(input) << "!\n";
             continue;
-        } catch (std::out_of_range const&) {
+        } catch (const std::out_of_range&) {
             std::cerr << "Input " << std::quoted(input) << " is too large!" << '\n';
             continue;
         }

src/ch02-guessing-game/main_cxx_17.cxx

@@ -8,8 +8,8 @@ auto main() -> int {
     std::cout << "Guessing Game!\n";
 
     auto rd = std::random_device{};
-    auto gen = std::mt19937{ rd() };
-    auto distrib = std::uniform_int_distribution{ 1, 100 };
+    auto gen = std::mt19937{rd()};
+    auto distrib = std::uniform_int_distribution{1, 100};
 
     const auto secret_number = distrib(gen);
     auto input = std::string{};

src/ch02-guessing-game/main_cxx_20.cxx

@@ -9,28 +9,28 @@ auto main() -> int {
     std::cout << "Guessing Game!\n";
 
     auto rd = std::random_device{};
-    auto gen = std::mt19937{ rd() };
-    auto distrib = std::uniform_int_distribution{ 1, 100 };
+    auto gen = std::mt19937{rd()};
+    auto distrib = std::uniform_int_distribution{1, 100};
 
     const auto secret_number = distrib(gen);
     auto input = std::string{};
-    auto guess = int{0};
+    auto guess = 0;
 
     while (true) {
         std::cout << "Please input your guess: ";
         std::getline(std::cin, input);
 
         try {
             guess = std::stoi(input);
-        } catch (std::invalid_argument const&) {
+        } catch (const std::invalid_argument&) {
             std::cout << "Invalid input " << std::quoted(input) << "!\n";
             continue;
-        } catch (std::out_of_range const&) {
+        } catch (const std::out_of_range&) {
             std::cout << "Input " << std::quoted(input) << " is too large!" << '\n';
             continue;
         }
 
-        if (auto const cmp = guess <=> secret_number; std::is_eq(cmp)) {
+        if (const auto cmp = guess <=> secret_number; std::is_eq(cmp)) {
             std::cout << "You guessed correctly!\n";
             break;
         } else if (std::is_lt(cmp)) {

src/ch03-common-concepts/data-types.md

@@ -300,7 +300,7 @@ $#include <iostream>
 $#include <tuple>
 $
 auto main() -> int {
-    const auto t = std::tuple{ 5u, 5.34f, -345, "abc", false };
+    const auto t = std::tuple{5u, 5.34f, -345, "abc", false};
     const auto u = std::make_tuple(5u, 5.f, -345, "abc", false);
     
     const auto [v, w, x, y, z] = t;

src/ch03-common-concepts/functions.md

@@ -89,7 +89,7 @@ $#include <sstream>
 $#include <string>
 $
 auto foo(const int x, const int y) -> std::string {
-    auto ss = std::stringstring{};
+    auto ss = std::stringstream{};
     ss << "x: " << x << ", y: " << y << "\n";
     return ss.str();
 }
@@ -118,14 +118,14 @@ $#include <string>
 // --snip--
 
 auto another_one(const int x, const int y) -> std::string {
-$    auto ss = std::stringstream {};
+$    auto ss = std::stringstream{};
 $    ss << "x: " << x << ", y: " << y << "\n";
 $    return ss.str();
 // --snip--
 }
 
 auto another_one(const float x, const float y) -> std::string {
-    auto ss = std::stringstream {};
+    auto ss = std::stringstream{};
     ss << std::setprecision(4) 
        << "x: "
        << x
@@ -157,13 +157,13 @@ functions can only take two parameters except unary operators, which can only ta
 // --snip--
 
 auto operator<<(std::ostream& os, std::pair<int, int> p) -> std::ostream& {
-    auto const [x, y] = p;
+    const auto [x, y] = p;
     os << "x: " << x << ", y: " << y << "\n";
     return os;
 }
 
 auto main() -> int {
-    auto const p = std::pair{7, 6};
+    const auto p = std::pair{7, 6};
 
     std::cout << p << "\n";
     return 0;

src/ch03-common-concepts/vars-mut.md

@@ -130,7 +130,7 @@ value.
 ```cpp,icon=%cplusplus,fp=main.cxx
 #include <iostream>
 
-auto constexpr sum(auto const n) {
+constexpr auto sum(const auto n) {
     auto acc = 0;
     for (auto i = 0; i < n; ++i) {
         acc += 1;
@@ -140,7 +140,7 @@ auto constexpr sum(auto const n) {
 }
 
 auto main() -> int {
-    auto constexpr x = (42 + 7) / sum(23);
+    constexpr auto x = (42 + 7) / sum(23);
     auto y = 6;
     y = (42 + 7) / sum(23);
 

src/ch04-ownership/refs-moves.md

@@ -89,7 +89,7 @@ auto foo(const std::string& s) -> const std::string& {
 }
 
 auto main() -> int {
-    auto const s = std::string{"hello"};
+    const auto s = std::string{"hello"};
 
     std::cout << "Address of s: " << static_cast<const void*>(s.data()) << "\n";
     std::cout << foo(s);
@@ -133,7 +133,7 @@ $#include <string>
 $#include <utility>
 // --snip--
 
-auto constexpr str_addr(const std::string& s) -> const void* {
+constexpr auto str_addr(const std::string& s) -> const void* {
     return static_cast<const void*>(s.data());
 }
 

src/ch05-structures/create.md

@@ -1,8 +1,5 @@
 # Creating Structures
 
-> [!WARNING]
-> 🚧 Page Under Construction! 🏗️
-
 To declare a struct we use the `struct` keyword followed by the name of the new type.
 Members are defined inside curly braces using the same variable and function declaration
 syntax we have seen previously; although variables do not need an initializer and thus
@@ -40,7 +37,7 @@ $    std::string email;
 $};
 $
 auto main() -> int {
-    auto const p = Person {
+    const auto p = Person{
         true,
         23,
         "John Doe",
@@ -100,16 +97,13 @@ auto make_person(std::string_view const name, std::string_view const email) -> P
     return Person {
         true,
         0,
-        std::string{ name },
-        std::string{ email }
+        std::string{name},
+        std::string{email}
     };
 }
 
 auto main() -> int {
-    auto const p = make_person(
-            "John Doe",
-            "johnd@example.com"
-    );
+    const auto p = make_person("John Doe", "johnd@example.com");
 $
 $    return 0;
 }
@@ -135,19 +129,16 @@ $auto make_person(std::string_view const name, std::string_view const email) ->
 $    return Person {
 $        true,
 $        0,
-$        std::string{ name },
-$        std::string{ email }
+$        std::string{name},
+$        std::string{email}
 $    };
 $}
 $
 auto main() -> int {
-    auto const p1 = make_person(
-            "John Doe",
-            "johnd@example.com"
-    );
+    const auto p1 = make_person("John Doe", "johnd@example.com");
 
     // Default construct
-    auto p2 = Person {};
+    auto p2 = Person{};
 
     // Copy
     auto p3 = p1;

src/ch05-structures/example.md

@@ -7,14 +7,14 @@ simple program to calculate operations on a 3D vector type.
 $#include <cmath>
 $#include <iostream>
 $
-auto magnitude(auto const x, auto const y, auto const z) -> double {
+auto magnitude(const double x, const double y, const double z) -> double {
     return std::sqrt(x * x + y * y + z * z);
 }
 
 auto main() -> int {
-    auto const x = 2.;
-    auto const y = 3.;
-    auto const z = 5.;
+    const auto x = 2.;
+    const auto y = 3.;
+    const auto z = 5.;
 
     std::cout << "The magnitude of the vector is "
               << magnitude(x, y, z)
@@ -38,13 +38,13 @@ $#include <tuple>
 $
 using vec3 = std::tuple<double, double, double>;
 
-auto magnitude(vec3 const vec) -> double {
-    auto const& [x, y, z] = v;
+auto magnitude(const vec3 vec) -> double {
+    const auto& [x, y, z] = v;
     return std::sqrt(x * x + y * y + z * z);
 }
 
 auto main() -> int {
-    auto const v = vec3 { 2., 3., 5. };
+    const auto v = vec3{2., 3., 5.};
 
     std::cout << "The magnitude of the vector is "
               << magnitude(v)
@@ -78,14 +78,14 @@ struct vec3 {
     double z;
 };
 
-auto magnitude(vec3 const vec) -> double {
+auto magnitude(const vec3 vec) -> double {
     return std::sqrt(vec.x * vec.x
                    + vec.y * vec.y
                    + vec.z * vec.z);
 }
 
 auto main() -> int {
-    auto const v = vec3 { 2., 3., 5. };
+    const auto v = vec3{2., 3., 5.};
 
     std::cout << "The magnitude of the vector is "
               << magnitude(v)