vector.hpp

Go to the documentation of this file.

#ifndef __LIBK__VECTOR_HPP_
#define __LIBK__VECTOR_HPP_
 
#include <memory/kalloc.h>
#include <type.h>
#include <vector.h>
#include <str.h>
 
// vector untuk c++
template <typename T> class Vector {
      public:
    Vector() : data_(nullptr), size_(0), capacity_(0) {
        reserve(VECTOR_MINIMUM_ITEM);
    }
 
    ~Vector() {
        destroy();
    }
 
    // Nonaktifkan copy untuk menghindari double-free
    Vector(const Vector&) = delete;
    Vector& operator=(const Vector&) = delete;

    Vector(Vector&& other) noexcept
        : data_(other.data_), size_(other.size_),
          capacity_(other.capacity_) {
        other.data_ = nullptr;
        other.size_ = 0;
        other.capacity_ = 0;
    }

    Vector& operator=(Vector&& other) noexcept {
        if (this != &other) {
            destroy();
            data_ = other.data_;
            size_ = other.size_;
            capacity_ = other.capacity_;
            other.data_ = nullptr;
            other.size_ = 0;
            other.capacity_ = 0;
        }
        return *this;
    }

    T& operator[](size_t index) {
        return data_[index];
    }

    const T& operator[](size_t index) const {
        return data_[index];
    }

    T& front() {
        return data_[0];
    }

    T& back() {
        return data_[size_ - 1];
    }

    T* data() {
        return data_;
    }

    const T* data() const {
        return data_;
    }

    size_t size() const {
        return size_;
    }

    size_t capacity() const {
        return capacity_;
    }

    bool empty() const {
        return size_ == 0;
    }

    void push_back(const T& val) {
        if (size_ >= capacity_)
            expand_capacity();
        data_[size_++] = val;
    }

    void push_back(T&& val) {
        if (size_ >= capacity_)
            expand_capacity();
        data_[size_++] = static_cast<T&&>(val);
    }

    T* pop_back() {
        if (size_ == 0)
            return nullptr;
        return &data_[--size_];
    }

    void clear() {
        size_ = 0;
    }

    void reserve(size_t new_cap) {
        if (new_cap <= capacity_)
            return;
 
        T* new_data = static_cast<T*>(kalloc(new_cap * sizeof(T)));
 
        if (data_) {
            memcopy(new_data, data_, capacity_ * sizeof(T));
            kfree(data_, capacity_ * sizeof(T));
        }
 
        data_ = new_data;
        capacity_ = new_cap;
    }
 
    T* begin() {
        return data_;
    }
    T* end() {
        return data_ + size_;
    }
 
    const T* begin() const {
        return data_;
    }
    const T* end() const {
        return data_ + size_;
    }
 
      private:
    T* data_;
    size_t size_;
    size_t capacity_;

    void expand_capacity() {
        size_t new_cap = capacity_ ? capacity_ * 2 : 4;
        reserve(new_cap);
    }

    void destroy() {
        if (data_) {
            kfree(data_, capacity_ * sizeof(T));
            data_ = nullptr;
            size_ = 0;
            capacity_ = 0;
        }
    }
};
 
#endif // __LIBK__VECTOR_HPP_