Updated Chapters 7 examples

Author: pdeitel

examples/ch07/fig07_01.cpp

@@ -10,7 +10,7 @@ int main() {
    cout << "The address of a is " << &a
       << "\nThe value of aPtr is " << aPtr;
    cout << "\n\nThe value of a is " << a
-      << "\nThe value of *aPtr is " << *aPtr << endl;
+      << "\nThe value of *aPtr is " << *aPtr << '\n';
 }
 
 

examples/ch07/fig07_02.cpp

@@ -1,16 +1,16 @@
 // fig07_02.cpp
 // Pass-by-value used to cube a variable's value.
+#include <fmt/format.h>
 #include <iostream>
-using namespace std;
 
 int cubeByValue(int n); // prototype 
 
 int main() {
    int number{5};
 
-   cout << "The original value of number is " << number;
+   std::cout << fmt::format("Original value of number is {}\n", number);
    number = cubeByValue(number); // pass number by value to cubeByValue
-   cout << "\nThe new value of number is " << number << endl;
+   std::cout << fmt::format("New value of number is {}\n", number);
 }
 
 // calculate and return cube of integer argument                
@@ -19,6 +19,7 @@ int cubeByValue(int n) {
 }
 
 
+
 /**************************************************************************
  * (C) Copyright 1992-2014 by Deitel & Associates, Inc. and               *
  * Pearson Education, Inc. All Rights Reserved.                           *

examples/ch07/fig07_03.cpp

@@ -1,17 +1,17 @@
 // fig07_03.cpp
 // Pass-by-reference with a pointer argument used to cube a 
 // variable's value.
+#include <fmt/format.h>
 #include <iostream>
-using namespace std;
 
 void cubeByReference(int* nPtr); // prototype 
 
 int main() {
    int number{5};
 
-   cout << "The original value of number is " << number;
+   std::cout << fmt::format("Original value of number is {}\n", number);
    cubeByReference(&number); // pass number address to cubeByReference
-   cout << "\nThe new value of number is " << number << endl;
+   std::cout << fmt::format("New value of number is {}\n", number);
 }
 
 // calculate cube of *nPtr; modifies variable number in main 

examples/ch07/fig07_06.cpp

@@ -1,31 +1,35 @@
 // fig07_06.cpp
 // C++20: Creating std::arrays with to_array.
+#include <fmt/format.h>
 #include <iostream>
 #include <array>
-using namespace std;
 
 int main() {
-   // lambda to display a collection of items
-   const auto display = [](const auto& items) {
-      for (const auto& item : items) {
-         cout << item << " ";
+   // generic lambda to display a collection of items
+   const auto display{
+      [](const auto& items) {
+         for (const auto& item : items) {
+            std::cout << fmt::format("{} ", item);
+         }
       }
    };
 
-   const int values1[3]{10, 20, 30};
+   const int values1[]{10, 20, 30};
 
    // creating a std::array from a built-in array
-   const auto array1 = to_array(values1);
+   const auto array1{std::to_array(values1)};
 
-   cout << "array1.size() = " << array1.size() << "\narray1: ";
+   std::cout << fmt::format("array1.size() = {}\n", array1.size())
+      << "array1: ";
    display(array1); // use lambda to display contents
 
    // creating a std::array from an initializer list
-   const auto array2 = to_array({1, 2, 3, 4});
-   cout << "\n\narray2.size() = " << array2.size() << "\narray2: ";
+   const auto array2{std::to_array({1, 2, 3, 4})};
+   std::cout << fmt::format("\n\narray2.size() = {}\n", array2.size())
+      << "array2: ";
    display(array2); // use lambda to display contents
 
-   cout << endl;
+   std::cout << '\n';
 }
 
 

examples/ch07/fig07_10.cpp

@@ -1,18 +1,19 @@
 // fig07_10.cpp
 // Sizeof operator when used on a built-in array's name
 // returns the number of bytes in the built-in array.
+#include <fmt/format.h>
 #include <iostream>
-using namespace std;
 
 size_t getSize(double* ptr); // prototype
 
 int main() {
    double numbers[20]; // 20 doubles; occupies 160 bytes on our system
 
-   cout << "The number of bytes in the array is " << sizeof(numbers);
+   std::cout << fmt::format("Number of bytes in numbers is {}\n\n",
+      sizeof(numbers));
 
-   cout << "\nThe number of bytes returned by getSize is "
-      << getSize(numbers) << endl;
+   std::cout << fmt::format("Number of bytes returned by getSize is {}\n",
+      getSize(numbers));
 }
 
 // return size of ptr         
@@ -21,6 +22,7 @@ size_t getSize(double* ptr) {
 }
 
 
+
 /**************************************************************************
  * (C) Copyright 1992-2014 by Deitel & Associates, Inc. and               *
  * Pearson Education, Inc. All Rights Reserved.                           *

examples/ch07/fig07_11.cpp

@@ -1,7 +1,7 @@
 // fig07_11.cpp
 // sizeof operator used to determine standard data type sizes.
+#include <fmt/format.h>
 #include <iostream>
-using namespace std;
 
 int main() {
    constexpr char c{}; // variable of type char
@@ -14,27 +14,26 @@ int main() {
    constexpr long double ld{}; // variable of type long double
    constexpr int array[20]{}; // built-in array of int
    const int* const ptr{array}; // variable of type int*
- 
-   cout << "sizeof c = " << sizeof c
-      << "\tsizeof(char) = " << sizeof(char)
-      << "\nsizeof s = " << sizeof s
-      << "\tsizeof(short) = " << sizeof(short)
-      << "\nsizeof i = " << sizeof i
-      << "\tsizeof(int) = " << sizeof(int)
-      << "\nsizeof l = " << sizeof l
-      << "\tsizeof(long) = " << sizeof(long)
-      << "\nsizeof ll = " << sizeof ll
-      << "\tsizeof(long long) = " << sizeof(long long)
-      << "\nsizeof f = " << sizeof f
-      << "\tsizeof(float) = " << sizeof(float)
-      << "\nsizeof d = " << sizeof d
-      << "\tsizeof(double) = " << sizeof(double)
-      << "\nsizeof ld = " << sizeof ld
-      << "\tsizeof(long double) = " << sizeof(long double)
-      << "\nsizeof array = " << sizeof array
-      << "\nsizeof ptr = " << sizeof ptr << endl;
-}
 
+   std::cout << fmt::format("sizeof c = {}\tsizeof(char) = {}\n",
+      sizeof c, sizeof(char));
+   std::cout << fmt::format("sizeof s = {}\tsizeof(short) = {}\n",
+      sizeof s, sizeof(short));
+   std::cout << fmt::format("sizeof i = {}\tsizeof(int) = {}\n",
+      sizeof i, sizeof(int));
+   std::cout << fmt::format("sizeof l = {}\tsizeof(long) = {}\n",
+      sizeof l, sizeof(long));
+   std::cout << fmt::format("sizeof ll = {}\tsizeof(long long) = {}\n",
+      sizeof ll, sizeof(long long));
+   std::cout << fmt::format("sizeof f = {}\tsizeof(float) = {}\n",
+      sizeof f, sizeof(float));
+   std::cout << fmt::format("sizeof d = {}\tsizeof(double) = {}\n",
+      sizeof d, sizeof(double));
+   std::cout << fmt::format("sizeof ld = {}\tsizeof(long double) = {}\n",
+      sizeof ld, sizeof(long double));
+   std::cout << fmt::format("sizeof array = {}\n", sizeof array);
+   std::cout << fmt::format("sizeof ptr = {}\n", sizeof ptr);
+}
 
 /**************************************************************************
  * (C) Copyright 1992-2014 by Deitel & Associates, Inc. and               *

examples/ch07/fig07_12.cpp

@@ -1,88 +1,85 @@
 // fig07_12.cpp
 // C++20 spans: Creating views into containers.
 #include <array>
+#include <fmt/format.h>
 #include <iostream>
 #include <numeric>
 #include <span>
 #include <vector>
-using namespace std;
 
 // items parameter is treated as a const int* so we also need the size to
 // know how to iterate over items with counter-controlled iteration
 void displayArray(const int items[], size_t size) {
    for (size_t i{0}; i < size; ++i) {
-      cout << items[i] << " ";
+      std::cout << fmt::format("{} ", items[i]);
    }
 }
 
 // span parameter contains both the location of the first item
 // and the number of elements, so we can iterate using range-based for
-void displaySpan(span<const int> items) {
+void displaySpan(std::span<const int> items) {
    for (const auto& item : items) { // spans are iterable
-      cout << item << " ";
+      std::cout << fmt::format("{} ", item);
    }
 }
 
 // spans can be used to modify elements in the original data structure
-void times2(span<int> items) {
+void times2(std::span<int> items) {
    for (int& item : items) {
       item *= 2;
    }
 }
 
 int main() {
-   int values1[5]{1, 2, 3, 4, 5};
-   array<int, 5> values2{6, 7, 8, 9, 10};
-   vector<int> values3{11, 12, 13, 14, 15};
+   int values1[]{1, 2, 3, 4, 5};
+   std::array values2{6, 7, 8, 9, 10};
+   std::vector values3{11, 12, 13, 14, 15};
 
    // must specify size because the compiler treats displayArray's items 
    // parameter as a pointer to the first element of the argument
-   cout << "values1 via displayArray: ";
-   displayArray(values1, 5); 
+   std::cout << "values1 via displayArray: ";
+   displayArray(values1, 5);
 
-   // compiler knows values' size and automatically creates a span
+   // compiler knows values1's size and automatically creates a span
    // representing &values1[0] and the array's length
-   cout << "\nvalues1 via displaySpan: ";
-   displaySpan(values1); 
+   std::cout << "\nvalues1 via displaySpan: ";
+   displaySpan(values1);
 
    // compiler also can create spans from std::arrays and std::vectors
-   cout << "\nvalues2 via displaySpan: ";
+   std::cout << "\nvalues2 via displaySpan: ";
    displaySpan(values2);
-   cout << "\nvalues3 via displaySpan: ";
+   std::cout << "\nvalues3 via displaySpan: ";
    displaySpan(values3);
 
    // changing a span's contents modifies the original data
    times2(values1);
-   cout << "\n\nvalues1 after times2 modifies its span argument: ";
+   std::cout << "\n\nvalues1 after times2 modifies its span argument: ";
    displaySpan(values1);
 
    // spans have various array-and-vector-like capabilities
-   span<int> mySpan{values1}; 
-   cout << "\n\nmySpan's first element: " << mySpan.front()
+   std::span mySpan{values1}; // span<int>
+   std::cout << "\n\nmySpan's first element: " << mySpan.front()
       << "\nmySpan's last element: " << mySpan.back();
 
    // spans can be used with standard library algorithms
-   cout << "\n\nSum of mySpan's elements: "
-      << accumulate(begin(mySpan), end(mySpan), 0);
+   std::cout << "\n\nSum of mySpan's elements: "
+      << std::accumulate(std::begin(mySpan), std::end(mySpan), 0);
 
    // spans can be used to create subviews of a container
-   cout << "\n\nFirst three elements of mySpan: ";
+   std::cout << "\n\nFirst three elements of mySpan: ";
    displaySpan(mySpan.first(3));
-   cout << "\nLast three elements of mySpan: ";
+   std::cout << "\nLast three elements of mySpan: ";
    displaySpan(mySpan.last(3));
-   cout << "\nMiddle three elements of mySpan: ";
+   std::cout << "\nMiddle three elements of mySpan: ";
    displaySpan(mySpan.subspan(1, 3));
-   
-   // changing a subview's contents modifies the original data   
+
+   // changing a subview's contents modifies the original data
    times2(mySpan.subspan(1, 3));
-   cout << "\n\nvalues1 after modifying middle three elements via span: ";
+   std::cout << "\n\nvalues1 after modifying elements via span: ";
    displaySpan(values1);
 
    // access a span element via []
-   cout << "\n\nThe element at index 2 is: " << mySpan[2];
-
-   // attempt to access an element outside the bounds
-   cout << "\n\nThe element at index 10 is: " << mySpan[10] << endl;
+   std::cout << "\n\nThe element at index 2 is: " << mySpan[2];
 }
 
 

examples/ch07/fig07_13.cpp

@@ -1,16 +1,18 @@
 // fig07_13.cpp
 // Reading in command-line arguments.
+#include <fmt/format.h>
 #include <iostream>
-using namespace std;
 
 int main(int argc, char* argv[]) {
-   cout << "There were " << argc << " command-line arguments:\n";
+   std::cout << fmt::format("Number of arguments: {}\n\n", argc);
+
    for (int i{0}; i < argc; ++i) {
-      cout << argv[i] << endl;
+      std::cout << fmt::format("{}\n", argv[i]);
    }
 }
 
 
+
 /**************************************************************************
  * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
  * Pearson Education, Inc. All Rights Reserved.                           *

examples/ch07/fig07_14.cpp

@@ -1,32 +1,37 @@
 // fig07_14.cpp
 // C++20: Creating std::arrays from string literals with to_array.
+#include <fmt/format.h>
 #include <iostream>
 #include <array>
-using namespace std;
 
 int main() {
    // lambda to display a collection of items
-   const auto display = [](const auto& items) {
-      for (const auto& item : items) {
-         cout << item << " ";
-      }
+   const auto display{
+      [](const auto& items) {
+         for (const auto& item : items) {
+            std::cout << fmt::format("{} ", item);
+         }
+       }
    };
 
    // initializing an array with a string literal
    // creates a one-element array<const char*>
-   const auto array1 = array{"abc"};
-   cout << "array1.size() = " << array1.size() << "\narray1: ";
+   const auto array1{std::array{"abc"}};
+   std::cout << fmt::format("array1.size() = {}\narray1: ",
+      array1.size());
    display(array1); // use lambda to display contents
 
    // creating std::array of characters from a string literal 
-   const auto array2 = to_array("C++20");
-   cout << "\n\narray2.size() = " << array2.size() << "\narray2: ";
+   const auto array2{std::to_array("C++20")};
+   std::cout << fmt::format("\n\narray2.size() = {}\narray2: ",
+      array2.size());
    display(array2); // use lambda to display contents
 
-   cout << endl;
+   std::cout << '\n';
 }
 
 
+
 /**************************************************************************
  * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
  * Pearson Education, Inc. All Rights Reserved.                           *