Updating index

Author: kernhanda

Presentations/back_to_basics_smart_pointers/SourceFiles/cyclicReference.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <memory>
+
+struct Son;
+struct Daughter;
+
+struct Mother{
+  ~Mother() {
+    std::cout << "Mother gone" << std::endl;
+  }
+  void setSon(const std::shared_ptr<Son> s) {
+    mySon = s;
+  }
+  void setDaughter(const std::shared_ptr<Daughter> d) {
+    myDaughter = d;
+  }
+  std::shared_ptr<const Son> mySon;
+  std::weak_ptr<const Daughter> myDaughter;
+};
+
+struct Son {
+  Son(std::shared_ptr<Mother> m) : myMother(m) {}
+  ~Son() {
+    std::cout << "Son gone" << std::endl;
+  }
+  std::shared_ptr<const Mother> myMother;
+};
+
+struct Daughter {
+  Daughter(std::shared_ptr<Mother> m) : myMother(m) {}
+  ~Daughter() {
+    std::cout << "Daughter gone" << std::endl;
+  }
+  std::shared_ptr<const Mother> myMother;
+};
+
+int main() {
+  std::cout << std::endl;
+  {
+    std::shared_ptr<Mother> mother= std::shared_ptr<Mother>(new Mother);
+    std::shared_ptr<Son> son= std::shared_ptr<Son>(new Son(mother));
+    std::shared_ptr<Daughter> daughter= std::shared_ptr<Daughter>(new Daughter(mother));
+    mother->setSon(son);
+    mother->setDaughter(daughter);
+  }
+  std::cout << std::endl;
+}

Presentations/back_to_basics_smart_pointers/SourceFiles/raii.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <new>
+#include <string>
+
+class ResourceGuard {
+  private:
+    const std::string resource;
+  public:
+    ResourceGuard(const std::string& res):resource(res) {
+      std::cout << "Acquire the " << resource << "." <<  std::endl;
+    }
+    ~ResourceGuard() {
+      std::cout << "Release the "<< resource << "." << std::endl;
+    }
+};
+
+int main() {
+
+  std::cout << std::endl;
+
+  ResourceGuard resGuard1{"memoryBlock1"};
+
+  std::cout << "\nBefore local scope" << std::endl;
+  {
+    ResourceGuard resGuard2{"memoryBlock2"};
+  }
+  std::cout << "After local scope" << std::endl;
+  
+  std::cout << std::endl;
+
+  
+  std::cout << "\nBefore try-catch block" << std::endl;
+  try {
+      ResourceGuard resGuard3{"memoryBlock3"};
+      throw std::bad_alloc();
+  }   
+  catch (std::bad_alloc& e) {
+      std::cout << e.what();
+  }
+  std::cout << "\nAfter try-catch block" << std::endl;
+  
+  std::cout << std::endl;
+
+}

Presentations/back_to_basics_smart_pointers/SourceFiles/sharedPtr.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <memory>
+
+class MyInt {
+public:
+  MyInt(int v) : val(v) {
+   std::cout << "  Hello: " << val << std::endl;
+  }
+  ~MyInt() {
+   std::cout << "  Good Bye: " << val << std::endl;
+  }
+private:
+  int val;
+};
+
+int main() {
+
+  std::cout << std::endl;
+
+  std::shared_ptr<MyInt> sharPtr(new MyInt(1998));
+  
+  std::cout << "sharedPtr.use_count(): " << sharPtr.use_count() << std::endl;
+  {
+    std::shared_ptr<MyInt> locSharPtr(sharPtr);
+    std::cout << "locSharPtr.use_count(): " << locSharPtr.use_count() << std::endl;
+  }
+  std::cout << "sharPtr.use_count(): "<<  sharPtr.use_count() << std::endl;
+
+  std::shared_ptr<MyInt> globSharPtr = sharPtr;
+  std::cout << "sharPtr.use_count(): "<<  sharPtr.use_count() << std::endl;
+  
+  globSharPtr.reset();
+  std::cout << "sharPtr.use_count(): "<<  sharPtr.use_count() << std::endl;
+
+  sharPtr = std::shared_ptr<MyInt>(new MyInt(2011));
+
+  std::cout << std::endl;
+
+}

Presentations/back_to_basics_smart_pointers/SourceFiles/sharedPtrDeleter.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <memory>
+#include <random>
+#include <string>
+#include <typeinfo>
+
+template <typename T>
+class Deleter {
+public:
+  void operator()(T *ptr) {
+    ++Deleter::count;
+    delete ptr;
+  }
+  void getInfo() {
+    std::string typeId{typeid(T).name()};
+    size_t sz= Deleter::count * sizeof(T);
+    std::cout << "Deleted " << Deleter::count << " objects of type: " << typeId << std::endl;
+    std::cout <<"Freed size in bytes: "  << sz << "." <<  std::endl;
+    std::cout << std::endl;
+
+  }
+private:
+  static int count;
+};
+
+template <typename T>
+int Deleter<T>::count = 0;
+
+typedef Deleter<int> IntDeleter;
+
+void createRandomNumbers() {
+
+  std::random_device seed;
+
+  // generator
+  std::mt19937 engine(seed());
+
+  // distribution
+  std::uniform_int_distribution<int> thousand(1, 1000);
+  int ranNumber= thousand(engine);
+  for ( int i=0 ; i <= ranNumber; ++i) std::shared_ptr<int>(new int(i), IntDeleter());
+
+}
+
+int main() {
+
+  std::cout << std::endl;
+
+  // define a local scope
+  {
+    std::shared_ptr<int> sharedPtr1(new int, IntDeleter());
+    std::shared_ptr<int> sharedPtr2(new int, IntDeleter());
+    auto intDeleter= std::get_deleter<IntDeleter>(sharedPtr1);
+    intDeleter->getInfo();
+    sharedPtr2.reset();
+    intDeleter->getInfo();
+
+  }
+  // create up to 1000 std::shared_ptr of type int
+  createRandomNumbers();
+  IntDeleter().getInfo();
+
+}
+

Presentations/back_to_basics_smart_pointers/SourceFiles/threadSharesOwnershipSharedPtr.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <memory>
+#include <thread>
+
+using namespace std::literals::chrono_literals;
+
+struct MyInt {
+  int val{2017};
+  ~MyInt() {
+    std::cout << "Good Bye" << std::endl;
+  }
+};
+
+void showNumber(std::shared_ptr<MyInt> myInt) {    
+    std::cout << myInt->val << std::endl;
+}
+
+void threadCreator() {
+    auto sharedPtr = std::make_shared<MyInt>();    
+    
+    std::thread t1(showNumber, sharedPtr);
+    std::thread t2(showNumber, sharedPtr);
+    
+    t1.detach();
+    t2.detach();
+}
+
+int main() {
+    
+    std::cout << std::endl;
+    
+    threadCreator();
+    std::this_thread::sleep_for(1s);
+    
+    std::cout << std::endl;
+    
+}

Presentations/back_to_basics_smart_pointers/SourceFiles/uniquePtr.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <memory>
+#include <utility>
+
+struct MyInt {
+  MyInt(int i) : i_(i) {}
+  ~MyInt() {
+    std::cout << "Good bye from " << i_ << std::endl;
+  }
+  int i_;
+};
+
+
+int main() {
+
+  std::cout << std::endl;
+
+  MyInt* myInt15 = new MyInt(15);
+  std::unique_ptr<MyInt> uniquePtr1(myInt15);
+  std::unique_ptr<MyInt> uniquePtr15(myInt15);
+
+  std::cout << "uniquePtr1.get(): " << uniquePtr1.get() << std::endl;
+
+  std::unique_ptr<MyInt> uniquePtr2{std::move(uniquePtr1)};
+  std::cout << "uniquePtr1.get(): " << uniquePtr1.get() << std::endl;
+  std::cout << "uniquePtr2.get(): " << uniquePtr2.get() << std::endl;
+
+  std::cout << std::endl;
+
+
+  {
+    std::unique_ptr<MyInt> localPtr{new MyInt(2003)};
+  }
+
+  std::cout << std::endl;
+
+  uniquePtr2.reset(new MyInt(2011));
+  MyInt* myInt= uniquePtr2.release();
+  delete myInt;
+
+  std::cout << std::endl;
+
+}

Presentations/back_to_basics_smart_pointers/SourceFiles/weakPtr.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <memory>
+
+int main() {
+
+  std::cout << std::boolalpha << std::endl;
+
+  auto sharedPtr = std::make_shared<int>(2011);
+  std::weak_ptr<int> weakPtr(sharedPtr);
+  
+  std::cout << "weakPtr.use_count(): " << weakPtr.use_count() << std::endl;
+  std::cout << "sharedPtr.use_count(): " << sharedPtr.use_count() << std::endl;
+  std::cout << "weakPtr.expired(): " << weakPtr.expired() << std::endl;
+
+  if( std::shared_ptr<int> sharedPtr1 = weakPtr.lock() ) {
+    std::cout << "*sharedPtr: " << *sharedPtr << std::endl;
+  }
+  else {
+    std::cout << "Don't get the resource!" << std::endl;
+  }
+
+  weakPtr.reset();
+  if( std::shared_ptr<int> sharedPtr1 = weakPtr.lock() ) {
+    std::cout << "*sharedPtr: " << *sharedPtr << std::endl;
+  }
+  else {
+    std::cout << "Don't get the resource!" << std::endl;
+  }
+
+  std::cout << std::endl;
+
+}

Presentations/justintime_compilation_the_next_big_thing/.presentation

@@ -1 +1 @@
-{"Title": "Just-in-Time Compilation The Next Big Thing", "Author": "Ben Deane Kris Jusiak"}
+{"Title": "Just-in-Time Compilation The Next Big Thing", "Author": "Ben Deane & Kris Jusiak"}

Presentations/justintime_compilation_the_next_big_thing/README.md

@@ -0,0 +1,7 @@
+**Just-in-Time Compilation The Next Big Thing?** by **Ben Deane & Kris Jusiak**
+
+Additional links:
+
+https://quantlabfinancial.github.io/talks/cppcon-2020/just-in-time_compilation_the-next-big-thing
+https://wg21.link/p1609
+https://github.com/hfinkel/llvm-project-cxxjit

Presentations/macrofree_testing_with_cpp20/README.md

@@ -0,0 +1,7 @@
+**Macro-free testing with C++20** by **Kris Jusiak**
+
+Additional links:
+
+https://boost-ext.github.io/ut/cppcon-2020/
+https://github.com/boost-ext/ut
+https://godbolt.org/z/81b3K7

README.md

@@ -19,7 +19,7 @@ and code from [CppCon 2020](http://cppcon.org).
  - [Back to Basics Concurrency](Presentations/back_to_basics_concurrency/back_to_basics_concurrency__arthur_odwyer__cppcon_2020.pdf) by Arthur O'Dwyer
  - [Back To Basics Lambda Expressions](Presentations/back_to_basics_lambda_expressions/back_to_basics_lambda_expressions__barbara_geller__ansel_sermersheim__cppcon_2020.pdf) by Barbara Geller & Ansel Sermersheim
  - [Back to Basics Move Semantics](Presentations/back_to_basics_move_semantics/back_to_basics_move_semantics__david_olsen__cppcon_2020.pdf) by David Olsen
- - [Back to Basics - Smart Pointers](Presentations/back_to_basics_smart_pointers/back_to_basics_smart_pointers__rainer_grimm__cppcon_2020.pdf) by Rainer Grimm
+ - [Back to Basics - Smart Pointers](Presentations/back_to_basics_smart_pointers/back_to_basics_smart_pointers__rainer_grimm__cppcon_2020.pdf) by Rainer Grimm \[[more materials](Presentations/back_to_basics_smart_pointers)\]
  - [Back to Basics - The Abstract Machine](Presentations/back_to_basics_the_abstract_machine/back_to_basics_the_abstract_machine__bob_steagall__cppcon_2020.pdf) by Bob Steagall
  - [Back to Basics - The Structure of a Program](Presentations/back_to_basics_the_structure_of_a_program/back_to_basics_the_structure_of_a_program__bob_steagall__cppcon_2020.pdf) by Bob Steagall
  - [Breaking Dependencies - The SOLID Principles](Presentations/breaking_dependencies_the_solid_principles/breaking_dependencies_the_solid_principles__klaus_iglberger__cppcon_2020.pdf) by Klaus Iglberger