Reorganization. module1, module2, move_semantics and shapes

Author: ziobron

.travis.yml

@@ -17,8 +17,8 @@ compiler:
   - clang
 
 script:
-  - mkdir build
-  - cd build
+  - mkdir shapes/build
+  - cd shapes/build
   - cmake ..
   - make
-  - ./modern_cpp
+  - ./shapes

module1/00_coffee_break.md

@@ -0,0 +1,10 @@
+<!-- .slide: data-background="#8B3536" -->
+# Break
+
+# &#9749; <!-- .element style="font-size: 5em"-->
+
+___
+
+## Recap
+
+### What were we talking about before the break?

module1/00_intro.md

@@ -0,0 +1,74 @@
+## Let's get to know each other
+
+* Your name and programming experience
+* What you do not like in C++?
+* Your hobbies
+
+___
+<!-- .slide: data-background="../img/lukasz.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
+
+* Frontend dev & DevOps @ Coders School
+* C++ and Python developer @ Nokia & Credit Suisse
+* Team leader & Trainer @ Nokia
+* Scrum Master @ Nokia & Credit Suisse
+* Code Reviewer @ Nokia
+* Webdeveloper (HTML, PHP, CSS) @ StarCraft Area
+
+</div>
+
+<div class="box fragment" style="width: 45%; right: 0; top: 100px;">
+
+### Training experience
+
+* C++ trainings @ Coders School
+* Practical Aspects Of Software Engineering @ PWr & UWr
+* Nokia Academy @ Nokia
+* Internal corporate trainings
+
+</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
+
+</div>
+
+<div class="box fragment" style="width: 45%; right: 0; top: 400px;">
+
+### Hobbies
+
+* StarCraft Brood War & StarCraft II
+* Motorcycles
+* Photography
+* Archery
+* Andragogy
+
+</div>
+
+___
+
+## Contract
+
+<ul>
+    <li class="fragment fade-in">🎰 Vegas rule</li>
+    <li class="fragment fade-in">🗣 Discussion, not a lecture</li>
+    <li class="fragment fade-in">☕️ Additional breaks on demand</li>
+    <li class="fragment fade-in">⌚️ Be on time after breaks</li>
+</ul>
+
+Note:
+Vegas rule: What happens in Vegas, it stays in Vegas.
+If you want to complain about the employer, I won't tell anyone
+
+___
+
+### [Link to presentation on GitHub](https://github.com/coders-school/advanced_cpp/tree/master/md.modern_cpp_basic_fatures)

module1/00_lunch_break.md

@@ -0,0 +1,10 @@
+<!-- .slide: data-background="#cf802a" -->
+# Lunch break
+
+# &#127837; <!-- .element style="font-size: 5em"-->
+
+___
+
+## Recap
+
+### What were we talking about before the break?

module1/auto.md

@@ -0,0 +1,164 @@
+<!-- .slide: data-background="#111111" -->
+# Automatic type deduction
+
+___
+
+## `auto` keyword
+
+```cpp
+auto a;         // error: declaration of ‘auto a’ has no initializer
+auto i = 42;    // i is int
+auto u = 42u;   // u is unsigned
+auto d = 42.0;  // d is double
+auto f = 42.0f; // f is float
+
+double f();
+auto r1 = f();  // r1 is double
+
+std::set<std::string> collection;
+auto it = collection.begin(); // it is std::set<std::string>::iterator
+```
+
+**Rationale**: Not important (but strongly defined) types, less typing, less refactoring.
+<!-- .element: class="fragment fade-in" -->
+
+* <!-- .element: class="fragment fade-in" --> A compiler can automatically deduce the type of variable during initialization
+* <!-- .element: class="fragment fade-in" --> Deduction is made from a literal, other variable or a function return type
+* <!-- .element: class="fragment fade-in" --> The same rules as for templates deduction are applied
+
+___
+
+## Variable modifiers
+
+```cpp
+int func() { return 10; }
+
+int main() {
+    const auto& v1 = func(); // v1 is const int&
+    const auto v2 = func();  // v2 is const int
+    // auto& v3 = func();    // error: cannot bind non-const lvalue reference
+                             // of type ‘int&’ to an rvalue of type ‘int’
+    auto v4 = func();        // v4 is int
+    return 0;
+}
+```
+
+___
+<!-- .slide: style="font-size: 0.9em" -->
+
+### Deduction rules for references
+
+```cpp
+const vector<int> values;
+auto v1 = values;   // v1 : vector<int>
+auto& v2 = values;  // v2 : const vector<int>&
+
+volatile long clock = 0L;
+auto c1 = clock;    // c1 : long
+auto& c2 = clock;   // c2 : volatile long&
+
+Gadget items[10];
+auto g1 = items;    // g1 : Gadget*
+auto& g2 = items;   // g2 : Gadget(&)[10] - a reference to
+                    // the 10-elementh array of Gadgets
+
+int func(double) { return 10; }
+auto f1 = func;     // f1 : int (*)(double)
+auto& f2 = func ;   // f2: int (&)(double)
+```
+
+* <!-- .element: class="fragment fade-in" --> Reference means the same object with the same properties
+* <!-- .element: class="fragment fade-in" --> Reference preserves cv-qualifiers (<code>const</code>, <code>volatile</code>)
+* <!-- .element: class="fragment fade-in" --> Copy drops cv-qualifiers
+* <!-- .element: class="fragment fade-in" --> Copy of array decays to a pointer
+
+___
+
+### Function declaration with arrow
+
+```cpp
+int sum(int a, int b);
+auto sum(int a, int b) -> int;
+
+
+auto isEven = [](int a) -> bool {
+    return a % 2;
+}
+```
+
+Introduced to allow definition of the type returned from lambda functions.
+<!-- .element: class="fragment fade-in" -->
+
+___
+<!-- .slide: style="font-size: 0.9em" -->
+
+### Deduction of a function returned type
+
+```cpp
+auto multiply(int x, int y) {
+    return x * y;
+}
+
+auto get_name(int id) {
+    if (id == 1)
+        return std::string("Gadget");
+    else if (id == 2)
+        return std::string("SuperGadget");
+    return string("Unknown");
+}
+
+auto factorial(int n) {
+    if (n == 1)
+        return 1;
+    return factorial(n - 1) * n;
+}
+```
+
+* <!-- .element: class="fragment fade-in" --> Introduced in C++14
+* <!-- .element: class="fragment fade-in" --> Deduction mechanism is the same as for deduction of variable types
+* <!-- .element: class="fragment fade-in" --> All <code>return</code> instructions must return the same type
+* <!-- .element: class="fragment fade-in" --> Recursion allowed only if recursive function call is not a first <code>return</code> statement
+
+___
+
+## range-based for loop
+
+```cpp
+std::vector<int> v = {0, 1, 2, 3, 4, 5};
+
+for (const auto & element : v) {
+    std::cout << element << ' ';
+}
+std::cout << '\n';
+```
+
+___
+
+### Generated code for-range based for loop
+
+```cpp
+{
+    auto && __range = range_expression ;
+    auto __begin = begin_expr ;
+    auto __end = end_expr ;
+    for ( ; __begin != __end; ++__begin) {
+        range_declaration = *__begin;
+        loop_statement
+    }
+}
+```
+
+___
+<!-- .slide: data-background="#cf802a" -->
+
+## Exercise
+
+Put auto wherever you think is good.
+
+Use range-based for loops wherever possible.
+
+### Let's have some fun :)
+<!-- .element: class="fragment fade-in" -->
+
+Connect to my VSC and edit my program simultaneously.
+<!-- .element: class="fragment fade-in" -->

module1/decltype.md

@@ -0,0 +1,34 @@
+## `decltype`
+
+**Rationale**: Deduction provided in contexts where auto is not allowed.
+
+`decltype` allows a compiler to deduce the type of the variable or expression, eg. the returned type can be deduced from function parameters.
+
+```cpp
+std::map<std::string, float> collection;
+
+decltype(collection) other;              // other has type of collection
+decltype(collection)::mapped_type value; // value is float
+
+template <typename T1, typename T2>
+auto add(T1 a, T2 b) -> decltype(a + b)  // from C++14 decltype not necessary
+{
+    return a + b;
+}
+```
+
+___
+
+## `decltype(auto)`
+
+`decltype(auto)` deduction mechanism preserves type modifiers (references, const, volatile).
+
+`auto` deduction mechanism does not preserve type modifiers.
+
+```cpp
+template<class FunctionType, class... Args>
+decltype(auto) Example(FunctionType fun, Args&&... args)
+{
+    return fun(std::forward<Args>(args)...);
+}
+```