string类

一.auto与范围for

1.用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2.当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

3.auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

4.auto不能直接用来声明数组
 

二.string中的函数

1.构造函数

string str：生成空字符串；

string s(str)：生成字符串为str拷贝复制；

string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值；

string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值；

string s(num ,c)：生成num个c字符的字符串；

string s(str, stridx)：将字符串str中从下标stridx开始到字符串结束的位置作为字符串初值；

2.字符串比较的符号重载

 bool operator<(const string& s1,const  string& s2)
 {
     return (strcmp(s1.c_str(),s2.c_str())<0);
 }
 bool operator<=(const string& s1, const string& s2)
 {
     return (strcmp(s1.c_str(), s2.c_str())<= 0);
 }
 bool operator>(const string& s1, const string& s2)
 {
     return (strcmp(s1.c_str(), s2.c_str()) > 0);
 }
 bool operator>=(const string& s1, const string& s2)
 {
     return (strcmp(s1.c_str(), s2.c_str()) >= 0);
 }
 bool operator==(const string& s1, const string& s2)
 {
     return (strcmp(s1.c_str(), s2.c_str()) == 0);

 }
 bool operator!=(const string& s1, const string& s2)
 {
     return !(strcmp(s1.c_str(), s2.c_str()) == 0);
 }

三.string插入push_back() 和 insert()

   void string:: insert(size_t pos, char ch)
   {
       reserve(_capacity + 1);
       for (size_t end =_size; end >=pos; end--)
       {
           _str[end + 1] = _str[end];
       }
       _str[pos] = ch;
       _size++;
   
   }
   void string::insert(size_t pos, const char* str)
   {
       reserve(_capacity + strlen(str));
       for (size_t end = _size; end >= pos; end--)
       {
           _str[end + strlen(str)] = _str[end];
       }
       for (size_t i = 0; i < strlen(str); i++)
       {
           _str[pos+i] = str[i];
       }
       _size += strlen(str);
   }
    void string:: push_back(char ch)
    {
        if (_capacity == _size)
        {
            reserve(_capacity == 0 ? 4 : 2 * _capacity);
        }
        _str[_size] = ch;
        _size++;
        _str[_size] = '\0';
    }

四.erase

   void string:: erase(size_t pos, size_t len)
   {
       assert(pos < _size);
       if (len + pos > _size)
       {
           _str[pos] = '\0';
           _size = pos;
       }
       else
       {
           
           for (size_t s=pos;s<=_size-len;s++)
           {
               _str[s] = _str[s + len];
           }
           _size -= len;
           
       }

五.find

   size_t string::find(char ch, size_t pos)
   {
       assert(pos < _size);
       for (size_t i = pos; i < _size; i++)
       {
           if (_str[i] == ch)
           {
               return i;
           }
       }
       return -1;
   }
   size_t  string:: find(const char* str, size_t pos )
   {
       assert(pos < _size);
       const char* pst = strstr(_str +pos, str);
       if (pst == nullptr)
           return -1;
       return pst - _str;
   }