一些函数的实现

memcpy
void* memcpy(const void* src,void* dst,size_t count){
   void* ret=dst;
   while(count--){
       *dst++=*src++
   }
   return ret;
}

memmove
void* memmove(const void* src,void* dst,size_t count){
     void* ret=dst;
     while(dst<srt||(src+count<dst)){
         while(count--)
          *dst++=*src++;
     }else{
          dst+=count-1;
          src+=count-1;
          while(count--){
             *dst--=*src--;
          }
     }
     return ret;
}

move
template<typename T>
typename remove_reference<T>::type&& (T&& t){
     return static_cast<typename remove_reference<T>::type&&>(t);
}

forward
template<typename T>
T&& forward(T&& t){
   return static_cast<T&&>(t);
}

emplace_back

class Student{
private:
   int age;
public:
  explicit Student(int age):age(age){}
};
void* ptr=malloc(sizeof(Student));
new (ptr)Student(100);

push_back
--传入参数
1.构造函数
2.移动构造
--插入左值
拷贝构造
--插入右值
1.移动构造

emplace_back
--传入参数
1.构造函数
--插入左值
拷贝构造
--插入右值
移动构造

智能指针
template<class T>
class smartPtr{
private:
   T* ptr;
   unsigned int* count;
public:
  smartPtr(T* p=nullptr){
     ptr=p;
     count=new unsigned int(0);
     ++(*count);
  }
  ~smartPtr(){
    --(*count);
    if((*count)==0){
        delete[] ptr;
        m_ptr=nullptr;
        delete[] count;
        count=nullptr;
     }
  }
  smartPtr(const smartPtr<T>& other){
       ptr=other.ptr;
       count=other.count;
       ++(*count);
  }
  /*
  smartPtr<T>& operator=(const smartPtr<T>& pther){
     ++(*other.count);
     --(*count);
     if(*count==0){
         delete[] ptr;
         m_ptr=nullptr;
         delete[] count;
         count=nullptr;
     }
      m_ptr=other,ptr;
      m_count=other.count;
      return *this;
  }
  */
  //copy ans swap写法
  smartPtr<T>& operator=(smartPtr<T> other) noexcept{
      other.swap(*this);
      return *this;
  }
  void swap(smartPtr<int>& other) noexcept{
      using std::swap;
      swap(ptr,other.ptr);
      ++*(other.count);
      swap(count,other.count);
  }

  T* get() const {
     return ptr;
  }
  T& operator*(){
    return *ptr;
  }
  operator bool() const{
     return ptr;
  }
};

String 
class String{
public:
  String(const char* cstr=nullptr){
    if(cstr){
       m_data=new char[strlen(cstr)+1];
       strcpy(m_data,cstr);
    }else{
       m_data=new char[1];
       *m_data='\0';
    }

  }
  String(const String& str){
     m_data=new char[strlen(str.m_data)+1];
     strcpy(m_data,str.m_data);

  }
  String& operator=(const String& str){
    if(this!=str){
         //保证异常安全性
         char* data=m_data;
         m_data=new char[strlen(str.m_data)+1];
         strcpy(m_data,str.m_data);
         delete[] data;
         return *this;
    }
  }
  ~String(){
   if(m_data){
     delete[] m_data;
   }
  }
  char* get_c_str() const{
     return m_data;
  }

private:
  char* m_data;
};