Спринт 14. Упрощаем работу с сырой памятью.

-----------------------------------------------------------------------
vector.h
-----------------------------------------------------------------------
#pragma once
#include <cassert>
#include <cstdlib>
#include <new>
#include <utility>

template <typename T>
class RawMemory {
public:
    RawMemory() = default;

    explicit RawMemory(size_t capacity) : buffer_(Allocate(capacity))
                                        , capacity_(capacity) {}

    ~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:
    T* buffer_ = nullptr;
    size_t capacity_ = 0;

    static T* Allocate(size_t n) {return n != 0 ? static_cast<T*>(operator new(n * sizeof(T))) : nullptr;}
    static void Deallocate(T* buf) noexcept {operator delete(buf);}
};

template <typename T>
class Vector {
public:

    Vector() = default;

    explicit Vector(size_t size) : data_(size)
                                 , capacity_(size)
                                 , size_(size) {
        size_t i = 0;
        try {

            for (; i != size; ++i) {
                new (data_ + i) T();
            }

        } catch (...) {
            DestroyN(data_.GetAddress(), i);
            throw;
        }
    }

    ~Vector() {DestroyN(data_.GetAddress(), size_);}

    Vector(const Vector& other) : data_(other.size_)
                                , capacity_(other.size_)
                                , size_(other.size_) {

        RawMemory<T> buffer(other.size_);
        size_t i = 0;
        try {
            for (; i != other.size_; ++i) {
                CopyConstruct(data_ + i, other.data_[i]);
            }

        } catch (...) {
            DestroyN(data_.GetAddress(), i);
            throw;
        }
    }

    size_t Size() const noexcept {return size_;}
    size_t Capacity() const noexcept {return capacity_;}

    void Reserve(size_t new_capacity) {

        if (new_capacity <= capacity_) {
            return;
        }

        RawMemory<T> new_data(new_capacity);
        size_t i = 0;
        try {

            for (; i != size_; ++i) {
                CopyConstruct(new_data + i, data_[i]);
            }

            data_.Swap(new_data);
            DestroyN(new_data.GetAddress(), size_);
            capacity_ = new_capacity;

        } catch (...) {
            DestroyN(new_data.GetAddress(), i);
            throw;
        }
    }

    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];}

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

    static void CopyConstruct(T* buf, const T& elem) {new (buf) T(elem);}
    static void Destroy(T* buf) noexcept {buf->~T();}

    static void DestroyN(T* buf, size_t n) noexcept {

        for (size_t i = 0; i != n; ++i) {
            Destroy(buf + i);
        }
    }
};
-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include "vector.h"

#include <stdexcept>

namespace {

struct Obj {

    Obj() {
        if (default_construction_throw_countdown > 0) {

            if (--default_construction_throw_countdown == 0) {

                throw std::runtime_error("Oops");
            }
        }

        ++num_default_constructed;
    }

    Obj(const Obj& other) {

        if (other.throw_on_copy) {

            throw std::runtime_error("Oops");
        }

        ++num_copied;
    }

    Obj(Obj&& /*other*/) noexcept {++num_moved;}

    Obj& operator=(const Obj& other) = default;
    Obj& operator=(Obj&& other) = default;

    ~Obj() {++num_destroyed;}

    static int GetAliveObjectCount() {return num_default_constructed + num_copied + num_moved - num_destroyed;}

    static void ResetCounters() {
        default_construction_throw_countdown = 0;
        num_default_constructed = 0;
        num_copied = 0;
        num_moved = 0;
        num_destroyed = 0;
    }

    bool throw_on_copy = false;

    static inline int default_construction_throw_countdown = 0;
    static inline int num_default_constructed = 0;
    static inline int num_copied = 0;
    static inline int num_moved = 0;
    static inline int num_destroyed = 0;
};

}//end namespace

void Test1() {
    Obj::ResetCounters();

    const size_t SIZE = 100500;
    const size_t INDEX = 10;
    const int MAGIC = 42;

    {
        Vector<int> v;
        assert(v.Capacity() == 0);
        assert(v.Size() == 0);

        v.Reserve(SIZE);
        assert(v.Capacity() == SIZE);
        assert(v.Size() == 0);
    }

    {
        Vector<int> v(SIZE);
        const auto& cv(v);
        assert(v.Capacity() == SIZE);
        assert(v.Size() == SIZE);
        assert(v[0] == 0);
        assert(&v[0] == &cv[0]);
        v[INDEX] = MAGIC;
        assert(v[INDEX] == MAGIC);
        assert(&v[100] - &v[0] == 100);

        v.Reserve(SIZE * 2);
        assert(v.Size() == SIZE);
        assert(v.Capacity() == SIZE * 2);
        assert(v[INDEX] == MAGIC);
    }

    {
        Vector<int> v(SIZE);
        v[INDEX] = MAGIC;
        const auto v_copy(v);
        assert(&v[INDEX] != &v_copy[INDEX]);
        assert(v[INDEX] == v_copy[INDEX]);
    }

    {
        Vector<Obj> v;
        v.Reserve(SIZE);
        assert(Obj::GetAliveObjectCount() == 0);
    }

    {
        Vector<Obj> v(SIZE);
        assert(Obj::GetAliveObjectCount() == SIZE);
        v.Reserve(SIZE * 2);
        assert(Obj::GetAliveObjectCount() == SIZE);
    }

    assert(Obj::GetAliveObjectCount() == 0);
}

void Test2() {
    const size_t SIZE = 100;
    Obj::ResetCounters();

    {
        Obj::default_construction_throw_countdown = SIZE / 2;

        try {
            Vector<Obj> v(SIZE);
            assert(false && "Exception is expected");

        } catch (const std::runtime_error&) {

        } catch (...) {
            assert(false && "Unexpected exception");
        }

        assert(Obj::num_default_constructed == SIZE / 2 - 1);
        assert(Obj::GetAliveObjectCount() == 0);
    }

    Obj::ResetCounters();

    {
        Vector<Obj> v(SIZE);

        try {
            v[SIZE / 2].throw_on_copy = true;
            Vector<Obj> v_copy(v);
            assert(false && "Exception is expected");

        } catch (const std::runtime_error&) {
            assert(Obj::num_copied == SIZE / 2);

        } catch (...) {
            assert(false && "Unexpected exception");
        }

        assert(Obj::GetAliveObjectCount() == SIZE);
    }

    Obj::ResetCounters();

    {
        Vector<Obj> v(SIZE);

        try {
            v[SIZE - 1].throw_on_copy = true;
            v.Reserve(SIZE * 2);
            assert(false && "Exception is expected");

        } catch (const std::runtime_error&) {
            assert(Obj::num_copied == SIZE - 1);

        } catch (...) {
            assert(false && "Unexpected exception");
        }

        assert(v.Capacity() == SIZE);
        assert(v.Size() == SIZE);
        assert(Obj::GetAliveObjectCount() == SIZE);
    }
}

int main() {
    Test1();
    Test2();
}