vector.hpp

Go to the documentation of this file.

#ifndef VECTOR_HPP
#define VECTOR_HPP
#include <stdexcept>
#include "vector"
template <typename T>
class Vector {
 
    unsigned int _size = 50;
    int nElements = 0;
    T* data = new T[_size]{};
 
 
public:
    template<typename>
    friend class Stack;
    ~Vector() { delete[] data; }
 
    Vector()=default;
 
    [[nodiscard]] unsigned int size() const { return nElements; }
 
    void push_back(const T& value) {
       if (nElements >= _size) {
           _size *= 2;
           T* newData = new T[_size]{};
           for (unsigned int i = 0; i < nElements; ++i)
               newData[i] = data[i];
           delete[] data;
           data = newData;
       }
       data[nElements++] = value;
    }
    T pop_back() {
        if (nElements == 0) {
            throw std::out_of_range("pop_back on empty Vector");
        }
        --nElements;
        T value = data[nElements];
 
        // Shrink when underutilized, keep minimum capacity of 50
        if (nElements > 0 && static_cast<unsigned int>(nElements) <= _size / 4 && _size > 50) {
            _size = 50u > _size ? 50u : _size;
            T* newData = new T[_size]{};
            for (unsigned int i = 0; i < nElements; ++i)
                newData[i] = data[i];
            delete[] data;
            data = newData;
        }
        return value;
    }
    T* begin() { return data; }
    T* end()   { return data + _size; }
 
    T& operator[](unsigned int index) { return data[index]; }
 
    const T& operator[](unsigned int index) const { return data[index]; }
    template <typename>
    friend class ScapeGoatTree;
 
    Vector(const Vector& other) {
        nElements = other.nElements;
        _size = other._size;
        data = new T[_size];
        for (int i = 0; i < nElements; i++) {
            data[i] = other.data[i];
        }
    }
 
    // Copy assignment operator
    Vector& operator=(const Vector& other) {
        if (this == &other) return *this; // self-assignment check
 
        delete[] data; // free old memory
 
        nElements = other.nElements;
        _size = other._size;
        data = new T[_size];
        for (int i = 0; i < nElements; i++) {
            data[i] = other.data[i];
        }
        return *this;
    }
    // Move constructor
    Vector(Vector&& other) noexcept {
        data = other.data;
        nElements = other.nElements;
        _size = other._size;
 
        other.data = nullptr;
        other.nElements = 0;
        other._size = 0;
    }
    Vector& operator=(Vector&& other) noexcept {
        if (this != &other) {
            delete[] data;        // free old memory
 
            data = other.data;
            nElements = other.nElements;
            _size = other._size;
 
            other.data = nullptr;
            other.nElements = 0;
            other._size = 0;
        }
        return *this;
    }
 
};
#endif