Added template metaprogramming example to vector

Grzegorz Jabłoński
1 parent cac6c667
Showing 2 changed files with 64 additions and 63 deletions
examples11/06-template_metaprogramming/testvector.cpp
examples11/06-template_metaprogramming/vector.h
@@ -2,35 +2,26 @@
 using namespace std;
 #include "vector.h"
  
-template<class C> void printvector (vector<C>  v)
-{
-  cout << v << endl;
-}
-
-int
-main ()
-{
-  vector<int> a (10);
-  cout << a << endl;
-  a[0] = 15;
-  a[5] = 32;
-  vector<int> b(10);
-  a.push_back(4);
-  a.push_back(5);
-  a.push_back(6);
-  a.push_back(7);
-  a.push_back(8);
-  a.push_back(9);
-  a.push_back(10);
-  cout << a.push_back(11) << endl;
-  auto x = a.push_back(12,13,14);
-  cout << get<0>(x) << endl;
-  cout << get<0>(get<1>(x)) << endl;
-  cout << get<0>(get<1>(get<1>(x))) << endl;
+template <class C> void printvector(vector<C> v) { cout << v << endl; }
  
-  int arg = 15;
+int main() {
+  vector<string> a(0);
+  vector<string> b(0);
+  a.push_back("1");
+  a.push_back("2");
+  a.push_back("3");
+  a.push_back("4");
+  a.push_back("5");
+  a.push_back("6");
+  a.push_back("7");
+  a.reserve(11); // to avoid reallocation and reference invalidation
+  auto [x, y, z] = a.push_back("8", "9", "10");
+  printvector(a);
+  x = "108";
+  y = "109";
+  z = "110";
+  string arg = "11";
   a.push_back(arg);
-  b=a;
-  printvector (b);
-
+  b = a;
+  printvector(b);
 }
@@ -2,8 +2,8 @@
 #define __VECTOR_H__
 #include <cstring>
 #include <limits>
-#include <type_traits>
 #include <tuple>
+#include <type_traits>
  
 template <class C> class vector {
   C *data;
@@ -25,33 +25,37 @@ private:
     free(ptr);
   }
  
+  void reserve_internal(unsigned capacity) {
+    unsigned int newcap = capacity;
+    C *newdata;
+    if constexpr (!std::is_trivially_copyable<C>()) {
+      newdata =
+          static_cast<C *>(std::aligned_alloc(alignof(C), newcap * sizeof(C)));
+      if (!newdata)
+        throw bad_alloc();
+      unsigned i;
+      try {
+        for (i = 0; i < size; i++)
+          new (newdata + i) C(std::move(data[i]));
+      } catch (...) {
+        destroy_array(newdata, i);
+        throw;
+      }
+      destroy_array(data, size);
+    } else {
+      newdata = static_cast<C *>(std::realloc(data, newcap * sizeof(C)));
+      if (!newdata)
+        throw bad_alloc();
+    }
+    data = newdata;
+    cap = newcap;
+  }
+
   void resize_before_push() {
     if (size >= cap) {
       if (cap > std::numeric_limits<decltype(size)>::max() / (2 * sizeof(C)))
         throw bad_alloc();
-      unsigned int newcap = (cap == 0) ? 1 : 2 * cap;
-      C *newdata;
-      if constexpr (!std::is_trivially_copyable<C>()) {
-        newdata = static_cast<C *>(
-            std::aligned_alloc(alignof(C), newcap * sizeof(C)));
-        if (!newdata)
-          throw bad_alloc();
-        unsigned i;
-        try {
-          for (i = 0; i < size; i++)
-            new (newdata + i) C(std::move(data[i]));
-        } catch (...) {
-          destroy_array(newdata, i);
-          throw;
-        }
-        destroy_array(data, size);
-      } else {
-        newdata = static_cast<C *>(std::realloc(data, newcap * sizeof(C)));
-        if (!newdata)
-          throw bad_alloc();
-      }
-      data = newdata;
-      cap = newcap;
+      reserve_internal((cap == 0) ? 1 : 2 * cap);
     }
   }
  
@@ -150,20 +154,26 @@ private:
   }
  
 public:
-
-  C& push_back(C&& s)
-  {
-    return push_back_single(std::forward<C>(s));
+  void reserve(unsigned capacity) {
+    if (capacity > std::numeric_limits<decltype(size)>::max() / (2 * sizeof(C)))
+      throw bad_alloc();
+    unsigned int cap_rounded_up = round_up_to_power_of_2(capacity);
+    reserve_internal(cap_rounded_up);
   }
  
-  std::tuple<> push_back()
-  {
-    return std::tuple<>{};
+  std::tuple<C &> push_back(C &&s) {
+    C &r = push_back_single(std::forward<C>(s));
+    return std::tuple<C &>(r);
   }
  
-  template <class T, class... Args> auto push_back(T&& a, Args &&... args) {
-    return std::tuple(push_back(std::forward<C>(a)),push_back(args...));
-  }
+private:
+  std::tuple<> push_back() { return std::tuple<>(); }
  
+public:
+  template <class T, class... Args> auto push_back(T &&a, Args &&... args) {
+    auto op1 = push_back(std::forward<C>(a));
+    auto op2 = push_back(args...);
+    return std::tuple_cat(op1, op2);
+  }
 };
 #endif /* __VECTOR_H__ */