vector.hpp

#ifndef vector_HPP
#define vector_HPP
#include <new>
#include <cstdlib>

template <typename value_t>
class vector{
private:
    int cap;
    int _size;
    value_t* arr;

    void resize(){
        int n_cap = cap*2;
        // value_t* new_arr = new value_t[n_cap];
        void* raw_mem = std::malloc(n_cap * sizeof(value_t));
        if(!raw_mem){
            throw std::bad_alloc();
        }
        value_t* new_arr = static_cast<value_t*>(raw_mem);

        for(int i=0;i<_size;i++){
            // new_arr[i] = arr[i];
            new (&new_arr[i]) value_t(std::move(arr[i]));   // can throw tho
            arr[i].~value_t();
        }
        std::free(arr);

        // delete[] arr;
        arr = new_arr;
        cap = n_cap;
    }

public:
    vector(){
        cap = 2;
        _size = 0;
        
        // arr = new value_t[cap];
        void* raw_mem = std::malloc(cap * sizeof(value_t));
        if(!raw_mem){
            throw std::bad_alloc();
        }
        arr = static_cast<value_t*>(raw_mem);
    }

    vector(int size){
        cap = size + 2;
        this->_size = size;

        // arr = new value_t[cap];
        void* raw_mem = std::malloc(cap * sizeof(value_t));
        if(!raw_mem){
            throw std::bad_alloc();
        }
        arr = static_cast<value_t*>(raw_mem);

        for(int i=0;i<this->_size;i++){
            new (&arr[i]) value_t();
        }
    }

    vector(const vector& other_vector){
        cap = other_vector.cap;
        this->_size = other_vector._size;

        // arr = new value_t[cap];
        void* raw_mem = std::malloc(cap * sizeof(value_t));
        if(!raw_mem){
            throw std::bad_alloc();
        }
        arr = static_cast<value_t*>(raw_mem);

        for(int i=0;i<this->_size;i++){
            // arr[i] = other_vector.arr[i];
            new (&arr[i]) value_t(other_vector.arr[i]);
        }
    }

    vector(vector&& other_vector) noexcept {
        this->_size = other_vector._size;
        this->arr = other_vector.arr;
        this->cap = other_vector.cap;

        other_vector.arr = nullptr;
        other_vector._size = 0;
        other_vector.cap = 0;
    }

    vector& operator=(const vector& other_vector){
        if(this != &other_vector){
            // delete[] arr;
            for(int i=0;i<this->_size;i++){
                arr[i].~value_t();
            }
            std::free(arr);

            cap = other_vector.cap;
            this->_size = other_vector._size;

            // arr = new value_t[cap];
            void* raw_mem = std::malloc(cap * sizeof(value_t));
            if(!raw_mem){
                throw std::bad_alloc();
            }
            arr = static_cast<value_t*>(raw_mem);

            for(int i=0;i<this->_size;i++){
                // arr[i] = other_vector.arr[i];
                new (&arr[i]) value_t(other_vector.arr[i]);
            }
        }

        return *this;
    }

    vector& operator=(vector&& other_vector) noexcept {
        if(this != &other_vector){
            // delete[] arr;
            for(int i=0;i<this->_size;i++){
                arr[i].~value_t();
            }
            std::free(arr);

            this->_size = other_vector._size;
            this->cap = other_vector.cap;
            this->arr = other_vector.arr;

            other_vector.arr = nullptr;
            other_vector._size = 0;
            other_vector.cap = 0;
        }

        return *this;
    }

    ~vector() {
        // delete[] arr;
        for(int i=0;i<this->_size;i++){
            arr[i].~value_t();
        }
        std::free(arr);
    }

    void push_back(value_t& val){
        if(_size==cap){
            resize();
        }

        new (&arr[_size]) value_t(val);
        _size++;
    }

    void push_back(value_t&& val){
        if(_size==cap){
            resize();
        }

        new (&arr[_size]) value_t(std::move(val));
        _size++;
    }
    
    value_t back(){
        if(_size==0){
            throw std::runtime_error("Tried an empty vector: vector.hpp\n");
        }
        
        value_t back_element = arr[_size-1];
        return back_element;
    }
    
    void pop_back(){
        if(_size==0){
            throw std::runtime_error("Tried to pop an empty vector : vector.hpp\n");
        }

        _size--;
        arr[_size].~value_t();
    }

    const value_t& operator[](int ind) const {
        if(ind<0 || ind>=_size){
            throw std::runtime_error("Out of bounds access: vector.hpp\n");
        }

        return  arr[ind];
    }

    value_t& operator[](int ind) {
        if(ind<0 || ind>=_size){
            throw std::runtime_error("Out of bounds access: vector.hpp\n");
        }

        return  arr[ind];
    }

    void clear(){
        for(int i=0;i<this->_size;i++){
            arr[i].~value_t();
        }
        std::free(arr);
        _size = 0;
        cap = 2;
    }

    int size() const {
        return _size;
    }

    bool empty() const {
        return (_size==0) ? true : false;
    }
};

#endif