The document describes how to implement a std::vector from scratch in C++. It begins with defining the vector interface and types like iterator, size_type, etc. It then describes implementing a vector_base class to handle memory allocation and storage. The rest of the document outlines methods for common vector operations without size modifications like at(), methods for changing the size like reserve(), insert(), and erase(). It provides code snippets and discusses using various Standard Library components to implement the vector functionality.

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