Review operators exercise and split a preceding classes exercise from it.

Author: chavid

exercises/ExerciseSchedule_EssentialCourse.md

@@ -37,10 +37,12 @@ People should replay them and discover the tools by themselves.
 Day 2 - OO Exercises
 --------------------
 
-### Polymorphism (directory: [`polymorphism`](polymorphism), [CheatSheet](ExercisesCheatSheet.md#polymorphism-directory-polymorphism))
+### My first classes (directory: [`classes`](classes), [CheatSheet](ExercisesCheatSheet.md#classes-directory-classes))
 
 ### Operator overloading (directory: [`operators`](operators), [CheatSheet](ExercisesCheatSheet.md#operator-overloading-directory-operators))
 
+### Polymorphism (directory: [`polymorphism`](polymorphism), [CheatSheet](ExercisesCheatSheet.md#polymorphism-directory-polymorphism))
+
 ### Virtual inheritance (directory: [`virtual_inheritance`](virtual_inheritance), [CheatSheet](ExercisesCheatSheet.md#virtual-inheritance-directory-virtual_inheritance))
 
 

exercises/ExercisesCheatSheet.md

@@ -45,6 +45,37 @@ The idea of this exercise is to play with all kinds of possible loops and contro
 Object-orientation Exercises
 ----------------------------
 
+### Classes (directory: [`classes`](classes))
+
+This exercise is about doing a basic class, not using any operator overloading. It also paves the way for object-functions, making a first algo-like class.
+
+You may discuss with the students:
+- pros and cons of making the constructor explicit or not,
+- pros and cons of having multiply() and equal() either as member functions,
+  friend free functions or external free functions.
+- optionally, thed difference between equality and equivalence.
+
+NOTE: I did not find a justified need to add operator=...
+
+### Operator overloading (directory: [`operators`](operators))
+
+Here we take the class from the previous exercise, and we try to make
+anything an operator that makes sense.
+
+Tips and tricks:
+- When the argument of CHECK() has a comma not between parentheses, for example
+  curly braces, add an additional global level of parenthesis, or CHECK() will
+  think it has several arguments.
+
+You may discuss with the students:
+- the chaining of operator<<
+- in a set of consistent operators (such as == and !=),
+  reusing versus performance.
+- object-functions.
+- for what concerns the related operators, such as * and *=,
+  the choice to be made consitent reuse or performant
+  specialization of each operator.
+
 ### Polymorphism (directory: [`polymorphism`](polymorphism))
 
 First create a Pentagon and an Hexagon and call computePerimeter. Can be used to break the ice.
@@ -79,22 +110,6 @@ See and solve the compilation issue about missing Drawable constructor. Understa
 See the new id being printed twice.
 
 
-### Operator overloading (directory: [`operators`](operators))
-
-This exercise is about making `main` run successfully by completing the implementation of `Fraction`.
-Implement a constructor for `Fraction` and add two integer data members for numerator and denominator.
-Comment out everything in `main` except the first two LOCs.
-This should compile now and print nothing.
-
-Then uncomment the `std::cout` statements and implement `operator<<` for `Fraction`.
-Compile and run.
-
-Proceed this way through the entire exercise.
-There are multiple possibilities to implement some operators, e.g. as members, as hidden friends, or as free functions.
-Also when and where to normalize a fraction is up to the students.
-All solutions are fine, as long as the `main` function runs successfully.
-
-
 Modern C++ Exercises
 --------------------
 

exercises/classes/.gitignore

@@ -0,0 +1 @@
+classes classes_sol

exercises/classes/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Set up the project.
+cmake_minimum_required( VERSION 3.12 )
+project( operators LANGUAGES CXX )
+
+# Set up the compilation environment.
+include( "${CMAKE_CURRENT_SOURCE_DIR}/../common.cmake" )
+
+# Create the user's executable.
+add_executable( classes "classes.cpp" )
+
+# Create the "solution executable".
+add_executable( classes_sol EXCLUDE_FROM_ALL "solution/classes_sol.cpp" )
+add_dependencies( solution classes_sol )

exercises/classes/Makefile

@@ -0,0 +1,11 @@
+all: classes
+solution: classes_sol
+
+clean:
+	rm -f *o classes *~ classes_sol
+
+classes : classes.cpp
+	${CXX} -g -std=c++17 -O0 -Wall -Wextra -L. -o $@ $<
+
+classes_sol : solution/classes_sol.cpp
+	${CXX} -g -std=c++17 -O0 -Wall -Wextra -L. -o $@ $<

exercises/classes/README.md

@@ -0,0 +1,33 @@
+
+## Instructions
+
+STEP 1
+- Complete the class Fraction so that a Fraction can be construct from one or two integer.
+  Check the first two lines of main() are working (comment out the rest)
+- Add the function equal().
+  Check the second section of main() works.
+- Add the function multiply().
+  Check the whole main() works.
+
+STEP 2
+- Replace the function printTestResult() by a class TestResultPrinter
+  with a method process() that take the same arguments as before.
+  Upgrade CHECK() and main().
+- Transform the WIDTH constant into a variable member of TestResultPrinter,
+  which is initialized in its constructor.
+  Upgrade main().
+
+OPTIONAL STEP 3
+- Move multiply() and compare() as friend functions within the class Fraction.
+  Check main() works.
+- Remove the accessors numerator() and denominator().
+  Check main() works.
+
+OPTIONAL STEP 4
+- Remove the systematic call to normalize().
+- Add a equivalent() method to Fraction.
+- Upgrade the tests accordingly.
+- Transform the private normalize() into a public const normalized() method
+  which return the normalized fraction.
+- Add some tests to check normalized().
+

exercises/classes/classes.cpp

@@ -0,0 +1,75 @@
+#include <iomanip>
+#include <iostream>
+#include <numeric>
+
+class Fraction {
+
+public:
+
+  // ADD YOUR CODE HERE
+
+  std::string str() const {
+    std::ostringstream oss;
+    oss << m_num << '/' << m_denom;
+    return oss.str();
+  }
+
+  int numerator() const {
+    return m_num;
+  }
+  int denominator() const {
+    return m_denom;
+  }
+
+private:
+
+  void normalize() {
+    const int gcd = std::gcd(m_num, m_denom);
+    m_num /= gcd;
+    m_denom /= gcd;
+  }
+
+  int m_num, m_denom;
+};
+
+// ADD YOUR CODE HERE
+
+#define CHECK(print,what) print(#what, what)
+
+unsigned int WIDTH {20};
+
+void printTestResult(std::string const & what, bool passed) {
+  std::cout << std::setw(WIDTH) << what << ": " << (passed ? "PASS" : "** FAIL **") << '\n';
+}
+
+int main() {
+
+  // create a fraction with values 3 (which is 3/1) and 1/3
+  std::cout<<std::endl;
+  const Fraction three{3};
+  const Fraction third{1, 3};
+  std::cout<<three.str()<<' '<<third.str()<<'\n';
+
+  // equality
+  std::cout<<std::endl;
+  CHECK(printTestResult,equal(three,three));
+  CHECK(printTestResult,equal(third,third));
+  CHECK(printTestResult,equal(three,Fraction{3}));
+  CHECK(printTestResult,equal(three,Fraction{3, 1}));
+  CHECK(printTestResult,equal(third,Fraction{1, 3}));
+  CHECK(printTestResult,equal(Fraction{3},three));
+  CHECK(printTestResult,equal(Fraction{1, 3},third));
+  CHECK(printTestResult,equal(third,Fraction{2, 6}));
+
+  // multiply
+  std::cout<<std::endl;
+  CHECK(printTestResult,equal(multiply(third,2),Fraction{2, 3}));
+  CHECK(printTestResult,equal(multiply(2,third),Fraction{2, 3}));
+  CHECK(printTestResult,equal(multiply(three,third),Fraction{1, 1}));
+  CHECK(printTestResult,equal(multiply(3,third),1));
+
+  // end
+  std::cout<<std::endl;
+
+}
+  

exercises/classes/classes_sol

@@ -0,0 +1,95 @@
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <numeric>
+
+class Fraction {
+
+public:
+
+  Fraction(int a_num, int a_denom = 1) : m_num(a_num), m_denom(a_denom) {}
+
+  std::string str() const {
+    std::ostringstream oss;
+    oss << m_num << '/' << m_denom;
+    return oss.str();
+  }
+
+  friend bool equal( Fraction const & lhs, Fraction const & rhs ) {
+    return (lhs.m_num==rhs.m_num) && (lhs.m_denom==rhs.m_denom);
+  }
+  
+  friend bool equivalent( Fraction const & lhs, Fraction const & rhs ) {
+    return (lhs.m_num*rhs.m_denom==rhs.m_num*lhs.m_denom);
+  }
+  
+  friend Fraction multiply( Fraction const & lhs, Fraction const & rhs ) {
+    return {lhs.m_num*rhs.m_num, lhs.m_denom*rhs.m_denom};
+  }
+  
+  Fraction normalized() const {
+    const int gcd = std::gcd(m_num, m_denom);
+    return {m_num/gcd, m_denom/gcd};
+  }
+
+private:
+
+  int m_num, m_denom;
+};
+
+class TestResultPrinter {
+
+public:
+
+  TestResultPrinter( unsigned int a_width ) : m_width(a_width) {}
+
+  void process(std::string const & what, bool passed) {
+    std::cout << std::left << std::setw(m_width) << what << ": " << (passed ? "PASS" : "** FAIL **") << '\n';
+  }
+  
+private: 
+
+  unsigned int m_width;
+
+};
+
+#define CHECK(printer,what) printer.process(#what, what)
+
+int main() {
+
+  // create a fraction with values 3 (which is 3/1) and 1/3
+  std::cout<<std::endl;
+  const Fraction three{3};
+  const Fraction third{1, 3};
+  std::cout<<three.str()<<' '<<third.str()<<'\n';
+  
+  // equality
+  std::cout<<std::endl;
+  TestResultPrinter p1{27};
+  CHECK(p1,equal(three,three));
+  CHECK(p1,equal(third,third));
+  CHECK(p1,equal(three,Fraction{3}));
+  CHECK(p1,equal(three,Fraction{3,1}));
+  CHECK(p1,equal(third,Fraction{1,3}));
+  CHECK(p1,equal(Fraction{3},three));
+  CHECK(p1,equal(Fraction{1,3},third));
+
+  // equivalence
+  std::cout<<std::endl;
+  TestResultPrinter p2{40};
+  CHECK(p2,!equal(third,Fraction{2,6}));
+  CHECK(p2,equivalent(third,Fraction{2,6}));
+  CHECK(p2,equal(third,Fraction{2,6}.normalized()));
+
+  // multiply
+  std::cout<<std::endl;
+  TestResultPrinter p3{48};
+  CHECK(p3,equal(multiply(third,2),Fraction{2,3}));
+  CHECK(p3,equal(multiply(2,third),Fraction{2,3}));
+  CHECK(p3,equivalent(multiply(three,third),Fraction{1,1}));
+  CHECK(p3,equivalent(multiply(3,third),1));
+
+  // end
+  std::cout<<std::endl;
+
+}

exercises/classes/solution/classes_sol.cpp

@@ -0,0 +1,2 @@
+operators
+operators_sol

exercises/operators/.gitignore

@@ -4,10 +4,11 @@ project( operators LANGUAGES CXX )
 
 # Set up the compilation environment.
 include( "${CMAKE_CURRENT_SOURCE_DIR}/../common.cmake" )
+set( CMAKE_CXX_STANDARD 20 )
 
 # Create the user's executable.
 add_executable( operators "operators.cpp" )
 
 # Create the "solution executable".
-add_executable( operators.sol EXCLUDE_FROM_ALL "solution/operators.sol.cpp" )
-add_dependencies( solution operators.sol )
+add_executable( operators_sol EXCLUDE_FROM_ALL "solution/operators_sol.cpp" )
+add_dependencies( solution operators_sol )

exercises/operators/CMakeLists.txt

@@ -1,11 +1,11 @@
 all: operators
-solution: operators.sol
+solution: operators_sol
 
 clean:
-	rm -f *o operators *~ operators.sol
+	rm -f *o operators *~ operators_sol
 
 operators : operators.cpp
-	${CXX} -g -std=c++17 -O0 -Wall -Wextra -L. -o $@ $<
+	${CXX} -g -std=c++20 -O0 -Wall -Wextra -L. -o $@ $<
 
-operators.sol : solution/operators.sol.cpp
-	${CXX} -g -std=c++17 -O0 -Wall -Wextra -L. -o $@ $<
+operators_sol : solution/operators_sol.cpp
+	${CXX} -g -std=c++20 -O0 -Wall -Wextra -L. -o $@ $<

exercises/operators/Makefile

@@ -1,6 +1,27 @@
 
 ## Instructions
 
-* inspect main and complete the implementation of class Fraction step by step
-  * you can comment out parts of main to test in between
-* when possible, prefer non-member operators and friend for operators
+STEP 1
+- Add a free operator<<, reusing str(), and simplify main() first lines.
+- Replace equal() with operator==(), and upgrade tests.
+- Add operator!=(), reusing operator==(), and upgrade tests.
+- Replace compare() with operator<=>(), reusing <=> between doubles,
+  and upgrade tests.
+- Replace multiply() with operator*(), and upgrade tests. 
+
+STEP 2
+- Replace TestResultPrinter::process() with operator()(), and upgrade CHECK().
+
+OPTIONAL STEP 3
+- Add an inplace multiplication operator*=(), and add tests.
+- Review operator*() so to reuse operator*=().
+- Ensure calls to operator*=() can be chained, the same as operator<<().
+
+## Take aways
+
+- Do not confuse equality and equivalence.
+- We can very often implement an arithemtic operator@ in terms of operator@=.
+- When implementing <=>, you get <, >, <=, >= for free.
+- Object-functions are very used with standard algorithms,
+  yet tend to be often replaced by lambdas in modern C++.
+