ch13 draft examples uploaded

Author: pdeitel

examples/ch13/fig13_01.cpp

@@ -0,0 +1,38 @@
+// fig13_01.cpp
+// Demonstrating input and output with iterators.
+#include <iostream>
+#include <iterator> // ostream_iterator and istream_iterator
+
+int main() {
+   std::cout << "Enter two integers: ";
+
+   // create istream_iterator for reading int values from cin
+   std::istream_iterator<int> inputInt{std::cin};
+
+   const int number1{*inputInt}; // read int from standard input
+   ++inputInt; // move iterator to next input value        
+   const int number2{*inputInt}; // read int from standard input
+
+   // create ostream_iterator for writing int values to cout
+   std::ostream_iterator<int> outputInt{std::cout};
+
+   std::cout << "The sum is: ";
+   *outputInt = number1 + number2; // output result to cout
+   std::cout << "\n";
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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/ch13/fig13_02.cpp

@@ -0,0 +1,57 @@
+// fig13_02.cpp
+// Standard library vector class template.
+#include <fmt/format.h> // C++20: This will be #include <format>
+#include <iostream>
+#include <ranges>
+#include <vector> // vector class-template definition
+
+// display value appended to vector and updated vector size and capacity
+void showResult(int value, size_t size, size_t capacity) {
+   std::cout << fmt::format("appended: {}; size: {}; capacity: {}\n",
+      value, size, capacity);
+}
+
+int main() {
+   std::vector<int> integers{}; // create vector of ints
+
+   std::cout << "Size of integers: " << integers.size()
+      << "\nCapacity of integers: " << integers.capacity() << "\n\n";
+
+   // append 1-10 to integers and display updated size and capacity
+   for (int i : std::views::iota(1, 11)) {
+      integers.push_back(i); // push_back is in vector, deque and list
+      showResult(i, integers.size(), integers.capacity());
+   }
+
+   std::cout << "\nOutput integers using iterators: ";
+
+   for (auto constIterator{integers.cbegin()};
+      constIterator != integers.cend(); ++constIterator) {
+      std::cout << *constIterator << ' ';
+   }
+
+   std::cout << "\nOutput integers in reverse using iterators: ";
+
+   // display vector in reverse order using const_reverse_iterator
+   for (auto reverseIterator{integers.crbegin()};
+      reverseIterator != integers.crend(); ++reverseIterator) {
+      std::cout << *reverseIterator << ' ';
+   }
+
+   std::cout << "\n";
+}
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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/ch13/fig13_03.cpp

@@ -0,0 +1,65 @@
+// fig13_03.cpp
+// Testing standard library vector class template
+// element-manipulation functions.
+#include <algorithm> // copy algorithm
+#include <fmt/format.h> // C++20: This will be #include <format>
+#include <iostream>
+#include <ranges> 
+#include <iterator> // ostream_iterator iterator
+#include <vector> 
+
+int main() {
+   std::vector values{1, 2, 3, 4, 5}; // class template argument deduction
+   std::vector<int> integers{values.cbegin(), values.cend()};
+   std::ostream_iterator<int> output{std::cout, " "};
+
+   std::cout << "integers contains: ";
+   std::copy(integers.cbegin(), integers.cend(), output);
+
+   std::cout << fmt::format("\nfront: {}\nback: {}\n\n",
+      integers.front(), integers.back());
+
+   integers[0] = 7; // set first element to 7             
+   integers.at(2) = 10; // set element at position 2 to 10
+
+   // insert 22 as 2nd element                  
+   integers.insert(integers.cbegin() + 1, 22);
+
+   std::cout << "Contents of vector integers after changes: ";
+   std::ranges::copy(integers, output);
+
+   integers.erase(integers.cbegin()); // erase first element
+   std::cout << "\n\nintegers after erasing first element: ";
+   std::ranges::copy(integers, output);
+
+   // erase remaining elements                          
+   integers.erase(integers.cbegin(), integers.cend());
+   std::cout << fmt::format("\nErased all elements: integers {} empty\n",
+      integers.empty() ? "is" : "is not");
+
+   // insert elements from the vector values                             
+   integers.insert(integers.cbegin(), values.cbegin(), values.cend());
+   std::cout << "\nContents of vector integers before clear: ";
+   std::ranges::copy(integers, output);
+
+   // empty integers; clear calls erase to empty a collection
+   integers.clear();
+   std::cout << fmt::format("\nAfter clear, integers {} empty\n",
+      integers.empty() ? "is" : "is not");
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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/ch13/fig13_04.cpp

@@ -0,0 +1,113 @@
+// fig13_04.cpp
+// Standard library list class template.
+#include <algorithm> // copy algorithm
+#include <iostream>
+#include <iterator> // ostream_iterator
+#include <list> // list class-template definition
+#include <vector>
+
+// printList function template definition; uses 
+// ostream_iterator and copy algorithm to output list elements
+template <typename T>
+void printList(const std::list<T>& items) {
+   if (items.empty()) { // list is empty
+      std::cout << "List is empty";
+   }
+   else {
+      std::ostream_iterator<T> output{std::cout, " "};
+      std::ranges::copy(items, output);
+   }
+}
+
+int main() {
+   std::list<int> values{}; // create list of ints     
+
+   // insert items in values
+   values.push_front(1);
+   values.push_front(2);
+   values.push_back(4);
+   values.push_back(3);
+
+   std::cout << "values contains: ";
+   printList(values);
+
+   values.sort(); // sort values
+   std::cout << "\nvalues after sorting contains: ";
+   printList(values);
+
+   // insert elements of ints into otherValues                            
+   std::vector ints{2, 6, 4, 8};
+   std::list<int> otherValues{}; // create list of ints
+   otherValues.insert(otherValues.cbegin(), ints.cbegin(), ints.cend());
+   std::cout << "\nAfter insert, otherValues contains: ";
+   printList(otherValues);
+
+   // remove otherValues elements and insert at end of values
+   values.splice(values.cend(), otherValues);
+   std::cout << "\nAfter splice, values contains: ";
+   printList(values);
+
+   values.sort(); // sort values
+   std::cout << "\nAfter sort, values contains: ";
+   printList(values);
+
+   // insert elements of ints into otherValues                            
+   otherValues.insert(otherValues.cbegin(), ints.cbegin(), ints.cend());
+   otherValues.sort(); // sort the list                                 
+   std::cout << "\nAfter insert and sort, otherValues contains: ";
+   printList(otherValues);
+
+   // remove otherValues elements and insert into values in sorted order
+   values.merge(otherValues);
+   std::cout << "\nAfter merge:\n   values contains: ";
+   printList(values);
+   std::cout << "\n   otherValues contains: ";
+   printList(otherValues);
+
+   values.pop_front(); // remove element from front
+   values.pop_back(); // remove element from back  
+   std::cout << "\nAfter pop_front and pop_back:\n   values contains: ";
+   printList(values);
+
+   values.unique(); // remove duplicate elements
+   std::cout << "\nAfter unique, values contains: ";
+   printList(values);
+
+   values.swap(otherValues); // swap elements of values and otherValues
+   std::cout << "\nAfter swap:\n   values contains: ";
+   printList(values);
+   std::cout << "\n   otherValues contains: ";
+   printList(otherValues);
+
+   // replace contents of values with elements of otherValues
+   values.assign(otherValues.cbegin(), otherValues.cend());
+   std::cout << "\nAfter assign, values contains: ";
+   printList(values);
+
+   // remove otherValues elements and insert into values in sorted order
+   values.merge(otherValues);
+   std::cout << "\nAfter merge, values contains: ";
+   printList(values);
+
+   values.remove(4); // remove all 4s
+   std::cout << "\nAfter remove(4), values contains: ";
+   printList(values);
+   std::cout << "\n";
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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/ch13/fig13_05.cpp

@@ -0,0 +1,49 @@
+// fig13_05.cpp
+// Standard library deque class template.
+#include <algorithm> // copy algorithm
+#include <deque> // deque class-template definition
+#include <iostream>
+#include <iterator> // ostream_iterator
+
+int main() {
+   std::deque<double> values; // create deque of doubles
+   std::ostream_iterator<double> output{std::cout, " "};
+
+   // insert elements in values
+   values.push_front(2.2);
+   values.push_front(3.5);
+   values.push_back(1.1);
+
+   std::cout << "values contains: ";
+
+   // use subscript operator to obtain elements of values
+   for (size_t i{0}; i < values.size(); ++i) {
+      std::cout << values[i] << ' ';
+   }
+
+   values.pop_front(); // remove first element
+   std::cout << "\nAfter pop_front, values contains: ";
+   std::ranges::copy(values, output);
+
+   // use subscript operator to modify element at location 1
+   values[1] = 5.4;
+   std::cout << "\nAfter values[1] = 5.4, values contains: ";
+   std::ranges::copy(values, output);
+   std::cout << "\n";
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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/ch13/fig13_06.cpp

@@ -0,0 +1,72 @@
+// fig13_06.cpp
+// Standard library multiset class template
+#include <algorithm> // copy algorithm
+#include <fmt/format.h> // C++20: This will be #include <format>
+#include <iostream>
+#include <iterator> // ostream_iterator
+#include <ranges> 
+#include <set> // multiset class-template definition
+#include <vector>
+
+int main() {
+   std::multiset<int, std::less<int>> ints{}; // multiset of int values
+   std::cout << fmt::format("15s in ints: {}\n", ints.count(15));
+
+   std::cout << "\nInserting two 15s into ints\n";
+   ints.insert(15); // insert 15 in ints
+   ints.insert(15); // insert 15 in ints
+   std::cout << fmt::format("15s in ints: {}\n\n", ints.count(15));
+
+   // search for 15 and 20 in ints; find returns an iterator
+   for (int i : {15, 20}) {
+      if (auto result{ints.find(i)}; result != ints.end()) {
+         std::cout << fmt::format("Found {} in ints\n", i);
+      }
+      else {
+         std::cout << fmt::format("Did not find {} in ints\n", i);
+      }
+   }
+
+   // search for 15 and 20 in ints; contains returns a bool
+   for (int i : {15, 20}) {
+      if (ints.contains(i)) {
+         std::cout << fmt::format("Found {} in ints\n", i);
+      }
+      else {
+         std::cout << fmt::format("Did not find {} in ints\n", i);
+      }
+   }
+
+   // insert elements of vector values into ints
+   const std::vector values{7, 22, 9, 1, 18, 30, 100, 22, 85, 13};
+   ints.insert(values.cbegin(), values.cend());
+   std::cout << "\nAfter insert, ints contains:\n";
+   std::ranges::copy(ints, std::ostream_iterator<int>{std::cout, " "});
+
+   // determine lower and upper bound of 22 in ints
+   std::cout << fmt::format(
+                   "\n\nlower_bound(22): {}\nupper_bound(22): {}\n\n",
+                   *(ints.lower_bound(22)), *(ints.upper_bound(22)));
+
+   // use equal_range to determine lower and upper bound of 22 in ints 
+   auto p{ints.equal_range(22)};
+   std::cout << fmt::format(
+                   "lower_bound(22): {}\nupper_bound(22): {}\n",
+                   *(p.first), *(p.second));
+}
+
+
+/**************************************************************************
+ * (C) Copyright 1992-2021 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.                     *
+ **************************************************************************/