Chapter 15 Examples Posted

Author: pdeitel

examples/ch15/fig15_01-02stack/Stack.h

@@ -0,0 +1,51 @@
+// Fig. 16.1: Stack.h
+// Stack class template.
+#pragma once
+#include <deque>
+
+template<typename T>
+class Stack {
+public:
+   // return the top element of the Stack
+   const T& top() {
+      return stack.front();
+   } 
+
+   // push an element onto the Stack
+   void push(const T& pushValue) {
+      stack.push_front(pushValue);
+   } 
+
+   // pop an element from the stack
+   void pop() {
+      stack.pop_front();
+   } 
+
+   // determine whether Stack is empty
+   bool isEmpty() const {
+      return stack.empty(); 
+   } 
+
+   // return size of Stack
+   size_t size() const {
+      return stack.size();
+   } 
+
+private:
+   std::deque<T> stack; // internal representation of the Stack
+}; 
+
+/**************************************************************************
+ * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_01-02stack/fig15_02.cpp

@@ -0,0 +1,68 @@
+// fig15_02.cpp
+// Stack class template test program.
+#include <iostream>
+#include "Stack.h" // Stack class template definition
+using namespace std;
+
+int main() {
+   Stack<double> doubleStack{}; // create a Stack of double
+   constexpr size_t doubleStackSize{5}; // stack size
+   double doubleValue{1.1}; // first value to push
+
+   cout << "Pushing elements onto doubleStack\n";
+
+   // push 5 doubles onto doubleStack
+   for (size_t i{0}; i < doubleStackSize; ++i) {
+      doubleStack.push(doubleValue);
+      cout << doubleValue << ' ';
+      doubleValue += 1.1;
+   } 
+
+   cout << "\n\nPopping elements from doubleStack\n";
+
+   // pop elements from doubleStack
+   while (!doubleStack.isEmpty()) { // loop while Stack is not empty
+      cout << doubleStack.top() << ' '; // display top element
+      doubleStack.pop(); // remove top element
+   } 
+
+   cout << "\nStack is empty, cannot pop.\n";
+
+   Stack<int> intStack{}; // create a Stack of int
+   constexpr size_t intStackSize{10}; // stack size
+   int intValue{1}; // first value to push
+
+   cout << "\nPushing elements onto intStack\n";
+
+   // push 10 integers onto intStack
+   for (size_t i{0}; i < intStackSize; ++i) {
+      intStack.push(intValue);
+      cout << intValue++ << ' ';
+   } 
+
+   cout << "\n\nPopping elements from intStack\n";
+
+   // pop elements from intStack
+   while (!intStack.isEmpty()) { // loop while Stack is not empty
+      cout << intStack.top() << ' '; // display top element
+      intStack.pop(); // remove top element
+   } 
+
+   cout << "\nStack is empty, cannot pop.\n";
+} 
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_03abbreviatedFunctionTemplate/fig15_03.cpp

@@ -0,0 +1,43 @@
+// fig15_03.cpp
+// Abbreviated function template.
+#include <array>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// abbreviated function template printContainer displays a 
+// container's elements separated by spaces.
+void printContainer(const auto& items) {
+   for (const auto& item : items) {
+      std::cout << item << " ";
+   }
+}
+
+int main() {
+   using namespace std::string_literals; // for string object literals
+
+   std::array ints{1, 2, 3, 4, 5};
+   std::vector strings{"red"s, "green"s, "blue"s};
+
+   std::cout << "ints: ";
+   printContainer(ints);
+   std::cout << "\nstrings: ";
+   printContainer(strings);
+   std::cout << "\n";
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_04multiply/fig15_04.cpp

@@ -0,0 +1,34 @@
+// fig15_04.cpp
+// Simple unconstrained multiply function template.
+#include <concepts>
+#include <iostream>
+
+template<typename T>
+T multiply(T first, T second) {
+   return first * second;
+}
+
+int main() {
+   std::cout << "Product of 5 and 3: " << multiply(5, 3)
+      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0) << "\n";
+
+   // std::string s1{"hi"};
+   // std::string s2{"bye"};
+   // auto result{multiply(s1, s2)}; // string does not have * operator
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_05_multiply_constrained/fig15_05.cpp

@@ -0,0 +1,36 @@
+// fig15_05.cpp
+// Constrained multiply function template that allows 
+// only integers and floating-point values.
+#include <concepts>
+#include <iostream>
+
+template<typename T>
+   requires std::integral<T> || std::floating_point<T>
+T multiply(T first, T second) {
+   return first * second;
+}
+
+int main() {
+   std::cout << "Product of 5 and 3: " << multiply(5, 3)
+      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0) << "\n";
+
+   //std::string s1{"hi"};
+   //std::string s2{"bye"};
+   //auto result{multiply(s1, s2)};
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_06typetraits/fig15_06.cpp

@@ -0,0 +1,55 @@
+// fig15_06.cpp
+// Using type traits to test whether types are 
+// integral types, floating-point types or arithmetic types.
+#include <fmt/format.h>
+#include <iostream>
+#include <string>
+#include <type_traits> 
+
+int main() {
+   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
+      "CHECK WITH TYPE TRAITS WHETHER TYPES ARE INTEGRAL",
+      "std::is_integral<int>::value: ", std::is_integral<int>::value,
+      "std::is_integral_v<int>: ", std::is_integral_v<int>,
+      "std::is_integral_v<long>: ", std::is_integral_v<long>,
+      "std::is_integral_v<float>: ", std::is_integral_v<float>,
+      "std::is_integral_v<std::string>: ",
+      std::is_integral_v<std::string>);
+
+   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
+      "CHECK WITH TYPE TRAITS WHETHER TYPES ARE FLOATING POINT",
+      "std::is_floating_point<float>::value: ",
+      std::is_floating_point<float>::value,
+      "std::is_floating_point_v<float>: ",
+      std::is_floating_point_v<float>,
+      "std::is_floating_point_v<double>: ",
+      std::is_floating_point_v<double>,
+      "std::is_floating_point_v<int>: ",
+      std::is_floating_point_v<int>,
+      "std::is_floating_point_v<std::string>: ",
+      std::is_floating_point_v<std::string>);
+
+   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n",
+      "CHECK WITH TYPE TRAITS WHETHER TYPES CAN BE USED IN ARITHMETIC",
+      "std::is_arithmetic<int>::value: ", std::is_arithmetic<int>::value,
+      "std::is_arithmetic_v<int>: ", std::is_arithmetic_v<int>,
+      "std::is_arithmetic_v<double>: ", std::is_arithmetic_v<double>,
+      "std::is_arithmetic_v<std::string>: ",
+      std::is_arithmetic_v<std::string>);
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_07_multiply_custom_abbreviated/fig15_06.cpp

@@ -0,0 +1,34 @@
+// fig15_06.cpp
+// Constrained multiply abbreviated function template.
+#include <concepts>
+#include <iostream>
+
+// Numeric concept aggregates std::integral and std::floating_point
+template<typename T>
+concept Numeric = std::integral<T> || std::floating_point<T>;
+
+// abbreviated function template with constrained auto
+auto multiply(Numeric auto first, Numeric auto second) {
+   return first * second;
+}
+
+int main() {
+   std::cout << "Product of 5 and 3: " << multiply(5, 3)
+      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0)
+      << "\nProduct of 5 and 7.25: " << multiply(5, 7.25) << "\n";
+}
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/

examples/ch15/fig15_08distance_overloaded/fig15_08.cpp

@@ -0,0 +1,56 @@
+// fig15_07.cpp
+// Using concepts to select overloads.
+#include <array>
+#include <iostream>
+#include <iterator>
+#include <list>
+#include <ranges>
+
+// calculate the distance (number of items) between two iterators 
+// using input iterators; requires incrementing between iterators, 
+// so this is an O(n) operation
+auto customDistance(std::input_iterator auto begin,
+   std::input_iterator auto end) {
+   std::cout << "Called customDistance with bidirectional iterators\n";
+   std::ptrdiff_t count{0};
+
+   // increment from begin to end and count number of iterations
+   for (auto& iter{begin}; iter != end; ++iter) {
+      ++count;
+   }
+
+   return count;
+}
+
+// calculate the distance (number of items) between two iterators 
+// using random-access iterators and an O(1) operation
+auto customDistance(std::random_access_iterator auto begin,
+   std::random_access_iterator auto end) {
+   std::cout << "Called customDistance with random-access iterators\n";
+   return end - begin;
+}
+
+int main() {
+   const std::array ints1{1, 2, 3, 4, 5}; // has random-access iterators
+   const std::list ints2{1, 2, 3}; // has bidirectional iterators
+
+   auto result1{customDistance(ints1.begin(), ints1.end())};
+   std::cout << "ints1 number of elements: " << result1 << "\n";
+   auto result2{customDistance(ints2.begin(), ints2.end())};
+   std::cout << "ints1 number of elements: " << result2 << "\n";
+}
+
+/**************************************************************************
+ * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
+ * Pearson Education, Inc. All Rights Reserved.                           *
+ *                                                                        *
+ * DISCLAIMER: The authors and publisher of this book have used their     *
+ * best efforts in preparing the book. These efforts include the          *
+ * development, research, and testing of the theories and programs        *
+ * to determine their effectiveness. The authors and publisher make       *
+ * no warranty of any kind, expressed or implied, with regard to these    *
+ * programs or to the documentation contained in these books. The authors *
+ * and publisher shall not be liable in any event for incidental or       *
+ * consequential damages in connection with, or arising out of, the       *
+ * furnishing, performance, or use of these programs.                     *
+ **************************************************************************/