Improve templates exercise

* Reword/extend README.md
* Repeat some instructions inside the code
* Use std::less instead of custom less
* Already provide the implementation of RevOrderString, so students can focus on the template related stuff
* Move to C++20

Co-authored-by: Stephan Hageboeck <[email protected]>

Author: 2 people

code/templates/CMakeLists.txt

@@ -10,6 +10,9 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 include( "${CMAKE_CURRENT_SOURCE_DIR}/../CompilerSettings.cmake" )
 include( "${CMAKE_CURRENT_SOURCE_DIR}/../SolutionTarget.cmake" )
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 # Create the user's executable.
 add_executable( playwithsort "Complex.hpp" "OrderedVector.hpp" "playwithsort.cpp" )
 

code/templates/Makefile

@@ -5,7 +5,7 @@ clean:
 	rm -f *o *so playwithsort *~ playwithsort.sol
 
 playwithsort : playwithsort.cpp OrderedVector.hpp Complex.hpp
-	$(CXX) -std=c++17 -g -O0 -Wall -Wextra -o $@ $<
+	$(CXX) -std=c++20 -g -O0 -Wall -Wextra -o $@ $<
 
 playwithsort.sol : solution/playwithsort.sol.cpp solution/OrderedVector.sol.hpp Complex.hpp
-	$(CXX) -std=c++17 -g -O0 -Wall -Wextra -I. -o $@ $<
+	$(CXX) -std=c++20 -g -O0 -Wall -Wextra -I. -o $@ $<

code/templates/README.md

@@ -2,15 +2,16 @@
 ## Instructions
 
 Beginners
-* look at the `OrderedVector` code
-* compile and run `playwithsort.cpp`. See the ordering
-* modify `playwithsort.cpp` and reuse `OrderedVector` with `Complex`
+* Look at the `OrderedVector` code
+* Compile and run `playwithsort.cpp`. See the ordering
+* Modify `playwithsort.cpp` and reuse `OrderedVector` with `Complex`
 
 Intermediary
-* improve `OrderedVector` to template the ordering
-* test reverse ordering of strings (from the last letter)
-* test order based on [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry) with complex type
+* Extend `OrderedVector` to allow to customize the ordering via an additional template parameter.
+  By default, `std::less` should be used.
+* Test ordering by the reversed strings (from the last letter, don't change the strings!)
+* Test order based on [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry) with complex type
 
 Bonus
-* check the implementation of `Complex`
-* try ordering complex of complex
+* Check the implementation of `Complex`
+* Try ordering complex of complex

code/templates/playwithsort.cpp

@@ -3,13 +3,19 @@
 #include <string>
 #include <iostream>
 #include <algorithm>
+#include <ranges>
 
-/*
-struct OrderFunctor {
-    bool operator() (const TYPE &s, const TYPE &t) const {
+struct ReverseStringLess {
+    bool operator() (const std::string &s, const std::string &t) const {
+        // TODO: compare reversed strings
+        // hint: you can use:
+        // - std::views::reverse
+        // - std::ranges::lexicographical_compare
+        // or, if your compiler does not support those yet,
+        // take copies of the strings and reverse them using std::reverse
+        return s < t;
     }
 };
-*/
 
 int main() {
     std::cout << "Integer\n";
@@ -31,4 +37,15 @@ int main() {
         std::cout << vs[i] << " ";
     std::cout << "\n\n";
 
+    // TODO: Demonstrate OrderedVector with Complex as done above
+
+
+    // TODO: Extend OrderedVector to allow to customize the ordering via an additional template paramter.
+    //       Then, demonstrate the new functionality by ordering an OrderedVector<std::string>,
+    //       where the strings are compared starting at their last letters.
+
+
+    // TODO: Order an OrderedVector of Complex based on the Manhattan distance
+
+
 }

code/templates/solution/OrderedVector.sol.hpp

@@ -1,12 +1,8 @@
 #include <memory>
 #include <stdexcept>
+#include <functional>
 
-template <typename T>
-struct less {
-  bool operator() (const T& x, const T& y) const {return x<y;}
-};
-
-template<typename ElementType, typename Compare=less<ElementType> >
+template<typename ElementType, typename Compare=std::less<>>
 class OrderedVector {
 public:
     OrderedVector(unsigned int maxLen);

code/templates/solution/playwithsort.sol.cpp

@@ -4,18 +4,25 @@
 #include <iostream>
 #include <algorithm>
 #include <cmath>
+#include <ranges>
 
-struct RevOrderString {
+struct ReverseStringLess {
     bool operator() (const std::string &s, const std::string &t) const {
+        // __cpp_lib_ranges is a feature test macro.
+        // We can use those to check what features a C++ compiler supports.
+#ifdef __cpp_lib_ranges
+        return std::ranges::lexicographical_compare(std::views::reverse(s), std::views::reverse(t));
+#else
         std::string rs = s;
         std::string rt = t;
         std::reverse(rs.begin(), rs.end());
         std::reverse(rt.begin(), rt.end());
         return rs < rt;
+#endif
     }
 };
 
-struct ManhattanOrder {
+struct ManhattanLess {
     bool operator() (const Complex &a, const Complex &b) const {
         return std::abs(a.real()) + std::abs(a.imaginary()) < std::abs(b.real()) + std::abs(b.imaginary());
     }
@@ -53,7 +60,7 @@ int main() {
     std::cout << "\n\n";
 
     std::cout << "String\n";
-    OrderedVector<std::string, RevOrderString> vsr(5);
+    OrderedVector<std::string, ReverseStringLess> vsr(5);
     vsr.add(std::string("one"));
     vsr.add(std::string("two"));
     vsr.add(std::string("three"));
@@ -64,7 +71,7 @@ int main() {
     std::cout << "\n\n";
 
     std::cout << "Complex with manhatan order\n";
-    OrderedVector<Complex, ManhattanOrder> vcm(5);
+    OrderedVector<Complex, ManhattanLess> vcm(5);
     vcm.add(Complex(1.5,0.0));
     vcm.add(Complex(1.0,1.0));
     vcm.add(Complex(-1.0,0.0));