final touches

Author: Oguzhan Katli

src/1-Inheritance/diamond_problem.cpp

@@ -159,6 +159,7 @@ namespace diamondproblem {
  } // namespace problem
 } // namespace diamondproblem
 
+// https://gcc.godbolt.org/z/4xaeM5KK8
 ELEMENT_CODE(DiamondProblemExample) {
  using namespace diamondproblem;
  problem::demonstrate();

src/3-Static/static_usage.cpp

@@ -21,6 +21,7 @@ namespace StaticUsage {
  };
 }
 
+// https://gcc.godbolt.org/z/G19zvG6YP
 ELEMENT_CODE(StaticUsageExample) 
 {
  using namespace StaticUsage;

src/5-Templates/template_crtp_usage.cpp

@@ -3,6 +3,37 @@
 
 namespace traits
 {
+
+ namespace base
+ {
+ class Line
+ {
+ public:
+ int draw() const { return 5; }
+ };
+
+ class Circle
+ {
+ public:
+ int draw() const { return 6; }
+ };
+
+ template <typename Shape>
+ void drawShape(const Shape& obj)
+ {
+ obj.draw(); // call draw() according to type of object
+ }
+
+ void usage()
+ {
+ Line l;
+ Circle c, c1, c2;
+
+ drawShape(l); //drawShape<Line>(Shape&) => Line::draw()
+ drawShape(c1); //drawShape<Circle>(Shape&) => Circle::draw()
+ }
+ }
+
  namespace problem {
  // common abstract base class GeoObj for geometric objects
  class GeoObj {

src/5-Templates/template_traits.cpp

@@ -6,30 +6,151 @@ namespace template_traits
  namespace problem
  {
  const unsigned max_chunk = 100;
- // 
+
+ // works for ascii only
  class stream_buffer
  {
  public:
- stream_buffer(const std::string& input) {
- buff = new char[input.size()];
- std::memcpy(buff, input.c_str(), input.size());
+ // ...
+ // return the next character or EOF
+ int sgetc() {
+ return EOF;
  }
+ };
 
- ~stream_buffer()
+ // works when unicode
+ class stream_buffer_unicode
+ {
+ public:
+ // ...
+ // return the next character or EOF
+ wint_t sgetc() {
+ return WEOF;
+ }
+ };
+
+
+ void demonstrate()
+ {
+#if UNICODE
+ stream_buffer_unicode buffer;
+ // get buffer and process
+ wint_t ch;
+ while ((ch = buffer.sgetc()) != WEOF)
  {
- delete buff;
+ // process buffer
+ putwchar(ch);
  }
+#else
+ stream_buffer buffer;
+ // get buffer and process
+ int ch;
+ while ((ch = buffer.sgetc()) != EOF)
+ {
+ // process buffer
+ putchar(ch);
+ }
+#endif
+ }
+
+ } // namespace problem
+
+ namespace solution
+ {
+ template <typename CharT>
+ struct char_traits { };
+ // specialization for ascii chars
+ template <>
+ struct char_traits<char> {
+ using char_type = char;
+ using int_type = int;
+ static inline int_type eof() { return EOF; }
+ };
+ // specialization for unicode chars
+ template <>
+ struct char_traits<wchar_t> {
+ using char_type = wchar_t;
+ using int_type = wint_t;
+ static inline int_type eof() { return WEOF; }
+ };
 
+ // now we can support different char representations by
+ // using trait helpers
+ template <typename CharT>
+ class basic_stream_buffer
+ {
+ public:
+ using traits_type = char_traits<CharT>;
+ using int_type = traits_type::int_type;
  // ...
- int sgetc(); // return the next character or EOF
- int sgetn(char *, int N); // get N characters from buffer
- private:
- char *buff;
+ static int_type eof() { return traits_type::eof(); }
+ // return the next character or EOF
+ int_type sgetc() {
+ return traits_type::eof();
+ }
  };
 
- } // namespace problem
+#if UNICODE
+ using basic_stream = basic_stream_buffer<wchar_t>;
+#else
+ using basic_stream = basic_stream_buffer<char>;
+#endif
+ void demonstrate()
+ {
+ basic_stream buffer;
+ // get buffer and process
+ basic_stream::int_type ch;
+ while ((ch = buffer.sgetc()) != basic_stream::eof())
+ {
+ // process buffer
+ putchar(ch);
+ }
+ }
+ } // namespace solution
+
+ namespace type_traits
+ {
+
+ template <typename Type>
+ struct is_integer {
+ static const bool val = false;
+ };
+
+ template <>
+ struct is_integer<int> {
+ static const bool val = true;
+ };
+
+ template <>
+ struct is_integer<unsigned int> {
+ static const bool val = true;
+ };
+/*
+The simplest solution to compile-time assertions (Van Horn 1997), and one that works in C as well as in
+C++, relies on the fact that a zero-length array is illegal.
+*/
+#define STATIC_CHECK(expr) { char unnamed[(expr) ? 1 : 0]; }
+
+ template <typename T>
+ void will_work_for_only_integer_types(T a, T b)
+ {
+ STATIC_CHECK(is_integer<T>::val);
+ }
+
+#include <type_traits>
+
+ template <typename T, 
+ typename = std::enable_if_t<std::is_integral<T>::value>>
+ T will_work_for_only_integer_types_cpp11(T a, T b)
+ {
+ return a + b;
+ }
+
+
+ } // namespace type_traits
 }
 
-ELEMENT_CODE(TemplateTraits) {
+ELEMENT_CODE(TemplateTraits)
+{
 
 }

src/7-CustomComparators/custom_comparator.cpp

@@ -10,17 +10,17 @@
 #include <set>
 #include <type_traits>
 
-class STMValueComparator {
+class ValueComparator {
 private:
  bool bUseCompEpsl;
  double dEpsl;
 public:
- explicit STMValueComparator(double epsl = 0) : dEpsl(epsl) {
+ explicit ValueComparator(double epsl = 0) : dEpsl(epsl) {
  bUseCompEpsl = dEpsl == 0 ? false : true;
  }
  template <class T,
- typename = typename std::enable_if_t<std::is_floating_point<T>::value>>
-  bool operator()(const T& lhs, const T& rhs) const {
+ typename = typename std::enable_if_t<std::is_floating_point_v<T>>>
+ bool operator()(const T& lhs, const T& rhs) const {
  if (bUseCompEpsl)
  return (std::fabs(lhs - rhs) > static_cast<T>(dEpsl)) &&
  (lhs < rhs);
@@ -114,23 +114,23 @@ ELEMENT_CODE(CustomComparatorNeedExample) {
 ELEMENT_CODE(CustomComparatorExample) {
 
  {
- std::map<float, int, STMValueComparator> mm; // use numeric limit epsilon
+ std::map<float, int, ValueComparator> mm; // use numeric limit epsilon
  mm[1.0] = 1;
  mm[2.0] = 2;
  mm[3.0] = 3;
  auto f = mm.find(1.0);
  }
 
  {
- std::map<float, int, STMValueComparator> mm(STMValueComparator(1.1));
+ std::map<float, int, ValueComparator> mm(ValueComparator(1.1));
  mm[1.0] = 1;
  mm[2.0] = 2;
  mm[3.0] = 3;
  auto f = mm.find(1.0);
  }
 
  {
- std::map<int, int, STMValueComparator> mm(STMValueComparator(0));
+ std::map<int, int, ValueComparator> mm(ValueComparator(0));
  mm[1] = 1;
  mm[2] = 2;
  mm[3] = 3;