vector.h

#pragma once
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdlib>
//#include <iterator>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>

template<typename T>
class RawMemory{
public:
    RawMemory() = default;
    explicit RawMemory(size_t size) : buffer_(Allocate(size)), capacity_(size){}
    RawMemory(const RawMemory&) = delete;
    RawMemory& operator=(const RawMemory&) = delete;
    RawMemory(RawMemory&& other) noexcept{
        Swap(other);
    }
    RawMemory& operator=(RawMemory&& other)noexcept{
        if (this == &other) {
            return *this;
        }
        Swap(other);
        return *this;
    }
    ~RawMemory(){
        Deallocate(buffer_);
    }

    T* operator+(size_t offset)noexcept{
        assert(offset <= capacity_);
        return buffer_ + offset;
    }
    const T* GetAddress() const noexcept {
        return buffer_;
    }
    const T* operator+(size_t offset) const noexcept {
        return const_cast<RawMemory&>(*this) + offset;
    }

    const T& operator[](size_t index) const noexcept {
        return const_cast<RawMemory&>(*this)[index];
    }

    T& operator[](size_t index) noexcept {
        assert(index < capacity_);
        return buffer_[index];
    }

    void Swap(RawMemory& other) noexcept {
        std::swap(buffer_, other.buffer_);
        std::swap(capacity_, other.capacity_);
    }

    T* GetAddress() noexcept {
        return buffer_;
    }

    size_t Capacity() const {
        return capacity_;
    }
    

private:
    T* Allocate(size_t size){
        return size > 0 ? static_cast<T*>(operator new(size * sizeof(T))) : nullptr;
    }
    void Deallocate(T* buffer) noexcept{
        operator delete(buffer);
    }
    T* buffer_ = nullptr;
    size_t capacity_ = 0;
};


template <typename T>
class Vector {
public:
    using iterator = T*;
    using const_iterator = const T*;
    Vector() = default;
    explicit Vector(const size_t size) : data_(size), size_(size){
        std::uninitialized_value_construct_n(data_.GetAddress(), size_);
    }
    Vector(const Vector& other) : data_(other.size_), size_(other.size_){
        std::uninitialized_copy_n(other.data_.GetAddress(), other.size_, data_.GetAddress());
    }
    Vector& VectorInitialization(const Vector& other){
        size_t common = std::min(other.size_, size_);
        std::copy_n(other.data_.GetAddress(), common, data_.GetAddress());
        if(other.size_ <= size_){
            std::destroy_n(data_.GetAddress() + other.size_, size_ - other.size_);
        }else {
            std::uninitialized_copy_n(other.data_.GetAddress() + size_, other.size_ - size_, data_.GetAddress() + size_);
        }
        size_ = other.size_;
        return *this;
    }
    Vector& operator=(const Vector& other){
        if(this == &other){
            return *this;
        }
        if(other.size_ > data_.Capacity()){
            Vector<T> new_vec(other);
            Swap(new_vec);
            return *this;
        }else{
            return VectorInitialization(other);
        }
    }
    Vector(Vector&& other) noexcept{
        data_ = std::move(other.data_);
        size_ = std::exchange(other.size_, 0);
    }
    Vector& operator=(Vector&& other) noexcept{
        if(this == &other){
            return *this;
        }
        data_.Swap(other.data_);
        size_ = std::exchange(other.size_, 0);//если убрать на платформе тесты упадут, своп размер не свопнет
        return *this;
    }
    ~Vector(){
        std::destroy_n(data_.GetAddress(), size_);
    }
    void PushBack(const T& value){
        EmplaceBack(value);
    }
    void PushBack(T&& value) {
        EmplaceBack(std::move(value));
    }
    void PopBack()noexcept{
        assert(size_ != 0);
        std::destroy_n(data_.GetAddress() + size_ - 1, 1);
        --size_;
    }
    template <typename... Args>
    T& EmplaceBack(Args&&... args){
        if(size_ == data_.Capacity()){
            size_t new_capacity = size_ == 0 ? 1 : size_ * 2;
            RawMemory<T> new_buffer(new_capacity);
            new(new_buffer.GetAddress() + size_) T(std::forward<Args>(args)...);
            if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
                std::uninitialized_move_n(data_.GetAddress(), size_, new_buffer.GetAddress());
            }else{
                try {
                    std::uninitialized_copy_n(data_.GetAddress(), size_, new_buffer.GetAddress());
                } catch (...) {
                    std::destroy_at(new_buffer.GetAddress() + size_);
                }
                
            }
            std::destroy_n(data_.GetAddress(), size_);
            data_.Swap(new_buffer);
        }else{
            new(data_.GetAddress() + size_) T(std::forward<Args>(args)...);
        }
        ++size_;
        return data_[size_ - 1];
    }
    void Resize(size_t new_size){
        if(new_size > data_.Capacity()){
            Reserve(new_size);
            std::uninitialized_value_construct_n(data_.GetAddress() + size_, new_size - size_);
            size_ = new_size;
            return;
        }
        if(new_size > size_ && new_size <= data_.Capacity()){
            std::uninitialized_value_construct_n(data_.GetAddress() + size_, new_size - size_);
        }else if(new_size < size_){
            std::destroy_n(data_.GetAddress() + new_size, size_ - new_size);;
        }
        size_ = new_size;
    }
    void Reserve(size_t capacity){
        if(capacity <= data_.Capacity()){
            return;
        }
        RawMemory<T> new_buffer(capacity);
        if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
            std::uninitialized_move_n(data_.GetAddress(), size_, new_buffer.GetAddress());
        }else{
            std::uninitialized_copy_n(data_.GetAddress(), size_, new_buffer.GetAddress());
        }
        std::destroy_n(data_.GetAddress(), size_);
        data_.Swap(new_buffer);
    }
    void Swap(Vector& other) noexcept{
        if(this == &other){
            return;
        }
        data_.Swap(other.data_);
        std::swap(size_, other.size_);
    }
    size_t Size() const noexcept {
        return size_;
    }

    size_t Capacity() const noexcept {
        return data_.Capacity();
    }

    const T& operator[](size_t index) const noexcept {
        return const_cast<Vector&>(*this)[index];
    }

    T& operator[](size_t index) noexcept {
        assert(index < size_);
        return data_[index];
    }

    iterator begin() noexcept{
        return &data_.GetAddress()[0];
    }
    iterator end() noexcept{
        return &data_.GetAddress()[size_];
    }
    const_iterator begin() const noexcept{
        return &data_.GetAddress()[0];
    }
    const_iterator end() const noexcept{
        return &data_.GetAddress()[size_];
    }
    const_iterator cbegin() const noexcept{
        return &data_.GetAddress()[0];
    }
    const_iterator cend() const noexcept{
        return &data_.GetAddress()[size_];
    }

    template <typename... Args>
    iterator Emplace(const_iterator pos, Args&&... args) {
        size_t pos_index = pos - begin();
        assert(pos_index <= size_);
        if (size_ == data_.Capacity()) {
            RawMemory<T> new_buffer(size_ == 0 ? 1 : size_ * 2);
            new(new_buffer.GetAddress() + pos_index) T(std::forward<Args>(args)...);
            try {
                if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
                    std::uninitialized_move_n(data_.GetAddress(), pos_index, new_buffer.GetAddress());
                } else {
                    std::uninitialized_copy_n(data_.GetAddress(), pos_index, new_buffer.GetAddress());
                }
            } catch (...) {
                std::destroy_at(new_buffer.GetAddress() + pos_index);
                throw;
            }

            try {
                if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
                    std::uninitialized_move_n(data_.GetAddress() + pos_index, size_ - pos_index, new_buffer.GetAddress() + pos_index + 1);
                } else {
                    std::uninitialized_copy_n(data_.GetAddress() + pos_index, size_ - pos_index, new_buffer.GetAddress() + pos_index + 1);
                }
            } catch (...) {
                std::destroy_n(new_buffer.GetAddress(), pos_index + 1);
                throw;
            }

            std::destroy_n(data_.GetAddress(), size_);
            data_.Swap(new_buffer);
        } else {
            if (pos == end()) {
                new(data_.GetAddress() + size_) T(std::forward<Args>(args)...);
            } else {
                T temp(std::forward<Args>(args)...);
                new(data_.GetAddress() + size_) T(std::move(data_[size_ - 1]));
                try {
                    std::move_backward(begin() + pos_index, end() - 1, end());
                } catch(...) {
                    std::destroy_at(data_.GetAddress() + size_);
                    throw;
                }
                data_[pos_index] = std::move(temp);
            }
        }
        ++size_;
        return begin() + pos_index;
    }
    iterator Erase(const_iterator pos){
        size_t pos_index = pos - begin();
        assert(pos_index < size_);
        iterator mutable_iter = begin() + pos_index;
        if(size_ == 1){
            std::destroy_n(data_.GetAddress(), size_);
        }else{
            std::move(mutable_iter + 1, end(), data_.GetAddress() + pos_index);
            std::destroy_n(data_.GetAddress() + size_ - 1, 1);
        }
        --size_;
        return begin() + pos_index;
    }
    iterator Insert(const_iterator pos, const T& value){
        return Emplace(pos, value);
    }
    iterator Insert(const_iterator pos, T&& value){
        return Emplace(pos, std::move(value));
    }

private:
    RawMemory<T> data_;
    size_t size_ = 0;
};