array_ptr.h

#pragma once

#include <numeric>
#include <iostream>
#include <cassert>

template <typename Type>
class ArrayPtr{
public:
    ArrayPtr() = default;

    explicit ArrayPtr(size_t size){
        if(size == 0){
            raw_ptr_ = nullptr;
            return;
        }
        try{
            raw_ptr_ = new Type[size]();
        }
        catch(...){
            raw_ptr_ = nullptr;
            throw;
        }
    }
    ArrayPtr(ArrayPtr &&other) noexcept
        : raw_ptr_(other.Release()){}

    explicit ArrayPtr(Type *raw_ptr) noexcept{
        raw_ptr_ = raw_ptr;
    }

    ArrayPtr(const ArrayPtr &) = delete;

    ~ArrayPtr(){
        delete[] raw_ptr_;
    }

    ArrayPtr &operator=(const ArrayPtr &rhs) = delete;

    ArrayPtr &operator=(ArrayPtr &&rhs)noexcept{
        if(raw_ptr_ != nullptr){
            delete[] raw_ptr_;
        }
        raw_ptr_ = std::exchange(rhs.raw_ptr_, nullptr);
        return *this;
    }

    [[nodiscard]] Type *Release() noexcept{
        Type *t = raw_ptr_;
        raw_ptr_ = nullptr;
        return t;
    }

    Type &operator[](size_t index) noexcept{
        return raw_ptr_[index];
    }

    const Type &operator[](size_t index) const noexcept{
        return raw_ptr_[index];
    }

    explicit operator bool() const{
        return raw_ptr_ != nullptr;
    }

    Type *Get() const noexcept{
        return raw_ptr_;
    }

    void swap(ArrayPtr &other) noexcept{
        // Реализуйте метод самостоятельно
        std::swap(raw_ptr_, other.raw_ptr_);
    }

private:
    Type *raw_ptr_ = nullptr;
    size_t size_;
};