revamp for cr session2

Author: ziobron

img/lukin.jpg

@@ -0,0 +1,64 @@
+## Something about you
+
+* What you don't like in C++?
+* What other programming languages do you know?
+
+___
+<!-- .slide: data-background="../img/lukin.jpg" -->
+
+<h2 style="text-shadow: 2px 2px black;">Łukasz Ziobroń</h2>
+<div class="box fragment" style="width: 45%; left: 0; top: 100px;">
+
+### Not only a programming XP
+
+* Front-end dev, DevOps & Owner @ Coders School
+* C++ and Python developer @ Nokia & Credit Suisse
+* Team leader & Trainer @ Nokia
+* Scrum Master @ Nokia & Credit Suisse
+* Code Reviewer @ Nokia
+* Web developer (HTML, PHP, CSS) @ StarCraft Area
+
+</div>
+
+<div class="box fragment" style="width: 45%; right: 0; top: 100px;">
+
+### Experience as a trainer
+
+* <a href="https://coders.school/kurs-online">C++ online course</a> @ Coders School
+* Company trainings @ Coders School
+* Practical Aspects Of Software Engineering @ PWr & UWr
+* Nokia Academy @ Nokia
+
+</div>
+
+<div class="box fragment" style="width: 45%; left: 0; top: 400px;">
+
+### Public speaking experience
+
+* code::dive conference
+* code::dive community
+* Academic Championships in Team Programming
+* <a href="http://youtube.com/c/CodersSchool">Coders School YouTube channel</a>
+
+</div>
+
+<div class="box fragment" style="width: 45%; right: 0; top: 400px;">
+
+### Hobbies
+
+* StarCraft Brood War & StarCraft II
+* Motorcycles
+* Photography
+* Archery
+* Andragogy
+
+</div>
+
+___
+
+## Contract
+
+* <!-- .element: class="fragment fade-in" --> 🎰 Vegas rule
+* <!-- .element: class="fragment fade-in" --> 🗣 Discussion, not a lecture
+* <!-- .element: class="fragment fade-in" --> ☕️ Additional breaks on demand
+* <!-- .element: class="fragment fade-in" --> ⌚️ Be on time after breaks

module3/00-intro.md

@@ -0,0 +1,43 @@
+## Pre-test 📝
+
+___
+
+### Question 1/2
+
+We have only the below template function defined.
+What will happen in each case? Which example will compile and display "OK"?
+
+```cpp
+template <typename T>
+void foo(T && a) {std::cout << "OK\n"; }
+
+int a = 5;
+```
+
+1. <code>foo(4);</code>
+2. <code>foo(a);</code>
+3. <code>foo(std::move(a));</code>
+
+___
+
+### Question 2/2
+
+What will be printed on the screen?
+
+```cpp
+class Gadget {};
+void f(const Gadget&) { std::cout << "const Gadget&\n"; }
+void f(Gadget&)       { std::cout << "Gadget&\n"; }
+void f(Gadget&&)      { std::cout << "Gadget&&\n"; }
+
+template <typename Gadget>
+void use(Gadget&& g) { f(g); }
+
+int main() {
+    const Gadget cg;
+    Gadget g;
+    use(cg);
+    use(g);
+    use(Gadget());
+}
+```

module3/01-pretest.md

@@ -70,7 +70,7 @@ str1 += str2                    <span class="fragment">// l-value</span>
 str1 + str2                     <span class="fragment">// r-value</span>
 [](int x){ return x * x; };     <span class="fragment">// r-value</span>
 std::move(a);                   <span class="fragment">// r-value</span>
-int && a = 4;                   <span class="fragment">// 4 is r-value</span>
+int && a = 4;                   <span class="fragment">// 4 is an r-value</span>
 </code></pre>
 
 ___

module3/move_semantics_rvalues_lvalues.md renamed to module3/02-rvalues-lvalues.md

@@ -1,11 +1,13 @@
+<!-- .slide: style="font-size: 0.9em" -->
+
 ## Usage of move semantics
 
 ```cpp
 template <typename T>
 class Container {
 public:
-    void insert(const T& item);  // inserts a copy of item
-    void insert(T&& item);       // moves item into container
+    void insert(const T& item);  // inserts a copy of an item
+    void insert(T&& item);       // moves item into the container
 };
 
 Container<std::string> c;
@@ -14,11 +16,11 @@ std::string str = "text";
 c.insert(str);              // lvalue -> insert(const std::string&)
                             // inserts a copy of str, str is used later
 c.insert(str + str);        // rvalue -> insert(string&&)
-                            // moves temporary into container
+                            // moves temporary into the container
 c.insert("text");           // rvalue -> insert(string&&)
-                            // moves temporary into container
+                            // moves temporary into the container
 c.insert(std::move(str));   // rvalue -> insert(string&&)
-                            // moves str into container, str is no longer used
+                            // moves str into the container, str is no longer used
 ```
 
 ___
@@ -28,12 +30,12 @@ ___
 * <!-- .element: class="fragment fade-in" --> Transfer all data from the source to the target
 * <!-- .element: class="fragment fade-in" --> Leave the source object in an unknown, but safe to delete state
 * <!-- .element: class="fragment fade-in" --> The source object should never be used
-* <!-- .element: class="fragment fade-in" --> The source object can only be safely destroyed or, if possible, new resource can be assigned to it (eg. <code>reset()</code>)
+* <!-- .element: class="fragment fade-in" --> The source object can only be safely destroyed or, if possible, a new resource can be assigned to it (eg. <code>reset()</code>)
 
 ```cpp
 std::unique_ptr<int> pointer1{new int{5}};
 std::unique_ptr<int> pointer2 = std::move(pointer1);
-*pointer1 = 4;  // Undefined behavior, pointer1 is in moved-from state
+*pointer1 = 4;  // Undefined behaviour, pointer1 is in the moved-from state
 pointer1.reset(new int{20});    // OK
 ```
 <!-- .element: class="fragment fade-in" -->

module3/move_semantics_usage.md renamed to module3/03-usage.md

@@ -1,3 +1,5 @@
+<!-- .slide: style="font-size: 0.9em" -->
+
 ## Implementation of move semantic
 
 ```cpp
@@ -38,14 +40,11 @@ ___
 
 ## Task
 
-Aim: learn how to implement move semantics with manual resource management
-
-Write your own implementation of `unique_ptr`
+Write your implementation of `unique_ptr`
 
-Let's try online Coding Dojo :)
-<!-- .element: class="fragment highlight-green" -->
+Aim: learn how to implement move semantics with manual resource management
 
-#### Hints
+### Hints
 
 <!-- .element: class="fragment fade-in" -->
 
@@ -54,7 +53,7 @@ Let's try online Coding Dojo :)
 * <!-- .element: class="fragment fade-in" --> Copy operations not allowed
 * <!-- .element: class="fragment fade-in" --> Move operations allowed
 * <!-- .element: class="fragment fade-in" --> <a href="https://en.cppreference.com/w/cpp/memory/unique_ptr">Interface functions</a> - at least:
-    * <code>T* get() const noexcept</code>
-    * <code>T& operator*() const</code>
-    * <code>T* operator->() const noexcept</code>
-    * <code>void reset(T* = nullptr) noexcept</code>
+  * <code>T* get() const noexcept</code>
+  * <code>T& operator*() const</code>
+  * <code>T* operator->() const noexcept</code>
+  * <code>void reset(T* = nullptr) noexcept</code>

module3/move_semantics_implementation.md renamed to module3/04-implementation.md

@@ -4,7 +4,7 @@ If you define at least one of:
 <!-- .element: class="fragment fade-in" -->
 
 * <!-- .element: class="fragment fade-in" --> destructor
-* <!-- .element: class="fragment fade-in" --> copy constructor 
+* <!-- .element: class="fragment fade-in" --> copy constructor
 * <!-- .element: class="fragment fade-in" --> copy assignment operator
 
 it means that you are manually managing resources and <span class="fragment highlight-red">you should implement them all</span>.
@@ -20,7 +20,7 @@ ___
 Rule of 5 = Rule of 3 + optimizations
 
 * destructor
-* copy constructor 
+* copy constructor
 * copy assignment operator
 * <!-- .element: class="fragment highlight-green" --> move constructor
 * <!-- .element: class="fragment highlight-green" --> move assignment operator
@@ -38,7 +38,7 @@ Do not implement any of Rule of 5 functions 😎
 If you use RAII handlers (like smart pointers), all the copy and move operations will be generated (or deleted) implicitly.
 <!-- .element: class="fragment fade-in" -->
 
-Eg. when you have unique_ptr as your class member, copy operations of your class will be automatically blocked, but move operations will be supported.
+For example, when you have a `unique_ptr` as your class member, copy operations of your class will be automatically blocked, but move operations will be supported.
 <!-- .element: class="fragment fade-in" -->
 
 ___
@@ -47,12 +47,12 @@ ___
 
 Aim: learn how to refactor code to use RAII and Rule of 0
 
-Write a template class which holds a pointer
+Write a template class that holds a pointer
 
-* <!-- .element: class="fragment fade-in" --> use raw pointer to manage resource of a template type
+* <!-- .element: class="fragment fade-in" --> use a raw pointer to manage the resource of a template type
 * <!-- .element: class="fragment fade-in" --> implement constructor to acquire a resource
-* <!-- .element: class="fragment fade-in" --> implement Rule of 3
-* <!-- .element: class="fragment fade-in" --> implement Rule of 5
-* <!-- .element: class="fragment fade-in" --> implement Rule of 0
-  * use proper smart pointer instead of raw pointer
+* <!-- .element: class="fragment fade-in" --> implement the Rule of 3
+* <!-- .element: class="fragment fade-in" --> implement the Rule of 5
+* <!-- .element: class="fragment fade-in" --> implement the Rule of 0
+  * use a roper smart pointer instead of the raw pointer
   <!-- .element: class="fragment fade-in" -->

module3/move_semantics_rules.md renamed to module3/05-rules.md

@@ -1,4 +1,6 @@
-## Implementation of `std::move()` and "universal reference"
+## Implementation of `std::move()`
+
+### "universal reference"
 
 ```cpp
 template <typename T>

module3/move_semantics_std_move.md renamed to module3/06-std-move.md

@@ -0,0 +1,30 @@
+## Reference collapsing rules
+
+* <!-- .element: class="fragment fade-in" --> <code>T& &</code> -> <code>T&</code>
+* <!-- .element: class="fragment fade-in" --> <code>T& &&</code> -> <code>T&</code>
+* <!-- .element: class="fragment fade-in" --> <code>T&& &</code> -> <code>T&</code>
+* <!-- .element: class="fragment fade-in" --> <code>T&& &&</code> -> <code>T&&</code>
+
+___
+
+## Reference collapsing
+
+When a template is being instantiated reference collapsing may occur
+
+```cpp
+template <typename T>
+void f(T & item) {}    // takes item always as an l-value reference
+
+void f(int& & item);   // passing int& as a param, like f(a) -> f(int&)
+void f(int&& & item);  // passing int&& as a param, like f(5) -> f(int&)
+```
+<!-- .element: class="fragment fade-in" -->
+
+```cpp
+template <typename T>
+void g(T && item) {}   // takes item as a forwarding reference
+
+void g(int& && item);  // passing int& as a param, like g(a) -> f(int&)
+void g(int&& && item); // passing int&& as a param, like g(5) -> f(int&&)
+```
+<!-- .element: class="fragment fade-in" -->

module3/07-reference-collapsing.md

@@ -1,6 +1,8 @@
+<!-- .slide: style="font-size: 0.9em" -->
+
 ## Interface bloat
 
-Trying to optimize for every possible use case may lead to an interface bloat
+Trying to optimize for every possible use case may lead to an interface bloat.
 
 ```cpp
 class Gadget;
@@ -20,14 +22,17 @@ int main() {
 }
 ```
 
-Task: Try to improve the `use()` function to catch more types of reference to have less overloads.
+### Task
+
+Improve the `use()` function to catch more types of references to have fewer overloads.
 <!-- .element: class="fragment fade-in" -->
 
 ___
 
-## Perfect Forwarding
+## Solution: Perfect Forwarding
 
 Forwarding reference `T&&` + `std::forward()` is a solution to interface bloat.
+<!-- .element: class="fragment fade-in" -->
 
 ```cpp
 class Gadget;
@@ -49,36 +54,37 @@ int main() {
     use(Gadget()); // calls use(Gadget&&) then calls f(Gadget&&)
 }
 ```
+<!-- .element: class="fragment fade-in" -->
 
 ___
 
 ## `std::forward`
 
-Forwarding reference (even bind to r-value) is treated as l-value inside template function
+Forwarding reference (even bind to r-value) is treated as l-value inside a template function.
 
 ```cpp
 template <typename T>
 void use(T&& t) {
-    f(t);                   // t is treated as l-value unconditionally
+    f(t);                   // t treated as l-value unconditionally
 }
 ```
 <!-- .element: class="fragment fade-in" -->
 
 ```cpp
 template <typename T>
 void use(T&& t) {
-    f(std::move(t));        // t is treated as r-value unconditionally
+    f(std::move(t));        // t treated as r-value unconditionally
 }
 ```
 <!-- .element: class="fragment fade-in" -->
 
 ```cpp
 template <typename T>
-void use(T&& t) {           // pass t as r-value if r-value was passed,
-    f(std::forward(t));     // pass as l-value otherwise
+void use(T&& t) {           // forwards t as r-value if r-value was passed,
+    f(std::forward(t));     // forwards as l-value otherwise
 }
 ```
 <!-- .element: class="fragment fade-in" -->
 
-In other words: `std::forward()` restores original reference type.
+In other words, `std::forward()` restores the original reference type.
 <!-- .element: class="fragment fade-in" -->

module3/move_semantics_std_forward.md renamed to module3/08-std-forward.md

@@ -16,7 +16,7 @@ T x = T(T(f())); // only one call to default c-tor of T, to initialize x
 ```
 <!-- .element: class="fragment fade-in" -->
 
-* <!-- .element: class="fragment fade-in" --> in return statement, when the object is temporary (RVO - Return Value Optimisation)
+* <!-- .element: class="fragment fade-in" --> in the <code>return</code> statement, when the object is temporary (RVO - Return Value Optimisation)
 * <!-- .element: class="fragment fade-in" --> in the initialization, when the initializer is of the same class and is temporary
 
 Do not try to "optimize" code by writing `return std::move(sth);`. It may prevent optimizations.