chromium源码阅读(3)-scoped_vector

古城微笑少年丶 2022-08-07 11:54 169阅读 0赞

相比原生的vecotr行为，scoped\_vector只是增加类在析构时delete其元素的行为。

5   // ScopedVector wraps a vector deleting the elements from its
    16  // destructor.
    17  template <class T>
    18  class ScopedVector {
    19    MOVE_ONLY_TYPE_FOR_CPP_03(ScopedVector, RValue)
    20  
    21   public:
    22    typedef typename std::vector<T*>::allocator_type allocator_type;
    23    typedef typename std::vector<T*>::size_type size_type;
    24    typedef typename std::vector<T*>::difference_type difference_type;
    25    typedef typename std::vector<T*>::pointer pointer;
    26    typedef typename std::vector<T*>::const_pointer const_pointer;
    27    typedef typename std::vector<T*>::reference reference;
    28    typedef typename std::vector<T*>::const_reference const_reference;
    29    typedef typename std::vector<T*>::value_type value_type;
    30    typedef typename std::vector<T*>::iterator iterator;
    31    typedef typename std::vector<T*>::const_iterator const_iterator;
    32    typedef typename std::vector<T*>::reverse_iterator reverse_iterator;
    33    typedef typename std::vector<T*>::const_reverse_iterator
    34        const_reverse_iterator;
    35  
    36    ScopedVector() {}
    37    ~ScopedVector() { clear(); }
    38    ScopedVector(RValue other) { swap(*other.object); }
    39  
    40    ScopedVector& operator=(RValue rhs) {
    41      swap(*rhs.object);
    42      return *this;
    43    }
    44  
    45    reference operator[](size_t index) { return v_[index]; }
    46    const_reference operator[](size_t index) const { return v_[index]; }
    47  
    48    bool empty() const { return v_.empty(); }
    49    size_t size() const { return v_.size(); }
    50  
    51    reverse_iterator rbegin() { return v_.rbegin(); }
    52    const_reverse_iterator rbegin() const { return v_.rbegin(); }
    53    reverse_iterator rend() { return v_.rend(); }
    54    const_reverse_iterator rend() const { return v_.rend(); }
    55  
    56    iterator begin() { return v_.begin(); }
    57    const_iterator begin() const { return v_.begin(); }
    58    iterator end() { return v_.end(); }
    59    const_iterator end() const { return v_.end(); }
    60  
    61    const_reference front() const { return v_.front(); }
    62    reference front() { return v_.front(); }
    63    const_reference back() const { return v_.back(); }
    64    reference back() { return v_.back(); }
    65  
    66    void push_back(T* elem) { v_.push_back(elem); }
    67  
    68    void pop_back() {
    69      DCHECK(!empty());
    70      delete v_.back();
    71      v_.pop_back();
    72    }
    73  
    74    std::vector<T*>& get() { return v_; }
    75    const std::vector<T*>& get() const { return v_; }
    76    void swap(std::vector<T*>& other) { v_.swap(other); }
    77    void swap(ScopedVector<T>& other) { v_.swap(other.v_); }
    78    void release(std::vector<T*>* out) {
    79      out->swap(v_);
    80      v_.clear();
    81    }
    82  
    83    void reserve(size_t capacity) { v_.reserve(capacity); }
    84  
    85    // Resize, deleting elements in the disappearing range if we are shrinking.
    86    void resize(size_t new_size) {
    87      if (v_.size() > new_size)
    88        STLDeleteContainerPointers(v_.begin() + new_size, v_.end());
    89      v_.resize(new_size);
    90    }
    91  
    92    template<typename InputIterator>
    93    void assign(InputIterator begin, InputIterator end) {
    94      v_.assign(begin, end);
    95    }
    96  
    97    void clear() { STLDeleteElements(&v_); }
    98  
    99    // Like |clear()|, but doesn't delete any elements.
    100   void weak_clear() { v_.clear(); }
    101 
    102   // Lets the ScopedVector take ownership of |x|.
    103   iterator insert(iterator position, T* x) {
    104     return v_.insert(position, x);
    105   }
    106 
    107   // Lets the ScopedVector take ownership of elements in [first,last).
    108   template<typename InputIterator>
    109   void insert(iterator position, InputIterator first, InputIterator last) {
    110     v_.insert(position, first, last);
    111   }
    112 
    113   iterator erase(iterator position) {
    114     delete *position;
    115     return v_.erase(position);
    116   }
    117 
    118   iterator erase(iterator first, iterator last) {
    119     STLDeleteContainerPointers(first, last);
    120     return v_.erase(first, last);
    121   }
    122 
    123   // Like |erase()|, but doesn't delete the element at |position|.
    124   iterator weak_erase(iterator position) {
    125     return v_.erase(position);
    126   }
    127 
    128   // Like |erase()|, but doesn't delete the elements in [first, last).
    129   iterator weak_erase(iterator first, iterator last) {
    130     return v_.erase(first, last);
    131   }
    132 
    133  private:
    134   std::vector<T*> v_;
    135 };