update Vector

Author: bitdove

data-structures/Array/__test__/test_Array.cpp

@@ -42,15 +42,126 @@ void test_array(){
     std::cout << arr_5[i] << " ";
   }
   std::cout << std::endl;
-  std::cout << "All tests passed!" << std::endl;
+  std::cout << "Array All tests passed!" << std::endl;
   std::cout << "*****Array Test End*****" << std::endl;
 }
 
 void test_vector(){
   std::cout << "*****Vector Test Begin*****" << std::endl;
-
-
-
+  Vector<int> vec_0(5);
+  assert(vec_0.empty() == false);
+  assert(vec_0.size() == 5);
+  assert(vec_0.capacity() == 5);
+  assert(vec_0[3] == 0);
+  Vector<int> vec_1(3, 77);
+  assert(vec_1.empty() == false);
+  assert(vec_1.size() == 3);
+  assert(vec_1.capacity() == 3);
+  assert(vec_1[1] == 77);
+  Vector<int> vec;
+  assert(vec.empty() == true);
+  assert(vec.size() == 0);
+  assert(vec.capacity() == 0);
+  try{
+    vec.front();
+  } catch(const std::underflow_error &e){
+    std::cout << "Vector::front() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  try{
+    vec.back();
+  } catch(const std::underflow_error &e){
+    std::cout << "Vector::back() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  try{
+    vec.pop_back();
+  } catch(const std::underflow_error &e){
+    std::cout << "Vector::pop_back() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  try{
+    vec.at(0);
+  } catch(const std::out_of_range &e){
+    std::cout << "Vector::at() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  try{
+    vec.insert(1, 99);
+  } catch(const std::out_of_range &e){
+    std::cout << "Vector::insert() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  try{
+    vec.erase(0);
+  } catch(const std::out_of_range &e){
+    std::cout << "Vector::erase() throw an exception PASSED: " << e.what() << std::endl;
+  }
+  vec.push_back(12); // 12
+  assert(vec.empty() == false);
+  assert(vec.size() == 1);
+  assert(vec.capacity() == 1);
+  assert(vec[0] == 12);
+  assert(vec.front() == 12);
+  assert(vec.back() == 12);
+  assert(vec.at(0) == 12);
+  vec.resize(1); // do nothing
+  vec.push_back(21); // 12 21
+  assert(vec.empty() == false);
+  assert(vec.size() == 2);
+  assert(vec.capacity() == 2);
+  assert(vec[1] == 21);
+  assert(vec.front() == 12);
+  assert(vec.back() == 21);
+  assert(vec.at(0) == 12);
+  vec.push_back(34); // 12 21 34
+  assert(vec.empty() == false);
+  assert(vec.size() == 3);
+  assert(vec.capacity() == 4);
+  assert(vec[1] == 21);
+  assert(vec.front() == 12);
+  assert(vec.back() == 34);
+  assert(vec.at(2) == 34);
+  vec.shrink_to_fit(); // 12 21 34
+  assert(vec.empty() == false);
+  assert(vec.size() == 3);
+  assert(vec.capacity() == 3);
+  assert(vec[0] == 12);
+  assert(vec.front() == 12);
+  assert(vec.back() == 34);
+  assert(vec.at(1) == 21);
+  vec.insert(1, 46); // 12 46 21 34
+  assert(vec.empty() == false);
+  assert(vec.size() == 4);
+  assert(vec.capacity() == 6);
+  assert(vec[1] == 46);
+  assert(vec.front() == 12);
+  assert(vec.back() == 34);
+  assert(vec.at(2) == 21);
+  vec.reserve(8); // 12 46 21 34
+  assert(vec.empty() == false);
+  assert(vec.size() == 4);
+  assert(vec.capacity() == 8);
+  assert(vec[1] == 46);
+  assert(vec.front() == 12);
+  assert(vec.back() == 34);
+  assert(vec.at(2) == 21);
+  vec.erase(2); // 12 46 34
+  assert(vec.empty() == false);
+  assert(vec.size() == 3);
+  assert(vec.capacity() == 8);
+  assert(vec[1] == 46);
+  assert(vec.front() == 12);
+  assert(vec.back() == 34);
+  assert(vec.at(1) == 46);
+  vec.pop_back(); // 12 46
+  assert(vec.empty() == false);
+  assert(vec.size() == 2);
+  assert(vec.capacity() == 8);
+  assert(vec[1] == 46);
+  assert(vec.front() == 12);
+  assert(vec.back() == 46);
+  assert(vec.at(0) == 12);
+  vec.clear(); // null
+  assert(vec.empty() == true);
+  assert(vec.size() == 0);
+  assert(vec.capacity() == 8);
+  std::cout << " Vector ALL TEST PASSED!" << std::endl;
   std::cout << "*****Vector Test End*****" << std::endl;
 }
 

data-structures/Array/include/Vector.h

@@ -16,20 +16,22 @@ class Vector{
     bool empty() const {return _start == _finish;}
     size_t size() const {return static_cast<size_t>(_finish - _start);};
     size_t capacity() const {return static_cast<size_t>(_end_of_storage - _start);};
+    void reserve (const size_t n);
     void shrink_to_fit();
     // Element access
     T& front();
     T& back();
     T& at(const size_t index);
     T& operator[](const size_t index);
     // Modifiers
-    void clear();
-    void resize(const size_t count);
-    void insert(const size_t index);
-    void erase(const size_t index);
     void push_back(const T &value);
     void pop_back();
+    void insert(const size_t index, const T& value);
+    void resize(const size_t count);
+    void erase(const size_t index);
+    void clear();
   private:
+    bool _full() const {return _end_of_storage == _finish;}
     void _reallocate(const size_t new_capacity);
   private:
     T *_start;
@@ -39,61 +41,58 @@ class Vector{
 
 //Constructor and Destructor
 template <typename T>
-Vector<T>::Vector(){
-  _start = nullptr;
-  _finish = nullptr;
-  _end_of_storage = nullptr;
-}
+Vector<T>::Vector() : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}
 
 template <typename T>
-Vector<T>::Vector(size_t N){
+Vector<T>::Vector(size_t N) : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr){
   if(N > 0){
-    _start = new T[N];
-    _finish = _start;
-    _end_of_storage = _start + N;
-  }
-  else{
-    _start = nullptr;
-    _finish = nullptr;
-    _end_of_storage = nullptr;
+    _start = static_cast<T*>(::operator new[](N * sizeof(T)));
+    _finish = _start + N;
+    _end_of_storage = _finish;
+    for(T* p = _start; p != _finish; ++p){
+      new(p) T();
+    }
   }
 }
 
 template <typename T>
-Vector<T>::Vector(size_t N, const T &value){
+Vector<T>::Vector(size_t N, const T &value) : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr){
   if(N > 0){
-    _start = new T[N];
+    _start = static_cast<T*>(::operator new[](N * sizeof(T)));
     _finish = _start + N;
     _end_of_storage = _finish;
-    for(size_t i = 0; i < N; ++i){
-      _start[i] = value;
+    for(T* p = _start; p != _finish; ++p){
+      new(p) T(value);
     }
   }
-  else{
-    _start = nullptr;
-    _finish = nullptr;
-    _end_of_storage = nullptr;
-  }
 }
 
 template <typename T>
 Vector<T>::~Vector(){
-  delete[] _start;
+  if(_start){
+    for(T* p = _start; p != _finish; ++p){
+      p->~T();
+    }
+    ::operator delete[](_start);
+  }
   _start = nullptr;
   _finish = nullptr;
   _end_of_storage = nullptr;
 }
 
+template <typename T>
+void Vector<T>::reserve(const size_t n){
+  if(n > capacity()){
+    _reallocate(n);
+  }
+}
+
 template <typename T>
 void Vector<T>::shrink_to_fit(){
   if(_finish == _end_of_storage){
     return;
   }
-  while(_end_of_storage != _finish){
-    T* del = _end_of_storage - 1;
-    delete del;
-    --_end_of_storage;
-  }
+  _reallocate(size());
 }
 
 // Elements access
@@ -126,4 +125,99 @@ T& Vector<T>::operator[](const size_t index){
   return _start[index];
 }
 
+//Modifier
+template <typename T>
+void Vector<T>::push_back(const T &value){
+  if(_full() == true){
+    size_t new_capacity = size() > 0 ? 2 * size() : 1;
+    _reallocate(new_capacity);
+  }
+  *_finish = value;
+  ++_finish;
+}
+
+template <typename T>
+void Vector<T>::pop_back(){
+  if(empty()){
+    throw std::underflow_error("pop_back(): This Vector is empty.");
+  }
+  --_finish;
+  _finish->~T();
+}
+
+template <typename T>
+void Vector<T>::insert(const size_t index, const T& value){
+  if(index > size()){
+    throw std::out_of_range("insert(): Index out of range.");
+  }
+  if(_full()){
+    size_t new_capacity = size() > 0 ? 2 * size() : 1;
+    _reallocate(new_capacity);
+  }
+  for(T* p = _finish; p != _start + index; --p){
+    new(p) T(*(p-1));
+    (p - 1)->~T();
+  }
+  new(_start+index) T(value);
+  ++_finish;
+}
+
+template <typename T>
+void Vector<T>::resize(const size_t count){
+  if(size() == count){
+    return;
+  }
+  else if(size() > count){
+    for(T* p = _start + count; p != _finish; ++p){
+      p->~T();
+    }
+    _finish = _start + count;
+  }
+  else{
+    if(count > capacity()){
+      _reallocate(count);
+    }
+    for(T* p = _finish; p != _start + count; ++p){
+      new(p) T();
+    }
+    _finish = _start + count;
+  }
+}
+
+template <typename T>
+void Vector<T>::erase(const size_t index){
+  if(index >= size()){
+    throw std::out_of_range("erase(): Index out of range.");
+  }
+  (_start + index)->~T();
+  for(T* p = _start + index + 1; p != _finish; ++p){
+    new(p-1) T(*(p));
+    p->~T();
+  }
+  --_finish;
+}
+
+template <typename T>
+void Vector<T>::clear(){
+  for(T* p = _start; p != _finish; ++p){
+    p->~T();
+  }
+  _finish = _start;
+}
+
+// Privare Functions
+template <typename T>
+void Vector<T>::_reallocate(const size_t new_capacity){
+  T *del = _start;
+  T *new_start = static_cast<T*>(::operator new[](new_capacity * sizeof(T)));
+  for(size_t i = 0; i < size(); ++i){
+    new(new_start + i) T(_start[i]);
+    _start[i].~T();
+  }
+  _finish = new_start + size();
+  _start = new_start;
+  _end_of_storage = new_start + new_capacity;
+  ::operator delete[](del);
+}
+
 #endif // VECTOR_H