daily pastebin goal
10%
SHARE
TWEET

Untitled

a guest Mar 26th, 2019 65 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #ifndef VECTOR_H
  2. #define VECTOR_H
  3.  
  4. #include <cstring>
  5. #include <string>
  6. #include <algorithm>
  7. #include <initializer_list>
  8. #include <stdexcept>
  9. #include <iostream>
  10.  
  11. #include "miniatur.h"
  12.  
  13. template<typename T>
  14. class Vector {
  15. public:
  16.     class ConstIterator;
  17.     class Iterator;
  18.     using value_type = T;
  19.     using size_type = std::size_t;
  20.     using difference_type = std::ptrdiff_t;
  21.     using reference = value_type&;
  22.     using const_reference = const value_type&;
  23.     using pointer = value_type*;
  24.     using const_pointer = const value_type*;
  25.     using iterator = Vector::Iterator;
  26.     using const_iterator = Vector::ConstIterator;
  27.  
  28.     class ConstIterator {
  29.     public:
  30.         using value_type = Vector::value_type;
  31.         using reference = Vector::const_reference;
  32.         using pointer = Vector::const_pointer;
  33.         using difference_type = Vector::difference_type;
  34.         using iterator_category = std::forward_iterator_tag;
  35.  
  36.     private:
  37.         pointer ptr;
  38.  
  39.     public:
  40.         ConstIterator(pointer ptr = nullptr) : ptr(ptr) {
  41.         }
  42.  
  43.         reference operator*() const {
  44.             return *ptr;
  45.         }
  46.  
  47.         pointer operator->() const {
  48.             return ptr;
  49.         }
  50.  
  51.         bool operator==(const const_iterator &it) const {
  52.             return ptr == it.ptr;
  53.         }
  54.  
  55.         bool operator!=(const const_iterator &it) const {
  56.             return ptr != it.ptr;
  57.         }
  58.  
  59.         const_iterator& operator++() {
  60.             ptr++;
  61.             return *this;
  62.         }
  63.  
  64.         const_iterator operator++(int) {
  65.             return ptr++;
  66.         }
  67.  
  68.         difference_type operator-(const const_iterator& rop) const {
  69.             return ptr - rop.ptr;
  70.         }
  71.     };
  72.     class Iterator {
  73.     public:
  74.         using value_type = Vector::value_type;
  75.         using reference = Vector::reference;
  76.         using pointer = Vector::pointer;
  77.         using difference_type = Vector::difference_type;
  78.         using iterator_category = std::forward_iterator_tag;
  79.  
  80.     private:
  81.         pointer ptr;
  82.  
  83.     public:
  84.         Iterator(pointer ptr = nullptr) : ptr(ptr) {
  85.         }
  86.  
  87.         reference operator*() const {
  88.             return *ptr;
  89.         }
  90.  
  91.         pointer operator->() const {
  92.             return ptr;
  93.         }
  94.  
  95.         bool operator==(const const_iterator &it) const {
  96.             return ptr == it.operator->();
  97.         }
  98.  
  99.         bool operator!=(const const_iterator &it) const {
  100.             return ptr != it.operator->();
  101.         }
  102.  
  103.         iterator& operator++() {
  104.             ptr++;
  105.             return *this;
  106.         }
  107.  
  108.         iterator operator++(int) {
  109.             return ptr++;
  110.         }
  111.  
  112.         operator const_iterator() const {
  113.             return const_iterator(ptr);
  114.         }
  115.     };
  116.  
  117. private:
  118.     static constexpr size_type min_sz {5};
  119.  
  120.     size_type sz {0};
  121.     size_type max_sz {0};
  122.     pointer values {nullptr};
  123.  
  124.     void allocate(size_type new_sz) {
  125.         new_sz = std::max(new_sz, min_sz);
  126.  
  127.         if (new_sz < sz || new_sz == max_sz) {
  128.             return;
  129.         }
  130.  
  131.         pointer new_values = new value_type[new_sz];
  132.         if (values) {
  133.             for (size_type i = 0; i < sz; i++) {
  134.                 new_values[i] = values[ i];
  135.             }
  136.             delete[] values;
  137.         }
  138.         values = new_values;
  139.         max_sz = new_sz;
  140.     }
  141.  
  142. public:
  143.  
  144.     Vector(size_type n = 0) : max_sz(std::max(min_sz, n * 2)), values(new value_type[max_sz]) {
  145.     }
  146.  
  147.     Vector(const std::initializer_list<value_type> &list) : Vector(list.size()) {
  148.         for (const_reference value : list) {
  149.             push_back(value);
  150.         }
  151.     }
  152.  
  153.     Vector(const Vector<value_type> &vector) {
  154.         operator=(vector);
  155.     }
  156.  
  157.     ~Vector() {
  158.         delete[] values;
  159.     }
  160.  
  161.     size_type size() const {
  162.         return sz;
  163.     }
  164.  
  165.     bool empty() const {
  166.         return sz == 0;
  167.     }
  168.  
  169.     void clear() {
  170.         sz = 0;
  171.     }
  172.  
  173.     void reserve(size_type n) {
  174.         if (n <= max_sz) {
  175.             return;
  176.         }
  177.         allocate(n);
  178.     }
  179.  
  180.     void shrink_to_fit() {
  181.         allocate(sz);
  182.     }
  183.  
  184.     void push_back(const_reference value) {
  185.         if (sz >= max_sz) {
  186.             reserve(max_sz * 2);
  187.         }
  188.         values[sz++] = value;
  189.     }
  190.  
  191.     void pop_back() {
  192.         if (sz == 0) {
  193.             throw std::runtime_error("List is already empty");
  194.         }
  195.         sz--;
  196.     }
  197.  
  198.     void operator=(const Vector<value_type> &vector) {
  199.         sz = 0;
  200.         allocate(vector.max_sz);
  201.         for (auto value : vector) {
  202.             push_back(value);
  203.         }
  204.     }
  205.  
  206.     reference operator[](size_type index) {
  207.         if (index < 0 || index >= sz) {
  208.             throw std::runtime_error("Array out of bounds index: " + std::to_string(index) + " max:" + std::to_string(sz));
  209.         }
  210.         return values[index];
  211.     }
  212.  
  213.     const_reference operator[](size_type index) const {
  214.         if (index < 0 || index >= sz) {
  215.             throw std::runtime_error("Array out of bounds index: " + std::to_string(index) + " max:" + std::to_string(sz));
  216.         }
  217.         return values[index];
  218.     }
  219.  
  220.     size_type capacity() const {
  221.         return max_sz;
  222.     }
  223.  
  224.     iterator begin() {
  225.         return values;
  226.     }
  227.  
  228.     iterator end() {
  229.         return values + sz;
  230.     }
  231.  
  232.     const_iterator begin() const {
  233.         return values;
  234.     }
  235.  
  236.     const_iterator end() const {
  237.         return values + sz;
  238.     }
  239.  
  240.     iterator insert(const_iterator pos, const_reference val) {
  241.         auto diff = pos - begin();
  242.         if (diff < 0 || static_cast<size_type>(diff) > sz) {
  243.             throw std::runtime_error("Iterator out of bounds");
  244.         }
  245.         size_type current{static_cast<size_type>(diff)};
  246.         if (sz >= max_sz) {
  247.             reserve(max_sz * 2);
  248.         }
  249.         for (size_t i {sz}; i-- > current;) {
  250.             values[i + 1] = values[i];
  251.         }
  252.         values[current] = val;
  253.         ++sz;
  254.         return iterator {values + current};
  255.     }
  256.  
  257.     iterator erase(const_iterator pos) {
  258.         auto diff = pos - begin();
  259.         if (diff < 0 || static_cast<size_type>(diff) >= sz) {
  260.             throw std::runtime_error("Iterator out of bounds");
  261.         }
  262.         size_type current{static_cast<size_type>(diff)};
  263.         for (size_type i {current}; i < sz - 1; ++i) {
  264.             values[i] = values[i + 1];
  265.         }
  266.         --sz;
  267.         return iterator {values + current};
  268.     }
  269.  
  270.     friend std::ostream& operator<<(std::ostream &out, const Vector<value_type> &vector) {
  271.         out << "[";
  272.         bool first {true};
  273.         for (size_type i = 0; i < vector.size(); i++) {
  274.             if (!first) {
  275.                 out << ", ";
  276.             }
  277.             first = false;
  278.             out << vector[i];
  279.         }
  280.         return out << "]";
  281.     }
  282.  
  283. };
  284. #endif
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top