Урок 9 реализация методов..

kutuzzzov

Jul 19th, 2023

1,349

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

C++ 7.17 KB | None | 0 0

raw download clone embed print report

#pragma once
#include <cassert>
#include <cstdlib>
#include <new>
#include <utility>
#include <memory>
template <typename T>
class RawMemory {
public:
RawMemory() = default;
explicit RawMemory(size_t capacity)
: buffer_(Allocate(capacity))
, capacity_(capacity) {
}
RawMemory(const RawMemory&) = delete;
RawMemory& operator=(const RawMemory& rhs) = delete;
RawMemory(RawMemory&& other) noexcept {
buffer_ = std::move(other.GetAddress());
capacity_ = std::move(other.Capacity());
}
RawMemory& operator=(RawMemory&& rhs) noexcept {
buffer_ = std::move(rhs.GetAddress());
capacity_ = std::move(rhs.Capacity());
//rhs.~RawMemory();
return *this;
}
~RawMemory() {
Deallocate(buffer_);
}
T* operator+(size_t offset) noexcept {
// Разрешается получать адрес ячейки памяти, следующей за последним элементом массива
assert(offset <= capacity_);
return buffer_ + offset;
}
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_);
}
const T* GetAddress() const noexcept {
return buffer_;
}
T* GetAddress() noexcept {
return buffer_;
}
size_t Capacity() const {
return capacity_;
}
private:
// Выделяет сырую память под n элементов и возвращает указатель на неё
static T* Allocate(size_t n) {
return n != 0 ? static_cast<T*>(operator new(n * sizeof(T))) : nullptr;
}
// Освобождает сырую память, выделенную ранее по адресу buf при помощи Allocate
static void Deallocate(T* buf) noexcept {
operator delete(buf);
}
T* buffer_ = nullptr;
size_t capacity_ = 0;
};
template <typename T>
class Vector {
public:
Vector() = default;
explicit Vector(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(), size_, data_.GetAddress());
}
Vector(Vector&& other) noexcept {
Swap(other);
}
Vector& operator=(const Vector& rhs) {
if (this != &rhs) {
if (data_.Capacity() < rhs.size_) {
Vector rhs_copy(rhs);
Swap(rhs_copy);
}
else {
if (rhs.size_ < size_) {
std::copy(rhs.data_.GetAddress(), rhs.data_.GetAddress() + rhs.size_, data_.GetAddress());
std::destroy_n(data_.GetAddress() + rhs.size_, size_ - rhs.size_);
}
else {
std::copy(rhs.data_.GetAddress(), rhs.data_.GetAddress() + size_, data_.GetAddress());
std::uninitialized_copy_n(rhs.data_.GetAddress() + size_, rhs.size_ - size_, data_.GetAddress() + size_);
}
size_ = rhs.size_;
}
}
return *this;
}
Vector& operator=(Vector&& rhs) noexcept {
if (this != &rhs) {
Swap(rhs);
}
return *this;
}
void Swap(Vector& other) noexcept {
data_.Swap(other.data_);
std::swap(size_, other.size_);
}
~Vector() {
std::destroy_n(data_.GetAddress(), size_);
}
size_t Size() const noexcept {
return size_;
}
size_t Capacity() const noexcept {
return data_.Capacity();
}
void Reserve(size_t new_capacity) {
if (new_capacity <= data_.Capacity()) {
return;
}
RawMemory<T> new_data(new_capacity);
// constexpr оператор if будет вычислен во время компиляции
if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
std::uninitialized_move_n(data_.GetAddress(), size_, new_data.GetAddress());
}
else {
std::uninitialized_copy_n(data_.GetAddress(), size_, new_data.GetAddress());
}
std::destroy_n(data_.GetAddress(), size_);
data_.Swap(new_data);
}
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];
}
void Resize(size_t new_size) {
if (new_size < size_) {
std::destroy_n(data_.GetAddress() + new_size, size_ - new_size);
size_ = new_size;
}
else {
Reserve(new_size);
std::uninitialized_value_construct_n(data_.GetAddress() + size_, new_size - size_);
size_ = new_size;
}
}
void PushBack(const T& value) {
if (size_ == Capacity()) {
RawMemory<T> new_data(size_ == 0 ? 1 : size_ * 2);
std::uninitialized_copy_n(&value, 1, new_data.GetAddress() + size_);
if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
std::uninitialized_move_n(data_.GetAddress(), size_, new_data.GetAddress());
}
else {
std::uninitialized_copy_n(data_.GetAddress(), size_, new_data.GetAddress());
}
std::destroy_n(data_.GetAddress(), size_);
data_.Swap(new_data);
}
else {
new (data_ + size_) T(value);
}
++size_;
}
void PushBack(T&& value) {
if (size_ == Capacity()) {
RawMemory<T> new_data(size_ == 0 ? 1 : size_ * 2);
std::uninitialized_move_n(&value, 1, new_data.GetAddress() + size_);
if constexpr (std::is_nothrow_move_constructible_v<T> || !std::is_copy_constructible_v<T>) {
std::uninitialized_move_n(data_.GetAddress(), size_, new_data.GetAddress());
}
else {
std::uninitialized_copy_n(data_.GetAddress(), size_, new_data.GetAddress());
}
std::destroy_n(data_.GetAddress(), size_);
data_.Swap(new_data);
}
else {
new (data_ + size_) T(std::move(value));
}
++size_;
}
void PopBack() noexcept {
if (size_ > 0) {
std::destroy_at(data_.GetAddress() + size_ - 1);
--size_;
}
}
private:
RawMemory<T> data_;
size_t size_ = 0;
};

Add Comment

Please, Sign In to add comment