Add exercises, small fixes, remove obsolete submodule

Author: xtofl

cpp11training/cpp11training/3.class_design.cpp

@@ -8,6 +8,48 @@
 #include "class_design/Vehicle.h"
 #include "class_design/MyBike.h"
 
+#include <utility>
+
+// Question from the class:
+// Uniform Initialization: can you specify a member variable default with braces?
+//   --> Yes.  It's called a "brace-or-equal-initializer"
+//   cf. https://arne-mertz.de/2015/08/new-c-features-default-initializers-for-member-variables/
+//
+class Person {
+public:
+    int birthyear = 1900; // <-- equal-initializer
+    std::string name{"John"}; // <-- brace-initializer
+    std::string given_name{"Doe"};
+};
+
+class Child : public Person {
+public:
+    Child(Person parent, int n, std::string name)
+        : Person{n, std::move(name), std::move(parent.given_name)}
+    {}
+};
+
+TEST(member_initializers, defaults_can_be_specified_in_class) {
+    Person x;
+    EXPECT_EQ(1900, x.birthyear);
+    EXPECT_EQ(std::string{"John"}, x.name);
+}
+
+TEST(member_initializers, defaults_can_be_overriden_with_aggregate_constructor)
+{
+    Person me{1976, "xtofl", "drarip"};
+    EXPECT_EQ(1976, me.birthyear);
+    EXPECT_EQ(std::string{"xtofl"}, me.name);
+}
+
+TEST(member_initializers, defaults_can_be_set_by_child_constructor)
+{
+    Person me{1976, "xtofl", "drarip"};
+
+    Child c{me, 2002, "Natan"};
+    EXPECT_EQ(std::string{"drarip"}, c.given_name);
+}
+
 // TODO:
 // visit Thing.h, and rename Thing::size_in_cm to size_in_m.
 // The code still compiles.  That's bad.  Make it so that inheritors

cpp11training/cpp11training/algorithms/2.set_algorithms.cpp

@@ -151,7 +151,7 @@ TEST_F(WithSomeData, DISABLED_find_lost_classmates)
         return lost_contains_if([&](const Person &p2) { return p == p2; });
     };
     EXPECT_TRUE(lost_person({ "Ton", "Lathauwers" }));
-    EXPECT_TRUE(lost_person({ "Stephen", "De Schrijver" }));
+    EXPECT_TRUE(lost_person({ "Stephan", "De Schrijver" }));
     EXPECT_FALSE(lost_person({ "Filip", "Dickens" }));
     EXPECT_FALSE(lost_person({ "Ton", "Sauerplum" }));
     EXPECT_FALSE(lost_person({ "Johan", "De Schrijver" }));

cpp11training/cpp11training/lambdas.cpp

@@ -9,6 +9,7 @@
 #include <exception>
 #include <algorithm>
 #include <cmath>
+#include <cctype>
 
 //////// DON'T TOUCH THIS
 // you should override these with local lambdas
@@ -78,6 +79,57 @@ TEST(lambdas, DISABLED_we_can_capture_local_variables_by_reference)
     EXPECT_EQ((std::vector<Op>{"+", "-", "*"}), sequence);
 }
 
+#include <algorithm>
+auto transform = [](auto &&x, auto f) {
+    return std::transform(begin(x), end(x), begin(x), f);
+};
+
+auto lowcase(std::string &s) { return transform(s, [](auto c){ return std::tolower(c);}); }
+auto upcase(std::string &s) { return transform(s, [](auto c){ return std::toupper(c);}); }
+
+TEST(lambdas, DISABLED_we_can_capture_by_const_reference)
+{
+    std::vector<std::string> tokens;
+
+    auto contains_token =
+    // TODO:
+    //  change the capture expression so that the lambda fails to compile
+    //  by capturing tokens as const
+    //  cf. https://stackoverflow.com/a/32440415/6610
+    //
+        [&tokens] (std::string_view text) {
+    // GOAL:
+    //   Become able to express that a lambda,
+    //   though it captures some variable, will not
+    //   actually _change_ that variable.
+    //
+    // NOTE: we only have capture by ref and capture by copy.
+    //  maybe capture by const-ref is an oversight in the standard?
+    //
+    // NOTE 2: you'll have to adapt the labmda body to make the test pass
+    //
+    // APPLICATION: when you want to avoid expensive copying of the
+    // closure, but have no control over the lambda body itself.
+    // In this case, the 'lack of control' is approximated by using
+    // some mutator functions that are out of our range.
+        for(auto &t: tokens) {
+            lowcase(t);
+            if (text.find(t) != text.npos) {
+                return true;
+            }
+            upcase(t);
+            if (text.find(t) != text.npos) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    tokens = {"token1", "token2"};
+    EXPECT_TRUE(contains_token("bla bla bla token2"));
+    EXPECT_EQ("token1", tokens[0]);
+    EXPECT_EQ("token2", tokens[1]);
+}
 
 TEST(lambdas, DISABLED_we_can_store_internal_state)
 {

moderncpp

@@ -43,52 +43,58 @@ This presentation focuses on the tools and the thought process.
 
 ## Context
 
-* Why do we have functions
-* Structured Programming
-    * => a tool for the user
-    * 'Structure' = divide and conquer
-        * -> how fine?  how coarse?
-        * how evenly?
-        <img src="http://www.rosslawinc.com/wp-content/uploads/2014/02/14B11-Stairs-1.jpg" style="width:200px"/>
+Q: Why do we have functions ?
 
---
+A: Structured Programming, divide and conquer
 
-### Notation
+--
 
-(TODO: find better name for 'our_function')
+### Why Functions
 
-* No more ~~foo~~ and ~~bar~~
-    * `ret_t our_function(arg_t)`
-    * ```
-    void client_code() {
-        ...
-        auto x = our_function(a);
-        ...
-    }```
+* As a reusable tool for the user
+* 'Structure' = divide and conquer
+    * -> how fine?  how coarse?
+    * how evenly?
+    <img src="http://www.rosslawinc.com/wp-content/uploads/2014/02/14B11-Stairs-1.jpg" style="width:200px"/>
 
 --
 
 ## Rationale
 
-* why bother?
-    * readability/learnability/usability
-    * who's the audience?
+why bother with the signature design?
+
+* Goals
+* Audience
+* Constraints
+* Tools
 
 --
 
 ### Goals of the Function Signature
 
-* what is the essence of the function
-    * easy to use
-    * hard to get wrong
-* indicate some non-functional aspects:
-    * sync/async
-    * side effects
-    * error handling indications
+Communication:
+
+* Functional aspects
+* Non-functional aspects
 
 --
 
-### Communication Context
+#### Communication: Functional Aspects
+
+* easy to use
+* hard to get wrong
+
+--
+
+#### Communication: Non-functional Aspects
+
+* sync/async
+* side effects
+* error handling indications
+
+--
+
+#### Communication Context
 
 Goals are served differently in different contexts
 
@@ -111,15 +117,35 @@ Goals are served differently in different contexts
 
 --
 
-### Goal
+### Constraints
+
+* Language
+    * English?
+    * C compatibility?
+* Time
+    * design for change!
+* Knowledge
+    * Of the audience
+    * Of the maintaining devs
+
+--
+
+### Tools
+
+To achieve this, we can use a number of tools
+
+Tool = generic term here
+
+--
+
+### Rationale: Conclusion
 
-Make the essence of the function
+Goal = make the essence of the function
 
 * as clear as possible
 * to all parties
 * in all situations
-
-With the tools we have at our disposal
+* with the tools we have at our disposal
 
 ---
 
@@ -454,20 +480,24 @@ if(w) { w->defaultValue("xxx"); }
 
 --
 
-### Wordt Type: Verb
+### Word Type: Verb
 
-* action
-* side-effect
-* non-pure
+* present tense: action, side-effect
+    * `shuffle(begin(xs), end(xs))`
+    * non-pure
+* past tense: derivative
+    * `sorted(range)`
+    * pure
 
 --
 
-### Wordt Type: Adjective
+### Word Type: Adjective
 
-* property
-* predicate
-    * replace `isBig()` with `big()`
-    * replace `hasX()` with `optional<X> x()` or `withX(callback)`
+* property: describes an aspect
+    * `Person.name`
+* predicate: answer to yes/no question
+    * C++: replace `isBig()` with `big()`
+    * C++: replace `hasX()` with `optional<X> x()` or `withX(callback)`
 
 --
 
@@ -488,13 +518,20 @@ if(w) { w->defaultValue("xxx"); }
     * more examples?
 * even level of abstraction
 
+--
+
+Hints:
+
+* use a synonym dictionary e.g. [m-w](https://www.merriam-webster.com/thesaurus/clear).
+* mind irregular verbs (to read/read/read: very ambiguous)
+* ask a native English speaker
 
 --
 
 ### Context avoids Repetition
 
-* `math::sin` vs. `confession::sin`
-* `myMachine.startMachine()`???
+* `myMachine.start()` starts what?
+    * C, Pascal, ...: `machine_start(machine)` for lack of namespaces/classes
 
 --