简单的vector--- 2

如何重载operator[]   及其相关细节

如何使用 const_cast<>(  )  和 static_cast<>( )

模板类 如何内部声明，外部定义友元函数

使用memset( )、memcpy_s( )

使用sizeof( )

禁用移动构造 和 移动赋值

 #pragma once
 #include <iostream>
 using std::ostream;
 using std::cout;
 using std::endl;

 template <class T>
 class vector
 {
 public:
     explicit vector(int size);
     vector(const vector<T>& v);
     vector(vector<T>&&) = delete;
     vector(int size, T vlaue);
     vector(T* es, int len);
     vector& operator=(const vector<T>& v);
     vector& operator=(vector<T>&&) = delete;

     int size() const;
     int capacity() const;
     void reserve(int min_capacity);
     void push_back(T e);
     void pop_back();
     void erase(int pos);
     void insert(T e, int pos);

     const T& operator[](int) const;
     T& operator[](int);
     template <class Ty>
     friend ostream& operator<<(ostream& os, const vector<Ty>& v);
 private:
     T* vec;
     int _size;
     int _capacity;
 };

 template <class T>
 inline ostream& operator<<(ostream& os, const vector<T>& v)
 {
     os << endl << "输出： " << endl;
     for (int i = ; i < v._size; i++)
     {
         os << v.vec[i] << "  ";
     }
     return os;
 }

 template <class T>
 inline vector<T>::vector(int size) : _size(size)
 {
     _capacity = size + size / ;
     this->vec = new T[_capacity];
     memset(this->vec, 0x00, sizeof(T) * _capacity);
 }

 template <class T>
 inline vector<T>::vector(int size, T vlaue)
 {
     this->_capacity = size + size / ;
     this->_size = size;
     this->vec = new T[_capacity];
     for (int i = ; i < _size; i++)
     {
         this->vec[i] = vlaue;
     }
 }

 template <class T>
 inline vector<T>::vector(T* es, int len)
 {
     this->_size = len;
     this->_capacity = len + len / ;
     this->vec = new T[_capacity];
     memcpy_s(this->vec, len * sizeof(T), es, len * sizeof(T));
 }

 template <class T>
 inline vector<T>::vector(const vector& v)
 {
     this->_capacity = v._capacity;
     this->_size = v._size;
     this->vec = new T[_capacity];
     memcpy_s(this->vec, sizeof(T) * _capacity, v.vec, sizeof(T) * _capacity);
 }

 template <class T>
 inline int vector<T>::size() const
 {
     return this->_size;
 }

 template <class T>
 inline int vector<T>::capacity() const
 {
     return this->_capacity;
 }

 template <class T>
 inline vector<T>& vector<T>::operator=(const vector<T>& v)
 {
     if (this == &v)return *this;
     if (this->vec != nullptr)delete[] this->vec;
     this->_capacity = v._capacity;
     this->_size = v._size;
     this->vec = new T[_capacity];
     memcpy_s(this->vec, _capacity * sizeof(T), v.vec, v._capacity * sizeof(T));
     return *this;
 }

 template <class T>
 inline void vector<T>::reserve(const int min_capacity)
 {
     if (min_capacity < this->_capacity) return;
     else
     {
         int* n_vec = new T[min_capacity];
         for (int i = ; i < _size; i++)
         {
             n_vec[i] = vec[i];
         }
         delete[] vec;
         this->vec = n_vec;
         this->_capacity = min_capacity;
     }
 }

 template <class T>
 inline void vector<T>::push_back(T e)
 {
     if (this->_size >= this->_capacity)
     {
         this->reserve(this->_size + this->_size / );
     }
     this->vec[_size++] = e;
 }

 template <class T>
 inline void vector<T>::pop_back()
 {
     if (this->_size != )
         this->_size -= ;
 }

 template <class T>
 inline void vector<T>::erase(int pos)
 {
     if (pos <  || pos >= _size)return;
     else
     {
         for (int i = pos; i < _size - ; i++)
         {
             this->vec[i] = this->vec[i + ];
         }
         _size -= ;
     }
 }

 template <class T>
 inline void vector<T>::insert(T e, int pos)
 {
     if (pos <  || pos > _size - )return;
     if (this->_size >= this->_capacity)
     {
         this->reserve(this->_size + this->_size / );
     }
     for (int i = _size; i > pos; i++)
     {
         this->vec[i] = this->vec[i - ];
     }
     this->vec[pos] = e;
 }

 template <class T>
 inline const T& vector<T>::operator[](int i) const
 {
     if (i <  || i >= this->_size)
     {
         cout << "下标 i=" << i << " 越界 退出";
         exit();
     };
     return this->vec[i];
 }

 template <class T>
 T& vector<T>::operator[](int pos)
 {
     // 这个写法的意思是 将指针this 转成 const 型指针 再对其*解引
     //return const_cast<T&>((*static_cast<const vector<T>*>(this))[pos]);

     //这个是先对this 指针解引  再转成const 而且&直接引用该对象
     return const_cast<T&>(static_cast<const vector<T>&>(*this)[pos]);

     //这个写法不不可取；先对this指针 解引，再转成const时 并不是&，所以会重新创建一个新对象
     //return const_cast<T&>(static_cast<const vector<T>>(*this)[pos]);
 }