[CPP] Rewrite vector<int> to work with primitive and non-primitive data-type

Author: scopeInfinity

src/usr/include/new.h

@@ -6,3 +6,5 @@ void *operator new(std::size_t size);
 void *operator new[](std::size_t size);
 void operator delete(void *ptr);
 void operator delete[](void *ptr);
+
+void *operator new(std::size_t size, void *);

src/usr/include/vector.h

@@ -7,28 +7,34 @@ namespace std {
 template <typename T> class vector {
     std::size_t _capacity, _size;
     T *_data;
-    void resize_capacity(std::size_t capacity);
 
   public:
     typedef T *iterator;
     typedef const T *const_iterator;
 
     vector();
+    vector(std::size_t size);
     vector(std::size_t size, const T &_default);
     vector(const vector<T> &o);
-    vector &operator=(const vector<T> &o);
     ~vector();
 
+    vector &operator=(const vector<T> &o);
+
+    void reserve(std::size_t n);
+    void resize(std::size_t new_size);
+    void resize(std::size_t new_size, const T &_default);
+    void push_back(const T &val);
+    void pop_back();
+
+    void clear();
+
     iterator begin();
     iterator end();
     const_iterator begin() const;
     const_iterator end() const;
 
-    void clear();
     bool empty() const;
     std::size_t size() const;
-    void push_back(const T &val);
-    void pop_back();
 
     T &back();
     T &front();
@@ -39,4 +45,20 @@ template <typename T> class vector {
 
 } // namespace std
 
-#include <vector.tcc>
+template <typename T>
+inline bool operator!=(const std::vector<T> &a, const std::vector<T> b) {
+    if (a.size() != b.size())
+        return true;
+    for (std::size_t i = 0; i < a.size(); i++) {
+        if (a[i] != b[i])
+            return true;
+    }
+    return false;
+}
+
+template <typename T>
+inline bool operator==(const std::vector<T> &a, const std::vector<T> b) {
+    return !(a != b);
+}
+
+#include <vector.tcc>

src/usr/include/vector.tcc

@@ -3,125 +3,161 @@
 // This is internal headerfile to be included by vector.h only
 
 #include <new.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vector.h>
 
 namespace std {
 
-static std::size_t next_power2(std::size_t size) {
-    // assumes no overflow
-    std::size_t p = 1;
-    while (p && p < size)
-        p <<= 1;
-    return p;
-}
+template <typename T>
+vector<T>::vector() : _data(NULL), _capacity(0), _size(0) {}
 
 template <typename T>
-vector<T>::vector() : _data(NULL), _capacity(0), _size(0) {
-    resize_capacity(1);
+vector<T>::vector(std::size_t size) : _data(NULL), _capacity(0), _size(0) {
+    reserve(size);
+    // initializing the members
+    for (std::size_t i = 0; i < size; i++) {
+        new (_data + i) T(); // default constructor
+    }
+    _size = size;
 }
 
 template <typename T>
 vector<T>::vector(std::size_t size, const T &_default)
-    : _data(NULL), _capacity(0), _size(size) {
-    resize_capacity(size);
+    : _data(NULL), _capacity(0), _size(0) {
+    reserve(size);
+    // initializing the members
     for (std::size_t i = 0; i < size; i++) {
-        this->_data[i] = _default;
+        new (_data + i) T(_default); // copy constructor
     }
+    _size = size;
 }
 
 template <typename T>
-vector<T>::vector(const vector<T> &o)
-    : _data(NULL), _capacity(0), _size(o._size) {
-    resize_capacity(o._capacity);
-    std::memcpy(_data, o._data, _capacity * sizeof(T));
+vector<T>::vector(const vector<T> &o) : _data(NULL), _capacity(0), _size(0) {
+    reserve(o._size);
+    // initializing the members
+    for (std::size_t i = 0; i < o._size; i++) {
+        new (_data + i) T(o._data[i]); // copy constructor
+    }
+    _size = o._size;
 }
 
 template <typename T> vector<T> &vector<T>::operator=(const vector<T> &o) {
-    resize_capacity(o._capacity);
-    _size = o._size;
-    std::memcpy(_data, o._data, _capacity * sizeof(T));
+    resize(o._size);
+    // re-initialize the members
+    for (std::size_t i = 0; i < o._size; i++) {
+        _data[i] = o._data[i]; // assignment operator
+    }
     return *this;
 }
 
-template <typename T> vector<T>::~vector() { delete[] _data; }
+template <typename T> vector<T>::~vector() {
+    clear();
+    reserve(0);
+}
 
-template <typename T> typename vector<T>::iterator vector<T>::begin() {
-    return this->_data;
+template <typename T> void vector<T>::reserve(std::size_t new_capacity) {
+    if (new_capacity < _size)
+        new_capacity = _size; // never reserve less than size
+    if (new_capacity == _capacity)
+        return; // resize not needed
+
+    const std::size_t new_capacity_size = (new_capacity) * sizeof(T);
+
+    // make a copy of array and move _data pointer.
+    _data = (T *)std::realloc(_data, new_capacity_size);
+    _capacity = new_capacity;
 }
 
-template <typename T> typename vector<T>::iterator vector<T>::end() {
-    return this->_data + this->_size;
+template <typename T> void vector<T>::resize(const std::size_t new_size) {
+    if (_size < new_size) {
+        reserve(new_size);
+        for (std::size_t i = _size; i < new_size; i++) {
+            new (_data + i) T(); // default constructor
+        }
+        _size = new_size;
+    } else {
+        for (std::size_t i = new_size; i < _size; i++) {
+            _data[i].~T(); // explicit destructor call
+        }
+        _size = new_size;
+        // not reducing the allocated capacity.
+    }
 }
 
 template <typename T>
-typename vector<T>::const_iterator vector<T>::begin() const {
-    return this->_data;
+void vector<T>::resize(const std::size_t new_size, const T &_default) {
+    if (_size < new_size) {
+        reserve(new_size);
+        for (std::size_t i = _size; i < new_size; i++) {
+            new (_data + i) T(_default); // copy constructor
+        }
+        _size = new_size;
+    } else {
+        for (std::size_t i = new_size; i < _size; i++) {
+            _data[i].~T(); // explicit destructor call
+        }
+        _size = new_size;
+        // not reducing the allocated capacity.
+    }
 }
 
-template <typename T>
-typename vector<T>::const_iterator vector<T>::end() const {
-    return this->_data + this->_size;
+template <typename T> void vector<T>::push_back(const T &val) {
+    if (_size == _capacity) {
+        reserve(max(1, _capacity * 2));
+    }
+    new (_data + (_size++)) T(val); // copy constructor
 }
 
-template <typename T> void vector<T>::resize_capacity(std::size_t capacity) {
-    // internal; assumes capacity to be power of 2
-    // and will also make a copy of array and move _data pointer.
-    // assumes size<=current_capacity and size<=new_capacity
-    const std::size_t data_size =
-        std::min(capacity, this->_capacity) * sizeof(T);
-    T *_new_data = new T[capacity];
-    if (!_new_data)
-        return; // malloc failed
-    std::memcpy(_new_data, this->_data, data_size);
+template <typename T> void vector<T>::pop_back() {
+    if (!(_size > 0)) {
+        return;
+    }
 
-    delete[] this->_data; // should be no-op if _data == NULL
-    this->_data = _new_data;
-    this->_capacity = capacity;
-}
+    _size--;
+    _data[_size].~T(); // explicit destructor call
 
-template <typename T> void vector<T>::clear() {
-    // not reducing capacity for now
-    this->_size = 0;
+    // not reducing the allocated capacity.
 }
 
-template <typename T> bool vector<T>::empty() const { return this->_size == 0; }
+template <typename T> void vector<T>::clear() { resize(0); }
 
-template <typename T> std::size_t vector<T>::size() const {
-    return this->_size;
+template <typename T> typename vector<T>::iterator vector<T>::begin() {
+    return _data;
 }
 
-template <typename T> void vector<T>::push_back(const T &val) {
-    if (this->_size == this->_capacity) {
-        resize_capacity(this->_capacity * 2);
-    }
-    this->_data[this->_size++] = val;
+template <typename T> typename vector<T>::iterator vector<T>::end() {
+    return _data + _size;
 }
 
-template <typename T> void vector<T>::pop_back() {
-    // not reducing the capacity for now
-    if (this->_size > 0) {
-        this->_size--;
-    }
+template <typename T>
+typename vector<T>::const_iterator vector<T>::begin() const {
+    return _data;
 }
 
-template <typename T> T &vector<T>::back() {
-    return this->_data[this->_size - 1];
+template <typename T>
+typename vector<T>::const_iterator vector<T>::end() const {
+    return _data + _size;
 }
 
-template <typename T> T &vector<T>::front() { return this->_data[0]; }
+template <typename T> bool vector<T>::empty() const { return _size == 0; }
 
-template <typename T> T &vector<T>::at(std::size_t pos) {
-    return this->_data[pos];
-}
+template <typename T> std::size_t vector<T>::size() const { return _size; }
+
+template <typename T> T &vector<T>::back() { return _data[_size - 1]; }
+
+template <typename T> T &vector<T>::front() { return _data[0]; }
+
+template <typename T> T &vector<T>::at(std::size_t pos) { return _data[pos]; }
 
 template <typename T> T &vector<T>::operator[](std::size_t pos) {
-    return this->_data[pos];
+    return _data[pos];
 }
 
 template <typename T> const T &vector<T>::operator[](std::size_t pos) const {
-    return this->_data[pos];
+    return _data[pos];
 }
 
-} // namespace std
+} // namespace std

src/usr/lib/new.cpp

@@ -8,4 +8,6 @@ void *operator new[](std::size_t size) { return ::operator new(size); }
 
 void operator delete(void *ptr) { std::free(ptr); }
 
-void operator delete[](void *ptr) { ::operator delete(ptr); }
+void operator delete[](void *ptr) { ::operator delete(ptr); }
+
+void *operator new(std::size_t s, void *ptr) { return ptr; }