Initial commit

Author: dennis

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,53 @@
+<h1 align="center">
+    <img align="center" alt="Coding Cards" width="50%" src="https://codingcards.org/static/img/logo/Coding_Cards_Logo_and_Text.svg" />
+</h1>
+
+--------
+
+## What is Coding Cards 
+
+**[Coding Cards](https://codingcards.org)** is a web application for learning C++ features in the style of flashcards.
+It is also possible to use the built-in editor/compiler to test your solution and play around.
+
+It started as a hobby project with a static set of cards, but we got so much positive feedback that we decided to add an option for the community to create new cards.  
+
+
+Website: https://codingcards.org
+
+
+## How to add Cards to the Project
+The project structure:
+
+    .
+    ├── C++11
+    │   ├── card_name-description.md            #Short description (exercise)
+    │   ├── card_name-solution.md               #The solution and a link to the cppreferenz page
+    │   ├── order.txt                           #File with the order of the cards... dont modify this file
+    │   └── ...
+    ├── C++14                   
+    │   ├── card_name-description.md          
+    │   ├── card_name-solution.md         
+    │   ├── order.txt         
+    │   └── ...
+    ├── C++17                   
+    │   ├── card_name-description.md          
+    │   ├── card_name-solution.md         
+    │   ├── oder.txt         
+    │   └── ...             
+    └── ...
+
+To add a new card:
+ 
+  * Choose a C++ version like **C++20** and add 2 files to the subdirectory.
+    * **card_name-description.md** 
+    * **card_name-solution.md**
+  * Required content of card_name-description.md
+    * Headline (# Lambda)
+    * Short and pregnant description/instruction
+  * Required content of card_name-solution.md
+    * Headline (# Solution)
+        * Show the solution as code 
+    * Headline (# Links)
+        * Add a link to cppreference
+ 
+After we accept your pull request we will add the card to the order.txt

c++11/Lambda-description.md

@@ -0,0 +1,8 @@
+# Lambda
+
+### Part 1
+Write the shortest possible lambda
+
+    
+### Part 2
+Use a lambda to calculate the sum of two numbers and return the result

c++11/Lambda-solution.md

@@ -0,0 +1,31 @@
+## Solution part 1
+
+```cpp
+auto lambda = []{};
+```
+
+## Solution part 2
+
+```cpp
+int main (){
+    auto sum = [](auto x, auto y) { return x + y; };
+    sum(2,3);
+}
+```
+
+## Links
+
+- [Cpp Reference](https://de.cppreference.com/w/cpp/language/lambda)
+
+
+## general knowledge
+structure of a lambda
+```cpp
+[captures] (params) {body}
+```
+
+captures:
+ - `[]` captures nothing
+ - `[&]` captures all variables used in the lambda by reference
+ - `[=]` captures all variables used in the lambda by value
+ - `[this]` captures `this` pointer by value

c++11/Lambda_2-description.md

@@ -0,0 +1,3 @@
+# Lambda 2
+
+What does the compiler create out of a lambda (approximately)

c++11/Lambda_2-solution.md

@@ -0,0 +1,33 @@
+## Solution
+
+```cpp
+int main()
+{
+  int a = 5;
+    
+  class __lambda_4_16
+  {
+    public: 
+    inline /*constexpr */ int operator()(int b) const
+    {
+      return a + b;
+    }
+    
+    private: 
+    int & a;
+    
+    public:
+    __lambda_4_16(int & _a)
+    : a{_a}
+    {}
+    
+  };
+  
+  __lambda_4_16 sum = __lambda_4_16{a};
+}
+```
+
+## Links
+
+- [Cpp Reference](https://de.cppreference.com/w/cpp/language/lambda)
+- [cppinsights](https://cppinsights.io/)

c++11/order.txt

@@ -0,0 +1,5 @@
+type_inference_auto
+Lambda
+Lambda_2
+trailing_return_type
+type_inference_auto_decltype

c++11/trailing_return_type-description.md

@@ -0,0 +1,4 @@
+# Trailing return type
+
+Create a method ```add(int a, int b)``` with trailing return type
+ 

c++11/trailing_return_type-solution.md

@@ -0,0 +1,14 @@
+# Trailing return type
+
+```
+auto add(int a, int b) -> int {
+    return a+b;
+}
+
+int main() {
+    return add(2,3);
+}
+```
+
+## Links
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/function) (Second function definition)

c++11/type_inference_auto-description.md

@@ -0,0 +1,12 @@
+# Keyword auto
+
+Iterate over vector ```data``` using the keyword ```auto```
+```
+#include <vector>
+#include <iostream>
+
+int main() {
+    std::vector<int> data(10);
+    return 0;
+}
+```

c++11/type_inference_auto-solution.md

@@ -0,0 +1,56 @@
+
+### C++98
+
+Before C++ 11 we had to use iterators which in some examples could be really
+long and incomprehensible
+```cpp
+    std::vector<int> data(10);
+    for (std::vector<int>::iterator it = data.begin() ; it != data.end(); ++it) {
+        std::cout << ' ' << *it;
+    }
+```
+
+### C++11
+Now with the new keyword ```auto``` we can do:
+
+```cpp
+   std::vector<int> data(10);
+   for(auto it = data.begin(); it != data.end(); it ++) {
+      std::cout << ' ' << *it;
+   }
+```
+
+Or even simpler:
+
+```cpp
+   std::vector<int> data(10);
+   for(auto const& val : data) {
+       std::cout << ' ' << val;
+   }
+```
+
+### All together
+```
+#include <vector>
+#include <iostream>
+
+int main() {
+    std::vector<int> data(10);
+
+    for (std::vector<int>::iterator it = data.begin() ; it != data.end(); ++it) {
+        std::cout << ' ' << *it;
+    }
+    for(auto it = data.begin(); it != data.end(); it ++) {
+        std::cout << ' ' << *it;
+    }
+       
+    for(auto const& val : data) {
+        std::cout << ' ' << val;
+    }
+    return 0;
+}
+
+```
+
+## Links
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/auto)

c++11/type_inference_auto_decltype-description.md

@@ -0,0 +1,4 @@
+# Keyword auto return value
+
+Create a function ```add``` that adds two values of any type and returns the result.
+

c++11/type_inference_auto_decltype-solution.md

@@ -0,0 +1,22 @@
+# Keyword auto return value
+
+```
+template <typename T1, typename T2>
+auto add(T1 t1, T2 t2) -> decltype(t1 + t2) {
+   return t1+t2;
+}
+
+int main() {
+    return add(4,3);
+}
+```
+
+## Links
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/auto)
+
+### Note
+Since C++20, the trailing return "trick" with ```decltype``` is not necessary anymore.
+(Abbreviated function template)
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/function_template#Abbreviated_function_template)
+
+

c++14/Generic_Lambda-description.md

@@ -0,0 +1,4 @@
+# Generic Lambda
+
+Create a generic lambda named ```add``` that adds two values of any type and returns the result.
+

c++14/Generic_Lambda-solution.md

@@ -0,0 +1,16 @@
+# Generic Lambda
+
+```
+#include <iostream>
+#include <string>
+
+int main() {
+   auto add = [](auto x, auto y){return x+y;};
+   std::string str =  add(std::string("3"),std::string("2.3"));
+   float f = add(3,2.3);
+   return 0;
+}
+```
+
+##Links
+-  [isocpp](https://isocpp.org/wiki/faq/cpp14-language#generic-lambdas)

c++14/order.txt

@@ -0,0 +1,2 @@
+Generic_Lambda
+return_type_deduction

c++14/return_type_deduction-description.md

@@ -0,0 +1,4 @@
+# Keyword auto return value
+
+Create a function ```add``` that adds two values of any type and returns the result.
+

c++14/return_type_deduction-solution.md

@@ -0,0 +1,22 @@
+# Keyword auto return value
+
+```
+template <typename T1, typename T2>
+auto add(T1 t1, T2 t2) {
+   return t1+t2;
+}
+
+int main() {
+    return add(4,3);
+}
+```
+
+## Links
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/auto)
+
+### Note
+Since C++20, the trailing return "trick" with ```decltype``` is not necessary anymore.
+(Abbreviated function template)
+- [Cpp Reference](https://en.cppreference.com/w/cpp/language/function_template#Abbreviated_function_template)
+
+

c++17/Chrono-description.md

@@ -0,0 +1,13 @@
+# Chrono
+
+Measure the time in milliseconds this function needs to execute.
+
+```cpp
+int test() {
+  return 0; 
+}
+   
+int main() {
+   test();
+}
+```

c++17/Chrono-solution.md

@@ -0,0 +1,23 @@
+## Solution
+
+```cpp
+#include <chrono>
+
+int test() {
+   return 0; 
+}
+
+
+int main() {
+    auto t1 = std::chrono::system_clock::now();
+    test();
+    auto t2 = std::chrono::system_clock::now();
+    auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count();
+    
+}
+```
+
+## Links
+
+- [Cpp Reference](https://en.cppreference.com/w/cpp/header/chrono)
+- [(youtube) Meeting C++ 2019 Opening Keynote - Howard Hinnant](https://www.youtube.com/watch?v=adSAN282YIwo)

c++17/Chrono_2-description.md

@@ -0,0 +1,16 @@
+# Chrono-2
+
+With the help of chrono, count how many frames the execution of function test took, given a framerate of 60FPS.
+
+```cpp
+int test() {
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    return 0;
+}
+   
+int main() {
+   test();
+
+   return 0;
+}
+```