SHARE
TWEET

Untitled

a guest Nov 17th, 2019 67 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <cstring>
  3. #include <initializer_list>
  4. #include <string>
  5. #include <algorithm>
  6. #include <memory>
  7. #include <chrono>
  8.  
  9. namespace my_vector {
  10.     template <typename T>
  11.     class vector {
  12.         private:
  13.             char* buffer_;
  14.             std::size_t size_;
  15.             int capacity_;
  16.             typedef T* iterator;
  17.        
  18.         public:
  19.             vector() : size_(0), buffer_(nullptr) { }
  20.            
  21.             vector(std::initializer_list<T> set)
  22.                     : size_(set.size()), capacity_(set.size()),
  23.                       buffer_(new char[sizeof(T) * set.size()]) {
  24.                 std::uninitialized_move(set.begin(), set.end(), reinterpret_cast<T*>(buffer_));
  25.             }
  26.  
  27.             vector(std::size_t n, const T& default_value = T())
  28.                     : size_(n), capacity_(n), buffer_(new char[sizeof(T) * n]) {
  29.                 std::uninitialized_fill_n(reinterpret_cast<T*>(buffer_), n, default_value);
  30.             }
  31.  
  32.             vector(const vector<T>& temp)
  33.                     : size_(temp.size()), capacity_(temp.size()),
  34.                       buffer_(new char[sizeof(T) * temp.size()]) {
  35.                 std::uninitialized_copy(temp.begin(), temp.end(), reinterpret_cast<T*>(buffer_));
  36.             }
  37.            
  38.             vector(vector<T>&& temp)
  39.                     : size_(temp.size()), capacity_(temp.size()), buffer_(temp.buffer_) {
  40.                 temp.size_ = 0;
  41.                 temp.capacity_ = 0;
  42.                 temp.buffer_ = nullptr;
  43.             }
  44.            
  45.             vector& operator =(const vector<T>& other) {
  46.                 std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  47.                 buffer_ = new char[sizeof(T) * other.size()];
  48.                 size_ = capacity_ = other.size();
  49.                 std::uninitialized_copy(other.begin(), other.end(), reinterpret_cast<T*>(buffer_));
  50.                 return *this;
  51.             }
  52.  
  53.             vector& operator =(vector<T>&& other) {
  54.                 std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  55.                 buffer_ = new char[sizeof(T) * other.size()];
  56.                 std::uninitialized_copy(other.begin(), other.end(), reinterpret_cast<T*>(buffer_));
  57.                 size_ = capacity_ = other.size();
  58.                 other.size = 0;
  59.                 other.capacity_ = 0;
  60.                 other.buffer_ = nullptr;
  61.                 return *this;
  62.             }
  63.  
  64.             ~vector() {
  65.                 std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  66.                 delete [] buffer_;
  67.             }
  68.  
  69.             T& front() {
  70.                 return *std::launder(reinterpret_cast<T*>(buffer_));
  71.             }
  72.  
  73.             const T& front() const {
  74.                 return *std::launder(reinterpret_cast<T*>(buffer_));
  75.             }
  76.  
  77.             T& back() {
  78.                 return *std::launder(reinterpret_cast<T*>(buffer_) + size_ - 1);
  79.             }
  80.  
  81.             const T& back() const {
  82.                 return *std::launder(reinterpret_cast<T*>(buffer_) + size_ - 1);
  83.             }
  84.  
  85.             T& at(int index) {
  86.                 return *std::launder(reinterpret_cast<T*>(buffer_) + index);
  87.             }
  88.  
  89.             const T& at(int index) const {
  90.                 return *std::launder(reinterpret_cast<T*>(buffer_) + index);
  91.             }
  92.  
  93.             void pop_back() {
  94.                 size_--;
  95.                 std::destroy_at(reinterpret_cast<T*>(buffer_) + size_);
  96.             }
  97.  
  98.             T* begin() {
  99.                 return std::launder(reinterpret_cast<T*>(buffer_));
  100.             }
  101.            
  102.             const T* begin() const {
  103.                 return std::launder(reinterpret_cast<T*>(buffer_));
  104.             }
  105.  
  106.             T* end() {
  107.                 return std::launder(reinterpret_cast<T*>(buffer_) + size_);
  108.             }
  109.  
  110.             const T* end() const {
  111.                 return std::launder(reinterpret_cast<T*>(buffer_) + size_);
  112.             }
  113.  
  114.             void clear() {
  115.                 std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  116.                 size_ = 0;
  117.             }
  118.  
  119.             bool empty() const {
  120.                 return size_ == 0;
  121.             }
  122.  
  123.             T& operator [](std::size_t index) {
  124.                 return *std::launder(reinterpret_cast<T*>(buffer_) + index);
  125.             }
  126.  
  127.             const T& operator[](std::size_t index) const {
  128.                 return *std::launder(reinterpret_cast<T*>(buffer_) + index);
  129.             }
  130.  
  131.             std::size_t size() {
  132.                 return size_;
  133.             }
  134.            
  135.             const std::size_t size() const {
  136.                 return size_;
  137.             }
  138.  
  139.             void push_back(T&& argument) {
  140.                 if (size_ == capacity_) {
  141.                     char* new_buffer_ = new char[size_* sizeof(T) * 2];
  142.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_),
  143.                                             reinterpret_cast<T*>(buffer_) + size_,
  144.                                             reinterpret_cast<T*>(new_buffer_));
  145.                     std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  146.                     delete [] buffer_;
  147.                     buffer_ = new_buffer_;                
  148.                     capacity_ = size_ * 2;      
  149.                 }
  150.                 new (reinterpret_cast<T*>(buffer_) + size_) T(std::move(argument));
  151.                 size_++;
  152.             }
  153.                
  154.             void push_back(T& argument) {
  155.                 if (size_ == capacity_) {
  156.                     char* new_buffer_ = new char[size_* sizeof(T) * 2];
  157.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_),
  158.                                             reinterpret_cast<T*>(buffer_) + size_,
  159.                                             reinterpret_cast<T*>(new_buffer_));
  160.                     std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  161.                     delete [] buffer_;
  162.                     buffer_ = new_buffer_;                
  163.                     capacity_ = size_ * 2;      
  164.                 }
  165.                 new (reinterpret_cast<T*>(buffer_) + size_) T(argument);
  166.                 size_++;
  167.             }
  168.  
  169.             void insert(vector<T>::iterator place, T&& argument) {
  170.                 int index = std::distance(reinterpret_cast<T*>(buffer_), place);
  171.                 if (size_ == capacity_) {
  172.                     char* new_buffer_ = new char[size_ * sizeof(T) * 2];
  173.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_),
  174.                                             reinterpret_cast<T*>(buffer_) + index,
  175.                                             reinterpret_cast<T*>(new_buffer_));
  176.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_) + index,
  177.                                             reinterpret_cast<T*>(buffer_) + size_,
  178.                                             reinterpret_cast<T*>(new_buffer_) + index + 1);
  179.                     new (reinterpret_cast<T*>(new_buffer_) + index) T(std::move(argument));
  180.                     std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  181.                     delete [] buffer_;
  182.                     buffer_ = new_buffer_;  
  183.                     capacity_ = size_ * 2;
  184.                 } else {
  185.                     new (reinterpret_cast<T*>(buffer_) + size_)
  186.                         T(*(reinterpret_cast<T*>(buffer_) + size_ - 1));
  187.                     std::move(reinterpret_cast<T*>(buffer_) + index,
  188.                               reinterpret_cast<T*>(buffer_) + size_ - 1,
  189.                               reinterpret_cast<T*>(buffer_) + index + 1);
  190.                     *(reinterpret_cast<T*>(buffer_) + index) = std::move(argument);
  191.                 }
  192.                 size_++;
  193.             }
  194.  
  195.             void insert(vector<T>::iterator place, T& argument) {  
  196.                 int index = std::distance(reinterpret_cast<T*>(buffer_), place);
  197.                 if (size_ == capacity_) {
  198.                     char* new_buffer_ = new char[size_ * sizeof(T) * 2];
  199.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_),
  200.                                             reinterpret_cast<T*>(buffer_) + index,
  201.                                             reinterpret_cast<T*>(new_buffer_));
  202.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_) + index,
  203.                                             reinterpret_cast<T*>(buffer_) + size_,
  204.                                             reinterpret_cast<T*>(new_buffer_) + index + 1);
  205.                     new (reinterpret_cast<T*>(new_buffer_) + index) T(argument);
  206.                     std::destroy_n(reinterpret_cast<T*>(buffer_), size_);
  207.                     delete [] buffer_;
  208.                     buffer_ = new_buffer_;  
  209.                     capacity_ = size_ * 2;
  210.                 } else {
  211.                     new (reinterpret_cast<T*>(buffer_) + size_)
  212.                         T(*(reinterpret_cast<T*>(buffer_) + size_ - 1));
  213.                     std::move(reinterpret_cast<T*>(buffer_) + index,
  214.                               reinterpret_cast<T*>(buffer_) + size_ - 1,
  215.                               reinterpret_cast<T*>(buffer_) + index + 1);
  216.                     *(reinterpret_cast<T*>(buffer_) + index) = argument;
  217.                 }
  218.                 size_++;
  219.             }
  220.                    
  221.             void insert(int place, vector<T>::iterator start_of_range,
  222.                                    vector<T>::iterator end_of_range) {    
  223.                 int start_index = std::distance(reinterpret_cast<T*>(buffer_), start_of_range);
  224.                 int end_index = std::distance(reinterpret_cast<T*>(buffer_), end_of_range);
  225.                 int length_of_range = end_index - start_index;
  226.                 if (size_ == capacity_) {
  227.                     char* new_buffer_ = new char[sizeof(T) * size_ * 2];
  228.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_),
  229.                                             reinterpret_cast<T*>(buffer_) + place,
  230.                                             reinterpret_cast<T*>(new_buffer_));
  231.                     std::uninitialized_move(reinterpret_cast<T*>(buffer_) + place,
  232.                                             reinterpret_cast<T*>(buffer_) + size_,
  233.                                             reinterpret_cast<T*>(new_buffer_) + place +
  234.                                             length_of_range);
  235.                     std::destroy(reinterpret_cast<T*>(buffer_), reinterpret_cast<T*>(buffer_) +
  236.                                  size_);
  237.                     delete [] buffer_;
  238.                     buffer_ = new_buffer_;
  239.                     capacity_ = size_ * 2;
  240.                 } else {
  241.                     if (size_ >= place + length_of_range) {
  242.                         for (int i = length_of_range; i > 0; i--) {
  243.                             new (reinterpret_cast<T*>(buffer_) + size_ + i - 1)
  244.                                 T(*(reinterpret_cast<T*>(buffer_) + size_ + i - length_of_range - 1));
  245.                         }
  246.                         std::move(reinterpret_cast<T*>(buffer_) + place,
  247.                                   reinterpret_cast<T*>(buffer_) + size_ - length_of_range,
  248.                                   reinterpret_cast<T*>(buffer_) + place + length_of_range);
  249.                     } else {
  250.                         int number_of_elements = place + length_of_range - size_;
  251.                        
  252.                     }
  253.                 }
  254.                 std::move(start_of_range, end_of_range, reinterpret_cast<T*>(buffer_) + place);
  255.                 size_ += length_of_range;
  256.             }
  257.                
  258.             void erase(vector<T>::iterator place) {
  259.                 int index = std::distance(reinterpret_cast<T*>(buffer_), place);
  260.                 std::move(reinterpret_cast<T*>(buffer_) + index + 1,
  261.                           reinterpret_cast<T*>(buffer_) + size_,
  262.                           reinterpret_cast<T*>(buffer_) + index);
  263.                 size_--;
  264.                 std::destroy_at(reinterpret_cast<T*>(buffer_) + size_);
  265.             }
  266.  
  267.             void erase(vector<T>::iterator start_of_range, vector<T>::iterator end_of_range) {    
  268.                 int start_index = std::distance(reinterpret_cast<T*>(buffer_), start_of_range);
  269.                 int end_index = std::distance(reinterpret_cast<T*>(buffer_), end_of_range);
  270.                 int length_of_range = end_index - start_index;
  271.                 std::move(reinterpret_cast<T*>(buffer_) + end_index,
  272.                           reinterpret_cast<T*>(buffer_) + size_,
  273.                           reinterpret_cast<T*>(buffer_) + start_index);  
  274.                 std::destroy(reinterpret_cast<T*>(buffer_) + size_ - length_of_range,
  275.                              reinterpret_cast<T*>(buffer_) + size_);
  276.                 size_ -= length_of_range;
  277.             }
  278.                    
  279.             bool operator <(const vector<T>& second) const {
  280.                 std::size_t less_size = std::min(size_, second.size_);
  281.                 for (int i = 0; i < less_size; i++) {
  282.                     if (*(reinterpret_cast<T*>(buffer_) + i) !=
  283.                         *(reinterpret_cast<T*>(second.buffer_) + i)) {
  284.                         return *(reinterpret_cast<T*>(buffer_) + i) <
  285.                                *(reinterpret_cast<T*>(second.buffer_) + i);
  286.                     }
  287.                 }
  288.                 return size_ < second.size_;
  289.             }
  290.  
  291.             bool operator <=(const vector<T>& second) const {
  292.                 std::size_t less_size = std::min(size_, second.size_);
  293.                 for (int i = 0; i < less_size; i++) {
  294.                     if (*(reinterpret_cast<T*>(buffer_) + i) !=
  295.                         *(reinterpret_cast<T*>(second.buffer_) + i)) {
  296.                         return *(reinterpret_cast<T*>(buffer_) + i) <
  297.                                *(reinterpret_cast<T*>(second.buffer_) + i);
  298.                     }
  299.                 }
  300.                 return size_ <= second.size_;
  301.             }
  302.  
  303.             bool operator ==(const vector<T>& second) const {
  304.                 if (size_ != second.size_) {
  305.                     return false;
  306.                 } else {
  307.                     for (int i = 0; i < size_; i++) {
  308.                         if (*(reinterpret_cast<T*>(buffer_) + i) !=
  309.                             *(reinterpret_cast<T*>(second.buffer_) + i)) {
  310.                             return false;
  311.                         }
  312.                     }
  313.                     return true;
  314.                 }
  315.             }
  316.            
  317.             bool operator !=(const vector<T>& second) const {
  318.                 return !(*this == second);
  319.             }
  320.  
  321.             bool operator >(const vector<T>& second) const {
  322.                 std::size_t less_size = std::min(size_, second.size_);
  323.                 for (int i = 0; i < less_size; i++) {
  324.                     if (*(reinterpret_cast<T*>(buffer_) + i) !=
  325.                         *(reinterpret_cast<T*>(second.buffer_) + i)) {
  326.                         return *(reinterpret_cast<T*>(buffer_) + i) >
  327.                                *(reinterpret_cast<T*>(second.buffer_) + i);
  328.                     }
  329.                 }
  330.                 return size_ > second.size_;
  331.             }
  332.  
  333.             bool operator >=(const vector<T>& second) const {
  334.                 std::size_t less_size = std::min(size_, second.size_);
  335.                 for (int i = 0; i < less_size; i++) {
  336.                     if (*(reinterpret_cast<T*>(buffer_) + i) !=
  337.                         *(reinterpret_cast<T*>(second.buffer_) + i)) {
  338.                         return *(reinterpret_cast<T*>(buffer_) + i) >
  339.                                *(reinterpret_cast<T*>(second.buffer_) + i);
  340.                     }
  341.                 }
  342.                 return size_ >= second.size_;
  343.             }        
  344.     };
  345. }
  346.  
  347. int main() {
  348.     my_vector::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
  349.     my_vector::vector<int> m = {100, 100, 500, 500, 100, 100};
  350.     v.insert(0, m.begin(), m.begin() + 3);
  351.     v.insert(5, m.begin(), m.begin() + 3);
  352.     for (int i : v) {
  353.         std::cout << i << ' ';
  354.     }
  355.     std::cout << '\n';
  356.     std::cout << v.size() << '\n';
  357.    
  358. }
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