New repo setup

include/vector

@@ -0,0 +1,191 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <stdlib.h>
+#include <string.h>
+
+inline void *operator new(size_t, void *p) throw()
+{
+    return p;
+}
+
+inline void *operator new[](size_t, void *p) throw()
+{
+    return p;
+}
+
+inline void operator delete(void *, void *) throw()
+{
+}
+
+inline void operator delete[](void *, void *) throw()
+{
+}
+
+namespace std
+{
+
+    template <typename T>
+    class vector
+    {
+    public:
+        vector();
+        vector(int capacity);
+        vector(const vector<T> &other);
+        ~vector();
+
+        bool empty() const;
+        int size() const;
+        int capacity() const;
+
+        void push_back(const T &data);
+        void pop_back();
+        T &back();
+        T &front();
+        void remove(int index);
+
+        void clear();
+        void resize(int new_capacity);
+
+        T &operator[](int index) const;
+
+    private:
+        T *array;
+        int _capacity;
+        int _size;
+    };
+
+    template <typename T>
+    vector<T>::vector()
+    {
+        _size = 0;
+        _capacity = 8;
+        array = malloc(sizeof(T) * _capacity);
+        memset((void *)array, 0, sizeof(T) * _capacity);
+        // array = new T[_capacity];
+    }
+
+    template <typename T>
+    vector<T>::vector(int capacity)
+    {
+        _size = 0;
+        _capacity = capacity;
+        array = malloc(sizeof(T) * _capacity);
+        memset((void *)array, 0, sizeof(T) * _capacity);
+        // array = new T[_capacity];
+    }
+
+    template <typename T>
+    vector<T>::vector(const vector<T> &other)
+    {
+        _size = other.size();
+        _capacity = other.capacity();
+        array = malloc(sizeof(T) * _capacity);
+        memset((void *)array, 0, sizeof(T) * _capacity);
+        // array = new T[_capacity];
+        for (int i = 0; i < _size; i++)
+            array[i] = other[i];
+    }
+
+    template <typename T>
+    vector<T>::~vector()
+    {
+        for (int i = 0; i < _size; i++)
+        {
+            array[i].~T();
+        }
+        free(array);
+        // if (array != nullptr)
+        //     delete[] array;
+    }
+
+    template <typename T>
+    bool vector<T>::empty() const
+    {
+        return _size == 0;
+    }
+
+    template <typename T>
+    int vector<T>::size() const
+    {
+        return _size;
+    }
+
+    template <typename T>
+    int vector<T>::capacity() const
+    {
+        return _capacity;
+    }
+
+    template <typename T>
+    T &vector<T>::operator[](int index) const
+    {
+        return array[index];
+    }
+
+    template <typename T>
+    void vector<T>::push_back(const T &data)
+    {
+        if (_size == _capacity)
+            resize(_capacity * 2);
+        new (&array[_size]) T(data);
+        // array[_size] = data;
+        _size++;
+    }
+
+    template <typename T>
+    void vector<T>::pop_back()
+    {
+        array[_size - 1].~T();
+        _size--;
+    }
+
+    template <typename T>
+    T &vector<T>::back()
+    {
+        return array[_size - 1];
+    }
+
+    template <typename T>
+    T &vector<T>::front()
+    {
+        return array[0];
+    }
+
+    template <typename T>
+    void vector<T>::remove(int index)
+    {
+        while (index < _size - 1)
+        {
+            array[index] = array[index + 1];
+            index++;
+        }
+        pop_back();
+    }
+
+    template <typename T>
+    void vector<T>::clear()
+    {
+        for (int i = 0; i < _size; i++)
+            array[i].~T();
+        _size = 0;
+    }
+
+    template <typename T>
+    void vector<T>::resize(int new_capacity)
+    {
+        _capacity = new_capacity;
+        // T *temp = new T[_capacity];
+        T *temp = malloc(sizeof(T) * _capacity);
+        memset((void *)temp, 0, sizeof(T) * _capacity);
+        for (int i = 0; i < _size; i++)
+        {
+            new (&temp[i]) T(array[i]);
+            // temp[i] = array[i];
+        }
+        // delete[] array;
+        free(array);
+        array = temp;
+    }
+}
+#endif