My-cpp-vector/iterator.h at master · tonichoff/My-cpp-vector · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#pragma once
#include <iterator>

template<class T>
class Iterator;

template<class T>
struct std::iterator_traits<Iterator<T>> {
  using difference_type = std::ptrdiff_t;
  using value_type = T;
  using reference = T&;
  using pointer = T*;
  using iterator_category = std::random_access_iterator_tag;
};

template<class T>
class Iterator {
public:
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = T*;
  using reference = T&;
  using iterator_category = std::random_access_iterator_tag;
  using size_type = std::size_t;

  Iterator(T* ptr) : _ptr(ptr) {}
  Iterator(const Iterator& other) : _ptr(other._ptr) {}
  Iterator(const Iterator&& other) : _ptr(std::move(other._ptr)) {}
  ~Iterator() {}

  Iterator& operator=(const Iterator& other) {
    _ptr = other._ptr;
    return *this;
  }

  Iterator& operator=(Iterator&& other) {
    _ptr = std::move(_ptr, other._ptr);
  }

  Iterator& operator++() {
    _ptr++;
    return *this;
  }

  Iterator& operator++(int) {
    Iterator it(_ptr);
    _ptr++;
    return it;
  }

  Iterator& operator+=(size_type count) {
    _ptr += count;
    return *this;
  }

  Iterator& operator--() {
    _ptr--;
    return *this;
  }

  Iterator& operator--(int) {
    Iterator it(_ptr);
    _ptr--;
    return it;
  }

  Iterator& operator-=(size_type count) {
    _ptr -= count;
    return *this;
  }

  friend Iterator operator+(const Iterator& other, size_type count) {
    return Iterator(other._ptr + count);
  }

  friend Iterator operator+(size_type count, const Iterator& other) {
    return Iterator(other._ptr + count);
  }

  friend Iterator operator-(const Iterator& other, size_type count) {
    return Iterator(other._ptr - count);
  }

  friend difference_type operator-(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr - rhs._ptr;
  }

  reference operator*() const {
    return *_ptr;
  }

  pointer operator->() const {
    return _ptr;
  }

  reference operator[](size_type pos) const {
    return *(_ptr + pos);
  }

  friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr == rhs._ptr;
  }

  friend bool operator!=(const Iterator& rhs, const Iterator& lhs) {
    return lhs._ptr != rhs._ptr;
  }

  friend bool operator<(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr < rhs._ptr;
  }

  friend bool operator>(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr > rhs._ptr;
  }

  friend bool operator<=(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr <= rhs._ptr;
  }

  friend bool operator>=(const Iterator& lhs, const Iterator& rhs) {
    return lhs._ptr >= rhs._ptr;
  }

  friend void swap(Iterator& lhs, Iterator& rhs) {
    std::swap(lhs._ptr, rhs._ptr);
  }
private:
  pointer _ptr;
};