对iterator,reverse_iterator,std::copy还有类里面的static函数有了些了解,果然看比不上写 template<typename T, size_t count> class CArray { public: typedef T value_type; typedef T* iterator; typedef const T* const_iterator; typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; typedef T& reference; typedef const T& const_reference; typedef size_t size_type; iterator begin() { return elems_;} const_iterator begin() const { return elems_; } iterator end() { return elems_ + size_ ; } const_iterator end() const { return elems_ + size_; } reverse_iterator rbegin() { return reverse_iterator(end());} const_reverse_iterator rbegin() const { return const_reverse_iterator(end()) ;} reverse_iterator rend() { return reverse_iterator<begin()>} const_reverse_iterator rend() const{ return const_reverse_iterator(begin());} reference operator[] (size_type i) { return elems_[i];} const_reference operator[] (size_type i) const { return elems_[i]; } reference front() { return elems_[0];} const_reference front() const { return elems_[0]; } reference back() { return elems_[size_-1];} const_reference back() const { return elems_[size_ - 1]; } size_type size() const { return size_;} bool empty() { return size_ == 0;} bool isfull() { retrurn size_ >= count;} //没有对象指针 static size_type max_size() { return count;} T* c_array() { return elems_; } iterator push_back(const T& x) { if (!isfull()) { elems_[size_++] = x; return elems_ + size_; } } // erase a element and move the back elemtes to front iterator erase(iterator pos) { iterator endPos = end(); if (pos != end) { iterator nextPos = pos + 1; if (nextPos != endPos) { std::copy(nextPos,endPos,pos); } --size_; } return pos; } void erase(size_type pos) { if (pos + 1 != size_) { std::copy(elems_ + pos + 1,elems_ + size_, elems_ + pos); } --size; } bool remove(const T& elem) { iterator pos = std::find(begin(),end(),elem); if (end() == pos) { return false; } erase(pos); return true; } bool has_elem(const T& elem) const { return end() != std::find(begin(),end(),elem); } iterator erase(iterator first, iterator last) { iterator __i(std::copy(last,end(),first); size_t -= (last - first); return first; } void clear() { size_ = 0; } void insert(iterator pos, const T& value) { if (size() == count) { return; } else { std::copy(pos,elems_ + size_,pos+1); *pos = value; ++size_; } } void reverse(size_t _size) { if (size_ < _size) { size_ = _size < count ? _size: count; } } void assign(size_t _n, const value_type& _val) { size_type capacity = n + size(); if (capacity > count) { capacity = count; } for (; size_ < capacity ; ++size_) { elems[size_t] = _val; } } template<typename InputIterator> void assign(InputIterator _first, InputIterator _last) { for (; _first != _last && size_ < count; ++ size_,++_first) { elems_[size_] = *_first; } } private: value_type elems_[count]; size_type size_; };