init check

Author: Henry Wu

basics/addspace.hpp

@@ -0,0 +1,17 @@
+template<typename T>
+class AddSpace
+{
+  private:
+    T const& ref;                  // refer to argument passed in constructor
+  public:
+    AddSpace(T const& r): ref(r) {
+    }
+    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
+      return os << s.ref << ' ';   // output passed argument and a space
+    }
+};
+
+template<typename... Args>
+void print (Args... args) {
+  ( std::cout << ... << AddSpace(args) ) << '\n';
+}

basics/addvalue.hpp

@@ -0,0 +1,5 @@
+template<int Val, typename T>
+T addValue (T x)
+{
+  return x + Val;
+}

basics/arrays.cpp

@@ -0,0 +1,30 @@
+#include "arrays.hpp"
+
+template<typename T1, typename T2, typename T3>
+void foo(int a1[7], int a2[],    // pointers by language rules
+         int (&a3)[42],          // reference to array of known bound
+         int (&x0)[],            // reference to array of unknown bound
+         T1 x1,                  // passing by value decays
+         T2& x2, T3&& x3)        // passing by reference
+{
+  MyClass<decltype(a1)>::print();     // uses MyClass<T*>
+  MyClass<decltype(a2)>::print();     // uses MyClass<T*>
+  MyClass<decltype(a3)>::print();     // uses MyClass<T(\&)[SZ]>
+  MyClass<decltype(x0)>::print();     // uses MyClass<T(\&)[]>
+  MyClass<decltype(x1)>::print();     // uses MyClass<T*>
+  MyClass<decltype(x2)>::print();     // uses MyClass<T(\&)[]>
+  MyClass<decltype(x3)>::print();     // uses MyClass<T(\&)[]>
+}
+
+int main()
+{
+  int a[42];
+  MyClass<decltype(a)>::print();      // uses MyClass<T[SZ]>
+
+  extern int x[];                     // forward declare array
+  MyClass<decltype(x)>::print();      // uses MyClass<T[]>
+
+  foo(a, a, a, x, x, x, x);
+}
+
+int x[] = {0, 8, 15};                 // define forward-declared array

basics/arrays.hpp

@@ -0,0 +1,34 @@
+#include <iostream>
+
+template<typename T>
+struct MyClass;             // primary template
+
+template<typename T, std::size_t SZ>
+struct MyClass<T[SZ]>       // partial specialization for arrays of known bounds
+{
+  static void print() { std::cout << "print() for T[" << SZ << "]\n"; }
+};
+
+template<typename T, std::size_t SZ>
+struct MyClass<T(&)[SZ]>    // partial spec. for references to arrays of known bounds
+{
+  static void print() { std::cout << "print() for T(&)[" << SZ << "]\n"; }
+};
+
+template<typename T>
+struct MyClass<T[]>         // partial specialization for arrays of unknown bounds
+{
+  static void print() { std::cout << "print() for T[]\n"; }
+};
+
+template<typename T>
+struct MyClass<T(&)[]>      // partial spec. for references to arrays of unknown bounds
+{
+  static void print() { std::cout << "print() for T(&)[]\n"; }
+};
+
+template<typename T>
+struct MyClass<T*>          // partial specialization for pointers
+{
+  static void print() { std::cout << "print() for T*\n"; }
+};

basics/boolstring.hpp

@@ -0,0 +1,12 @@
+class BoolString {
+  private:
+    std::string value;
+  public:
+    BoolString (std::string const& s)
+     : value(s) {
+    }
+    template<typename T = std::string>
+    T get() const {         // get value (converted to T)
+      return value;
+    }
+};

basics/boolstringgetbool.hpp

@@ -0,0 +1,5 @@
+// full specialization for BoolString::getValue<>() for bool
+template<>
+inline bool BoolString::get<bool>() const {
+  return value == "true" || value == "1" || value == "on";
+}

basics/byref.hpp

@@ -0,0 +1,5 @@
+template<typename T>
+T const& checked (T const& a, T const& b)
+{
+    return  test() ? a : b;
+}

basics/byvalue.hpp

@@ -0,0 +1,5 @@
+template<typename T>
+T checked (T a, T b)
+{
+    return  test() ? a : b;
+}

basics/cref.cpp

@@ -0,0 +1,21 @@
+#include <functional>  // for std::cref()
+#include <string>
+#include <iostream>
+
+void printString(std::string const& s)
+{
+  std::cout << s << '\n';
+}
+
+template<typename T>
+void printT (T arg)
+{
+  printString(arg);        // might convert arg back to std::string
+}
+
+int main()
+{
+  std::string s = "hello";
+  printT(s);               // print s passed by value
+  printT(std::cref(s));    // print s passed ``as if by reference''
+}

basics/errornovel1.cpp

@@ -0,0 +1,14 @@
+#include <string>
+#include <map>
+#include <algorithm>
+
+int main()
+{
+  std::map<std::string,double> coll;                  
+  //...
+  // find the first nonempty string in coll:
+  auto pos = std::find_if (coll.begin(), coll.end(),
+                           [] (std::string const& s) { 
+                             return s != "";
+                           });
+}

basics/errornovel2.cpp

@@ -0,0 +1,30 @@
+#include <string>
+#include <unordered_set>
+
+class Customer
+{
+  private:
+    std::string name;
+  public:
+    Customer (std::string const& n)
+     : name(n) {
+    }
+    std::string getName() const {
+      return name;
+    }
+};
+
+int main()
+{
+  // provide our own hash function:
+  struct MyCustomerHash {
+    // NOTE: missing const is only an error with g++ and clang:
+    std::size_t operator() (Customer const& c) {
+      return std::hash<std::string>()(c.getName());
+    }
+  };
+
+  // and use it for a hash table of Customers:
+  std::unordered_set<Customer,MyCustomerHash> coll;
+  //...
+}

basics/foldtraverse.cpp

@@ -0,0 +1,29 @@
+// define binary tree structure and traverse helpers:
+struct Node {
+  int value;
+  Node* left;
+  Node* right;
+  Node(int i=0) : value(i), left(nullptr), right(nullptr) {
+  }
+  //...
+};
+auto left = &Node::left;
+auto right = &Node::right;
+
+// traverse tree, using fold expression:
+template<typename T, typename... TP>
+Node* traverse (T np, TP... paths) {
+  return (np ->* ... ->* paths);      // np ->* paths1 ->* paths2 ...
+}
+
+int main()
+{
+  // init binary tree structure:
+  Node* root = new Node{0};
+  root->left = new Node{1};
+  root->left->right = new Node{2};
+  //...
+  // traverse binary tree:
+  Node* node = traverse(root, left, right);
+  //...
+}

basics/foreach.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <vector>
+#include "foreach.hpp"
+
+// a function to call:
+void func(int i)
+{
+  std::cout << "func() called for: " << i << '\n';
+}
+
+// a function object type (for objects that can be used as functions):
+class FuncObj {
+  public:
+    void operator() (int i) const {  // Note: const member function
+      std::cout << "FuncObj::op() called for: " << i << '\n';
+    }
+};
+
+int main()
+{
+  std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
+
+  foreach(primes.begin(), primes.end(),  // range
+          func);                         // function as callable (decays to pointer)
+
+  foreach(primes.begin(), primes.end(),  // range
+          &func);                        // function pointer as callable
+
+  foreach(primes.begin(), primes.end(),  // range
+          FuncObj());                    // function object as callable
+
+  foreach(primes.begin(), primes.end(),  // range
+          [] (int i) {                   // lambda as callable
+            std::cout << "lambda called for: " << i << '\n';
+          });
+}

basics/foreach.hpp

@@ -0,0 +1,8 @@
+template<typename Iter, typename Callable>
+void foreach (Iter current, Iter end, Callable op)
+{
+  while (current != end) {  // as long as not reached the end
+    op(*current);           //  call passed operator for current element
+    ++current;              //  and move iterator to next element
+  }
+}

basics/foreachinvoke.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include "foreachinvoke.hpp"
+
+// a class with a member function that shall be called
+class MyClass {
+  public:
+    void memfunc(int i) const {
+      std::cout << "MyClass::memfunc() called for: " << i << '\n';
+    }
+};
+
+int main()
+{
+  std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
+
+  // pass lambda as callable and an additional argument:
+  foreach(primes.begin(), primes.end(),          // elements for 2nd arg of lambda
+          [](std::string const& prefix, int i) { // lambda to call
+            std::cout << prefix << i << '\n';
+          },
+          "- value: ");                          // 1st arg of lambda
+    
+  // call obj.memfunc() for/with each elements in primes passed as argument
+  MyClass obj;
+  foreach(primes.begin(), primes.end(),  // elements used as args
+          &MyClass::memfunc,             // member function to call
+          obj);                          // object to call memfunc() for
+}

basics/foreachinvoke.hpp

@@ -0,0 +1,13 @@
+#include <utility>
+#include <functional>
+
+template<typename Iter, typename Callable, typename... Args>
+void foreach (Iter current, Iter end, Callable op, Args const&... args)
+{
+  while (current != end) {     // as long as not reached the end of the elements
+    std::invoke(op,            // call passed callable with
+                args...,       // any additional args
+                *current);     // and the current element
+    ++current;
+  }
+}

basics/invoke.hpp

@@ -0,0 +1,9 @@
+#include <utility>     // for std::invoke()
+#include <functional>  // for std::forward()
+
+template<typename Callable, typename... Args>
+decltype(auto) call(Callable&& op, Args&&... args)
+{
+  return std::invoke(std::forward<Callable>(op),    // passed callable with
+                     std::forward<Args>(args)...);  // any additional args
+}

basics/invokeret.hpp

@@ -0,0 +1,23 @@
+#include <utility>     // for std::invoke()
+#include <functional>  // for std::forward()
+#include <type_traits> // for std::is_same<> and invoke_result<>
+
+template<typename Callable, typename... Args>
+decltype(auto) call(Callable&& op, Args&&... args)
+{
+  if constexpr(std::is_same_v<std::invoke_result_t<Callable, Args...>,
+                              void>) {
+    // return type is void:
+    std::invoke(std::forward<Callable>(op),
+                std::forward<Args>(args)...);
+    //...
+    return;
+  }
+  else {
+    // return type is not void:
+    decltype(auto) ret{std::invoke(std::forward<Callable>(op),
+                                   std::forward<Args>(args)...)};
+    //...
+    return ret;
+  }
+}

basics/isprime.hpp

@@ -0,0 +1,25 @@
+template<unsigned p, unsigned d>   // p: number to check, d: current divisor
+struct DoIsPrime {
+  static constexpr bool value = (p%d != 0) && DoIsPrime<p,d-1>::value; 
+}; 
+
+template<unsigned p>               // end recursion if divisor is 2
+struct DoIsPrime<p,2> {
+  static constexpr bool value = (p%2 != 0);
+}; 
+
+template<unsigned p>               // primary template
+struct IsPrime {
+  // start recursion with divisor from  p/2:
+  static constexpr bool value = DoIsPrime<p,p/2>::value;
+}; 
+
+// special cases (to avoid endless recursion with template instantiation):
+template<>
+struct IsPrime<0> { static constexpr bool value = false; }; 
+template<>
+struct IsPrime<1> { static constexpr bool value = false; }; 
+template<>
+struct IsPrime<2> { static constexpr bool value = true; }; 
+template<>
+struct IsPrime<3> { static constexpr bool value = true; }; 

basics/isprime11.hpp

@@ -0,0 +1,12 @@
+constexpr bool
+doIsPrime (unsigned p, unsigned d)  // p: number to check, d: current divisor
+{
+  return d!=2 ? (p%d!=0) && doIsPrime(p,d-1) // check this and smaller divisors
+              : (p%2!=0);                    // end recursion if divisor is 2
+}
+
+constexpr bool isPrime (unsigned p)
+{
+  return p < 4 ? !(p<2)             // handle special cases
+               : doIsPrime(p,p/2);  // start recursion with divisor from p/2
+}

basics/isprime14.hpp

@@ -0,0 +1,9 @@
+constexpr bool isPrime (unsigned int p)
+{
+  for (unsigned int d=2; d<=p/2; ++d) {
+    if (p % d == 0) {
+      return false;  // found divisor without remainder
+    }
+  }
+  return p > 1;      // no divisor without remainder found
+}