1.
STD::VECTOR FROM SCRATCH
Alexey Kutumov
Senior software engineer at Kaspersky Lab

2.
AGENDA
vector interface
vector_base
methods w/o size modifications
reserve
insert
erase
…
Profit!

3.
VECTOR INTERFACE

4.
INTERFACE
template <typename Type, typename Alloc = allocator<Type>>
class vector;

5.
MINIMAL ALLOCATOR INTERFACE
template <typename Type>
struct allocator {
typedef Type value_type;
value_type* allocate(size_t n, const void* /* hint */ = nullptr) {
return (value_type*)(::operator new(n * sizeof(value_type)));
}
void deallocate(value_type* p, size_t n) {
::operator delete(p, n * sizeof(value_type));
}
};

6.
VECTOR TYPES, PART 1
typedef ??? iterator;
typedef ??? const_iterator;
typedef ??? difference_type;
typedef ??? size_type;

7.
VECTOR TYPES, PART 1
typedef Type* iterator;
typedef const Type* const_iterator;
typedef ptrdiff_t difference_type;
typedef size_t size_type;

8.
VECTOR TYPES, PART 2
typedef value_type& reference;
typedef const value_type& const_reference;
typedef Type value_type;
typedef Alloc allocator_type;
typedef typename allocator_traits<Alloc>::pointer pointer;
typedef typename allocator_traits<Alloc>::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

9.
ALLOCATOR_TRAITS (TYPES, PART 1)
template <typename Allocator>
struct allocator_traits {
typedef Allocator allocator_type;
typedef typename Allocator::value_type value_type;
typedef ??? pointer;
typedef ??? const_pointer;
typedef ??? size_type;
(difference_type, void_pointer, const_void_pointer)

10.
ALLOCATOR_TRAITS (TYPES, PART 1)
template <typename Allocator>
struct allocator_traits {
typedef Allocator allocator_type;
typedef typename Allocator::value_type value_type;
typedef typename detail::get_pointer<Allocator>::type pointer;
typedef typename detail::get_const_pointer<Allocator>::type const_pointer;
typedef typename detail::get_size_type<Allocator>::type size_type;

11.
GET_POINTER
template <typename Allocator>
struct get_pointer {
template <typename Alloc2>
static auto select_type(int)->typename Alloc2::pointer;
template <typename Alloc2>
static auto select_type(wrap_int)->typename Allocator::value_type*;
typedef decltype(select_type<Allocator>(0)) type;
};

12.
ALLOCATOR_TRAITS (TYPES, PART 2)
template <typename Allocator>
struct allocator_traits {
// ...
typedef ??? propagate_on_container_copy_assignment;
typedef ??? propagate_on_container_move_assignment;
typedef ??? propagate_on_container_swap;

13.
ALLOCATOR_TRAITS (METHODS)
template <typename Alloc>
struct allocator_traits {
static pointer allocate(Alloc& a, size_type n, const void* hint = 0);
static void deallocate(Alloc& a, pointer p, size_type n);
template <typename Type, typename... Args>
static void construct(Alloc& alloc, Type* ptr, Args&&... args);
template <typename Type>
static void destroy(Alloc& alloc, Type* ptr);
static Alloc select_on_container_copy_construction(const Alloc& alloc);
};

14.
STD
allocator<>
iterator_traits<>
ptrdiff_t
make_unsigned<>
declval<>()
allocator_traits<>
pointer_traits<>
false_type, true_type
integral_constant<>
forward<>()
remove_reference<>
reverse_iterator<>
iterator_traits<>

15.
VECTOR_BASE

16.
VECTOR_BASE
template <typename Type, typename Allocator>
struct vector_base: private Allocator {
iterator m_first;
iterator m_last;
iterator m_endOfCapacity;
vector_base();
vector_base(const Allocator& alloc);
vector_base(vector_base&& other);
vector_base(vector_base&& other, const Allocator& alloc);
vector_base& operator=(vector_base&& other);
vector_base& operator=(const vector_base& other);
~vector_base();

17.
VECTOR_BASE
vector_base() : vector_base(Allocator()) {}
vector_base(const Allocator& alloc) : Allocator(alloc) {
tidy(*this);
}
vector_base(vector_base&& other)
: Allocator(std::move(static_cast<Allocator&&>(other))) {
swap_base(*this, static_cast<vector_base&>(other));
tidy(other);
}
vector_base(vector_base&& other, const Allocator& alloc) : Allocator(alloc) {
swap_base(*this, static_cast<vector_base&>(other));
tidy(other);
}

18.
VECTOR_BASE
vector_base& operator=(vector_base&& other) {
destroy_and_free(m_first, m_last, m_endOfCapacity, allocator_from(*this));
propagate_on_move_assignment(static_cast<Allocator&&>(other));
swap_base(*this, static_cast<vector_base&>(other));
tidy(other);
return *this;
}
vector_base& operator=(const vector_base& other) {
propagate_on_copy_assignment(static_cast<const Allocator&>(other));
return *this;
}

19.
VECTOR_BASE
void propagate_on_move_assignment(Allocator&& other) {
typedef vector_allocator_traits::propagate_on_container_move_assignment tag;
propagate_on_move_assignment(forward<Allocator>(other), tag());
}
void propagate_on_move_assignment(Allocator&& other, true_type) {
static_cast<Allocator&>(*this) = std::move(other);
}
void propagate_on_move_assignment(Allocator&& /* other */, false_type) {
// does nothing
}

20.
UNINITIALIZED_*
template<typename FwdIt, typename Alloc, typename ... Args>
void uninitialized_construct_a(FwdIt f, FwdIt l, Alloc& a, Args&&... args);
template<typename InputIt, typename FwdIt, typename Alloc>
FwdIt uninitialized_copy_a(InputIt first, InputIt last, FwdIt dest, Alloc& a);
template<typename Type, typename Size, typename FwdIt, typename Alloc>
FwdIt uninitialized_fill_n_a(FwdIt dest, Size n, const Type& v, Alloc& a);

21.
UNINITIALIZED_CONSTRUCT
template<typename FwdIt, typename Alloc, typename ... Args>
void uninitialized_construct_a(FwdIt f, FwdIt l, Alloc& a, Args&&... args) {
FwdIt c = f;
try {
for (; c != l; ++c) {
allocator_traits<Alloc>::construct(a, addressof(*c), forward<Args>(args)...);
}
}
catch (...) {
destroy_range(first, c, alloc);
throw;
}
}

22.
STD
move()
swap()
addressof()
enable_if<>
is_function<>
uninitialized_fill_n()
uninitialized_copy()

23.
METHODS WITHOUT SIZE MODIFICATIONS

24.
METHODS WITHOUT SIZE MODIFICATIONS
allocator_type get_allocator() const;
*reference at(size_type pos) *;
*reference operator[](size_type pos) *;
*reference front() *;
*reference back() *;
*pointer data() *;
*iterator *begin() *;
*iterator *end() *;
size_type size() const;
size_type capacity() const;
size_type max_size() const;
bool empty() const;

25.
RESERVE

26.
RESERVE
void reserve(size_type newCapacity) {
if (newCapacity > max_size()) {
throw std::length_error("");
}
if (newCapacity > capacity()) {
iterator newFirst = alloc(allocator_from(*this), newCapacity);
try {
relocate(newFirst, newCapacity);
} catch (...) {
dealloc(allocator_from(*this), newFirst, newCapacity);
throw;
}
}
}

27.
RELOCATE
void relocate(iterator newFirst, size_type newCapacity) {
iterator newLast = detail::uninitialized_copy_a(
make_move_iterator(m_first),
make_move_iterator(m_last),
newFirst,
allocator_from(*this));
destroy_and_free(m_first, m_last, m_endOfCapacity, allocator_from(*this));
m_first = newFirst;
m_last = newLast;
m_endOfCapacity = m_first + newCapacity;
}

28.
MOVE_ITERATOR
template <typename Iterator>
class move_iterator {
Iterator m_current;
public:
typedef value_type&& reference;
reference operator*() const {
return std::move(*m_current);
}

29.
STD
length_error
logic_error
basic_string<>
logic_error
basic_string<>
...
exception
make_move_iterator()
move_iterator<>

30.
INSERT

31.
INSERT
iterator insert(const_iterator pos, const Type& value);
iterator insert(const_iterator pos, Type&& value);
iterator insert(const_iterator pos, size_type count, const Type& value);
template <typename InputIterator>
typename enable_if<is_iterator<InputIterator>::value, iterator>::type
insert(const_iterator pos, InputIterator first, InputIterator last);
iterator insert(const_iterator pos, std::initializer_list<Type> ilist);

32.
INSERT
iterator insert(const_iterator pos, const Type& value) {
return insert_with_perfect_fwd(pos, value);
}
iterator insert(const_iterator pos, Type&& value) {
return insert_with_perfect_fwd(pos, std::forward<Type>(value));
}
iterator insert(const_iterator pos, std::initializer_list<Type> ilist) {
return insert_range(pos, ilist.begin(), ilist.end());
}
iterator insert(const_iterator pos, size_type count, const Type& value) {
return insert_range(pos, make_iterator(count, value), make_iterator());
}

33.
COUNTING_ITERATOR
template <typename Type>
struct counting_iterator {
size_t m_count;
Type* m_value;
counting_iterator& operator++() {
--m_count;
return *this;
}
reference operator*() {
return *m_value;
}
};

34.
INSERT_WITH_PERFECT_FWD
template <typename... Args>
iterator insert_with_perfect_fwd(const_iterator pos, Args&&... a) {
difference_type offset = pos - cbegin();
grow(size() + 1);
uninitialized_construct_a(m_last, m_last + 1, alloc(*this), forward<Args>(a)...);
m_last += 1;
rotate(m_first + offset, m_last - 1, m_last);
return m_first + offset;
}

35.
ROTATE
first new_first last

36.
INSERT_RANGE
template <typename InputIterator>
insert_range(const_iterator pos, InputIterator first, InputIterator last) {
difference_type offset = pos - cbegin();
difference_type count = std::distance(first, last);
grow(size() + count);
detail::uninitialized_copy_a(first, last, m_last, allocator_from(*this));
m_last += count;
rotate(m_first + offset, m_last - count, m_last);
return m_first + offset;
}

37.
STD
rotate()
iter_swap()
distance()
is_base_of<>

38.
ERASE

39.
ERASE
iterator erase(const_iterator pos) {
return erase(pos, pos + 1);
}
iterator erase(const_iterator first, const_iterator last) {
iterator newLast = rotate(cast_from_const(first), cast_from_const(last), m_last);
detail::destroy_range(newLast, m_last, allocator_from(*this));
m_last = newLast;
return cast_from_const(first);
}

40.
OTHER METHODS

41.
OTHER METHODS
void assign(size_type count, const Type& value) {
erase(m_first, m_last);
resize(count, value);
}
template <typename... Args>
iterator emplace(const_iterator pos, Args&&... args) {
return insert_with_perfect_fwd(pos, std::forward<Args>(args)...);
}
void push_back(const value_type& value) {
insert_with_perfect_fwd(end(), value);
}

42.
CLOC
---------------------------------------------------------------------------
Language files blank comment code
---------------------------------------------------------------------------
C/C++ Header 20 428 33 1449
C++ 3 271 8 995
---------------------------------------------------------------------------
SUM: 23 699 41 2444
---------------------------------------------------------------------------

43.
LET'S TALK?
alexey.kutumov@gmail.com
https://github.com/prograholic/simple_vector