daily pastebin goal
14%
SHARE
TWEET

Untitled

a guest Oct 21st, 2018 79 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
  1. #pragma once
  2. #include <iostream>
  3. #include <initializer_list>
  4. #include <iterator>
  5.  
  6. class Vector {
  7. private:
  8.     int* data_;
  9.     size_t size_;
  10.     size_t capacity_;
  11.  
  12. public:
  13.     Vector() {
  14.         size_ = 0;
  15.         capacity_ = 1;
  16.         data_ = new int[1];
  17.     }
  18.  
  19.     explicit Vector(size_t size) {
  20.         size_ = size;
  21.         capacity_ = size;
  22.         data_ = new int[capacity_];
  23.         for (size_t i = 0; i < size_; ++i) {
  24.             data_[i] = 0;
  25.         }
  26.     }
  27.  
  28.     Vector(std::initializer_list<int> list) {
  29.         size_ = list.size();
  30.         capacity_ = list.size();
  31.         data_ = new int[capacity_];
  32.         size_t i = 0;
  33.         for (const int& elem : list) {
  34.             data_[i] = elem;
  35.             ++i;
  36.         }
  37.     }
  38.  
  39.     Vector(const Vector& list) {
  40.         size_ = list.size_;
  41.         capacity_ = list.capacity_;
  42.         data_ = new int[capacity_];
  43.         for (size_t i = 0; i < size_; ++i) {
  44.             data_[i] = list.data_[i];
  45.         }
  46.     }
  47.  
  48.     Vector(Vector&& list) {
  49.         size_ = list.size_;
  50.         capacity_ = list.capacity_;
  51.         data_ = list.data_;
  52.         list.data_ = nullptr;
  53.     }
  54.  
  55.     Vector& operator=(const Vector& list) {
  56.         if (list.data_ == data_) {
  57.             return *this;
  58.         }
  59.         delete[] data_;
  60.         size_ = list.size_;
  61.         capacity_ = list.capacity_;
  62.         data_ = new int[capacity_];
  63.         for (size_t i = 0; i < size_; ++i) {
  64.             data_[i] = list.data_[i];
  65.         }
  66.         return *this;
  67.     }
  68.  
  69.     Vector& operator=(Vector&& list) {
  70.         delete[] data_;
  71.         size_ = list.size_;
  72.         capacity_ = list.capacity_;
  73.         data_ = list.data_;
  74.         list.data_ = nullptr;
  75.         return *this;
  76.     }
  77.  
  78.     ~Vector() {
  79.         delete[] data_;
  80.     }
  81.  
  82.     void Swap(Vector& list) {
  83.         std::swap(data_, list.data_);
  84.         std::swap(size_, list.size_);
  85.         std::swap(capacity_, list.capacity_);
  86.     }
  87.  
  88.     int operator[](size_t i) const {
  89.         return data_[i];
  90.     }
  91.  
  92.     int& operator[](size_t i) {
  93.         return data_[i];
  94.     }
  95.  
  96.     size_t Size() const {
  97.         return size_;
  98.     }
  99.  
  100.     size_t Capacity() const {
  101.         return capacity_;
  102.     }
  103.  
  104.     void PushBack(int elem) {
  105.         if (size_ != capacity_) {
  106.             data_[size_] = elem;
  107.             ++size_;
  108.         } else {
  109.             capacity_ *= 2;
  110.             int* data = new int[capacity_];
  111.             for (size_t i = 0; i < size_; ++i) {
  112.                 data[i] = data_[i];
  113.             }
  114.  
  115.             data[size_] = elem;
  116.             delete[] data_;
  117.             ++size_;
  118.             data_ = data;
  119.         }
  120.     }
  121.  
  122.     void PopBack() {
  123.         --size_;
  124.     }
  125.  
  126.     void Clear() {
  127.         size_ = 0;
  128.     }
  129.  
  130.     void Reserve(size_t capacity) {
  131.         if (capacity > capacity_) {
  132.             capacity_ = capacity;
  133.             int* data = new int[capacity_];
  134.             for (size_t i = 0; i < size_; ++i) {
  135.                 data[i] = data_[i];
  136.             }
  137.             delete[] data_;
  138.             data_ = data;
  139.         }
  140.     }
  141.  
  142.     class Iterator : public std::iterator<std::forward_iterator_tag, int> {
  143.     private:
  144.         int* current_;
  145.  
  146.     public:
  147.         Iterator() {
  148.         }
  149.  
  150.         Iterator(int* current) {
  151.             current_ = current;
  152.         }
  153.  
  154.         bool operator==(const Iterator& iter) const {
  155.             return current_ == iter.current_;
  156.         }
  157.  
  158.         bool operator!=(const Iterator& iter) const {
  159.             return !(*this == iter);
  160.         }
  161.  
  162.         Iterator& operator++() {
  163.             ++current_;
  164.             return *this;
  165.         }
  166.  
  167.         Iterator operator++(int) {
  168.             Iterator cpy(*this);
  169.             ++current_;
  170.             return cpy;
  171.         }
  172.  
  173.         Iterator& operator--() {
  174.             --current_;
  175.             return *this;
  176.         }
  177.  
  178.         Iterator operator--(int) {
  179.             Iterator cpy(*this);
  180.             --current_;
  181.             return cpy;
  182.         }
  183.  
  184.         friend Iterator operator+(const Iterator kfirst, const int& klen) {
  185.             Iterator result(kfirst.current_ + klen);
  186.             return result;
  187.         }
  188.  
  189.         friend int operator-(const Iterator kfirst, const Iterator ksecond) {
  190.             return kfirst.current_ - ksecond.current_;
  191.         }
  192.  
  193.         Iterator& operator+=(const int& klen) {
  194.             current_ += klen;
  195.             return *this;
  196.         }
  197.  
  198.         Iterator& operator-=(const int& klen) {
  199.             current_ -= klen;
  200.             return *this;
  201.         }
  202.  
  203.         int& operator*() {
  204.             return *current_;
  205.         }
  206.  
  207.         int* operator->() {
  208.             return current_;
  209.         }
  210.     };
  211.  
  212.     Iterator Begin() {
  213.         return Iterator(data_);
  214.     }
  215.  
  216.     Iterator End() {
  217.         return Iterator(data_ + size_);
  218.     }
  219.  
  220.     Iterator begin() {  // NOLINT
  221.         return Iterator(data_);
  222.     }
  223.  
  224.     Iterator end() {  // NOLINT
  225.         return Iterator(data_ + size_);
  226.     }
  227. };
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