collections/vector: implement dynamic table described in CLRS

.gitignore

@@ -1 +1,2 @@
 /bazel-*
+.idea

src/collections/vector.h

@@ -4,20 +4,28 @@
 #include <algorithm>
 #include <optional>
 
-template <typename T>
-class Vec {
-  public:
+template <typename T> class Vec {
+public:
   Vec();
   virtual ~Vec();
 
-  private:
-  T* buf;
+private:
+  T *buf;
   size_t len;
+  size_t _capacity;
+  void reallocate();
 
-  public:
+public:
   // Get the length of the vector
   size_t size();
 
+  // Get the size of underneath array
+  size_t capacity();
+
+  // Set the size of underneath array to at least len + additional
+  // Do nothing if capacity already greater than len + additional
+  void reserve(size_t additional);
+
   // Examine if the vector is empty.
   bool is_empty();
 
@@ -31,57 +39,62 @@ class Vec {
   T operator[](size_t index);
 };
 
-template <typename T>
-inline Vec<T>::Vec()
-{
+template <typename T> inline Vec<T>::Vec() {
   this->buf = nullptr;
   len = 0;
+  _capacity = 0;
 }
 
-template <typename T>
-inline size_t Vec<T>::size()
-{
-  return this->len;
+template <typename T> void Vec<T>::reallocate() {
+  T *new_buf = new T[this->_capacity];
+  std::copy(this->buf, this->buf + this->len, new_buf);
+  delete[] buf;
+  buf = new_buf;
 }
 
-template <typename T>
-inline Vec<T>::~Vec()
-{
-  if (this->len == 0)
-    delete[] this->buf;
+template <typename T> inline size_t Vec<T>::size() { return this->len; }
+
+template <typename T> inline size_t Vec<T>::capacity() {
+  return this->_capacity;
 }
 
-template <typename T>
-inline bool Vec<T>::is_empty()
-{
-  return this->len == 0;
+template <typename T> void Vec<T>::reserve(size_t additional) {
+  size_t new_capacity = this->len + additional;
+  if (this->_capacity < new_capacity) {
+    this->_capacity = new_capacity;
+    reallocate();
+  }
 }
 
-template <typename T>
-void Vec<T>::push(T data)
-{
-  T* new_buf = new T[this->len + 1];
-  std::copy(this->buf, this->buf + this->len, new_buf);
-  new_buf[this->len] = data;
+template <typename T> inline Vec<T>::~Vec() {
+  if (this->len == 0)
+    delete[] this->buf;
+}
 
-  delete[] this->buf;
+template <typename T> inline bool Vec<T>::is_empty() { return this->len == 0; }
 
-  this->buf = new_buf;
-  this->len++;
+template <typename T> void Vec<T>::push(T data) {
+  size_t total = this->len + 1;
+  if (total > this->_capacity) {
+    size_t new_capacity = total * 3 / 2 + 1;
+    this->_capacity = new_capacity;
+    reallocate();
+  }
+  buf[this->len++] = data;
 }
 
-template <typename T>
-std::optional<T> Vec<T>::pop()
-{
-  if (this->len > 0)
+template <typename T> std::optional<T> Vec<T>::pop() {
+  if (this->len > 0) {
+    if ((this->_capacity / this->len) > 2) {
+      reserve((this->len - 1) / 2);
+    }
     return this->buf[this->len-- - 1];
+  }
 
   return {};
 }
 
-template <typename T>
-T Vec<T>::operator[](size_t idx)
-{
+template <typename T> T Vec<T>::operator[](size_t idx) {
   if (idx < this->len)
     return this->buf[idx];
   else

tests/test-vector.cc

@@ -43,3 +43,22 @@ TEST(TestVec, TestPop)
   EXPECT_EQ(233, vec.pop().value());
   EXPECT_EQ(std::nullopt, vec.pop());
 }
+
+TEST(TestVec, TestCapacity)
+{
+  Vec<int> vec;
+  EXPECT_EQ(0, vec.capacity());
+  vec.push(123);
+  EXPECT_EQ(1 * 3/2 +1, vec.capacity());
+
+}
+
+TEST(TestVec, TestReserve)
+{
+  Vec<int> vec;
+  vec.push(1);
+  vec.push(11);
+  int additional = 5;
+  vec.reserve(additional);
+  EXPECT_GE(vec.capacity(), vec.size() + additional);
+}