143.vector模板库

• myvector.h

   #pragma once
   #include <initializer_list>
   #include <iostream>
   using namespace std;
  
   template<class T>
   class myvector
   {
   public:
       myvector();
       myvector(int n);
       myvector(initializer_list<T> my);
       void show() const;
       ~myvector();
       //用于迭代
       T *begin();
       T *end();
       int arraysize();
       int memsize();
       //后插
       void push_back(T data);
       //前插
       void push_front(T data);
       //返回的是副本
       T operator[](int i) const;
       //返回的不是副本
       T &operator[](int i);
       //发现左值
       T* find(T &t);
       //发现右值
       T* find(T &&t);
       //改变一个值,传递的是右值
       void change(T *pos, T &&t);
       //改变一个值,传递的是左值
       void change(T *pos, T &t);
       void del(T &t);
       void del(T &&t);
       //找到的位置之前插入
       void insert(T &t, T &newt);
       void insert(T &&t, T &&newt);
  
       template<class T>
       friend ostream& operator <<(ostream &out, myvector<T> &myv);
   public:
       T * p;
       int memn;//内存长度
       int realn;//数组长度
   };

• myvector.cpp

   #include "myvector.h"
  
   template<class T>
   myvector<T>::myvector():p(nullptr),memn(),realn()
   {
  
   }
  
   template<class T>
   myvector<T>::myvector(int n)
   {
       this->memn = this->realn = n;
       this->p = new T[n];
       memset(this->p, , sizeof(T)*n);
   }
  
   template<class T>
   myvector<T>::myvector(initializer_list<T> my)
   {
       this->realn = this->memn = my.size();
       this->p = new T[my.size()];
       int id = ;
       //初始化
       for (auto i : my)
       {
           this->p[id] = i;
           id++;
       }
   }
  
   template<class T>
   void myvector<T>::show() const
   {
       for (int i = ; i < realn; i++)
       {
           cout << p[i];
       }
   }
  
   template<class T>
   myvector<T>::~myvector()
   {
       if (p != nullptr)
       {
           delete[] this->p;
       }
   }
  
   template<class T>
   T * myvector<T>::begin()
   {
       return this->p;
   }
  
   template<class T>
   T * myvector<T>::end()
   {
       return this->p + this->realn;
   }
  
   template<class T>
   int myvector<T>::arraysize()
   {
       return this->realn;
   }
  
   template<class T>
   int myvector<T>::memsize()
   {
       return this->memn;
   }
  
   template<class T>
   void myvector<T>::push_back(T data)
   {
       if (this->p == nullptr || this->memn == )
       {
               p = new T;
               *p = data;
               memn = ;
               realn = ;
       }
       else if(memn == realn)
       {
           T *ptemp = new T[this->memn + ];
           memcpy(ptemp, this->p, this->realn * sizeof(T));
           *(ptemp + realn) = data;
           delete[] this->p;
           this->p = ptemp;
           realn += ;
           memn += ;
       }
       else
       {
           p[realn] = data;
           realn++;
       }
   }
  
   template<class T>
   void myvector<T>::push_front(T  data)
   {
       if (this->p == nullptr || this->memn == )
       {
           p = new T;
           *p = data;
           memn = ;
           realn = ;
       }
       else if (memn == realn)
       {
           T *ptemp = new T[this->memn + ];
           memcpy(ptemp + , this->p, this->realn * sizeof(T));
           *ptemp = data;
           delete[] this->p;
           this->p = ptemp;
           realn += ;
           memn += ;
       }
       else
       {
           for (int i = ; i < realn; i++)
           {
               p[i + ] = p[i];
           }
           p[] = data;
           realn += ;
       }
   }
  
   template<class T>
   T myvector<T>::operator[](int i) const
   {
       if (i > realn)
       {
           throw ;
       }
       return this->p[i];
   }
  
   template<class T>
   T & myvector<T>::operator[](int i)
   {
       if (i > realn)
       {
           throw ;
       }
       return this->p[i];
   }
  
   template<class T>
   T * myvector<T>::find(T & t)
   {
       for (auto ib = this->begin(); ib != this->end(); ib++)
       {
           if (*it == t)
           {
               return ib;
           }
       }
   }
  
   template<class T>
   T * myvector<T>::find(T && t)
   {
       for (auto ib = this->begin(); ib != this->end(); ib++)
       {
           if (*it == t)
           {
               return ib;
           }
       }
   }
  
   template<class T>
   void myvector<T>::change(T * pos, T && t)
   {
       if (pos != nullptr)
       {
           *pos = t;
       }
   }
  
   template<class T>
   void myvector<T>::change(T * pos, T & t)
   {
       if (pos != nullptr)
       {
           *pos = t;
       }
   }
  
   template<class T>
   void myvector<T>::del(T & t)
   {
       int pos = -;
       for (int i = ; i < this->realn; i++)
       {
           if (t == *(this->p + i))
           {
               pos = i;
               break;
           }
       }
       if (pos != -)
       {
           if (pos == this->realn)
           {
               this->realn -= ;
           }
           else
           {
               for (int i = pos; i < realn-; i++)
               {
                   p[i] = p[i + ];
               }
               realn -= ;
           }
       }
   }
  
   template<class T>
   void myvector<T>::del(T && t)
   {
       int pos = -;
       for (int i = ; i < this->realn; i++)
       {
           if (t == *(this->p + i))
           {
               pos = i;
               break;
           }
       }
       if (pos != -)
       {
           if (pos == this->realn)
           {
               this->realn -= ;
           }
           else
           {
               for (int i = pos; i < realn - ; i++)
               {
                   p[i] = p[i + ];
               }
               realn -= ;
           }
       }
   }
  
   template<class T>
   void myvector<T>::insert(T & t, T & newt)
   {
       int pos = -;
       for (int i = ; i < this->realn; i++)
       {
           if (t == *(this->p + i))
           {
               pos = i;
               break;
           }
       }
  
       if (pos != -)
       {
           if (this->realn == this->memn)
           {
                   T *ptemp = new T[this->memn + ];
                   memcpy(ptemp, this->p, sizeof(T)*memn);
  
                   delete[] this->p;
                   this->p = ptemp;
                   this->realn += ;
                   this->memn += ;
                   for (int i = realn - ; i >= pos; i--)
                   {
                       p[i + ] = p[i];
                   }
                   p[pos] = newt;
           }
           else
           {
               for (int i = realn - ; i >= pos; i--)
               {
                   p[i + ] = p[i];
               }
               p[pos] = newt;
               this->realn += ;
           }
       }
  
   }
  
   template<class T>
   void myvector<T>::insert(T && t, T && newt)
   {
       int pos = -;
       for (int i = ; i < this->realn; i++)
       {
           if (t == *(this->p + i))
           {
               pos = i;
               break;
           }
       }
  
       if (pos != -)
       {
           if (this->realn == this->memn)
           {
               T *ptemp = new T[this->memn + ];
               memcpy(ptemp, this->p, sizeof(T)*memn);
  
               delete[] this->p;
               this->p = ptemp;
               this->realn += ;
               this->memn += ;
               for (int i = realn - ; i >= pos; i--)
               {
                   p[i + ] = p[i];
               }
               p[pos] = newt;
           }
           else
           {
               for (int i = realn - ; i >= pos; i--)
               {
                   p[i + ] = p[i];
               }
               p[pos] = newt;
               this->realn += ;
           }
       }
   }
  
   template<class T>
   ostream & operator<<(ostream & out, myvector<T> & myv)
   {
       for (int i = ; i < myv.realn; i++)
       {
           out << myv.p[i];
       }
       return out;
   }

• main.cpp

   #include "myvector.h"
   #include "myvector.cpp"
  
   void main()
   {
       myvector<double> myv({ 1.1,2.2,3.3 });
       //myv.show();
       ////迭代器
       //for (auto i : myv)
       //{
       //    cout << i << endl;
       //}
       myv.push_front(4.4);
       myv.push_back(5.5);
       myv.insert(2.2, 8.8);
       myv.del(2.2);
       myv.push_back(2.2);
       myv.del(2.2);
       /*for (auto ib = myv.begin(), ie = myv.end(); ib != ie; ib++)
       {
           cout << *ib << endl;
       }*/
       //cout << myv[1] << endl;
       cout << myv << endl;
       myv.show();
       cin.get();
   }