类string解析

原创作品，转载请注明来源：http://www.cnblogs.com/shrimp-can/p/5645248.html 

在涉及字符串的时候，我们可以定义字符数组或指针，其实还有一个类，专门是为字符串设计的，即类string，包含在头文件<string>中，在命名空间std中的，因此要用string类，需要使用命名空间std。

一、初始化、赋值所用

1.构造函数string()：用于初始化的时候。

string();	默认构造函数
string (const string& str);	拷贝构造函数
string (const string& str, size_t pos, size_t len = npos);	拷贝str的一部分，从pos处字符开始拷贝len长度
string (const char* s);	拷贝s所指向的字符串
string (const char* s, size_t n);	拷贝s所指向的字符串的前面n个字符
string (size_t n, char c);	用n个字符c填充字符串
template <class InputIterator> string (InputIterator first, InputIterator last);	拷贝返回[first, las)返回内的字符序列
string (initializer_list<char> il);	拷贝il里的每个字符(C++11)
string (string&& str) noexcept;	获取str里的内容（C++11）

  std::string s0 ("Initial string");
  std::string s1;
  std::string s2 (s0);
  std::string s3 (s0, 8, 3);
  std::string s4 ("A character sequence", 6);
  std::string s5 ("Another character sequence");
  std::string s6a (10, 'x');
  std::string s6b (10, 42);      // 42 is the ASCII code for '*'
  std::string s7 (s0.begin(), s0.begin()+7);
  std::cout << "s1: " << s1 << "
s2: " << s2 << "
s3: " << s3;
  std::cout << "
s4: " << s4 << "
s5: " << s5 << "
s6a: " << s6a;
  std::cout << "
s6b: " << s6b << "
s7: " << s7 << '
';

输出：

s1: 
s2: Initial string
s3: str
s4: A char
s5: Another character sequence
s6a: xxxxxxxxxx
s6b: **********
s7: Initial

2.=操作：string& operator= (const string& str);

              string& operator= (const char* s);

              string& operator= (char c);

              string& operator= (initializer_list<char> il);（C++11）

              string& operator= (string&& str) noexcept；（C++11）

赋值，返回this指针。

二、迭代器相关函数

1.begin：iterator begin() noexcept;

             const_iterator begin() const noexcept;

返回指向字符串第一个字符的迭代器

2.end：iterator end() noexcept;

           const_iterator end() const noexcept;

返回指向字符串最后一个字符再后面的一个字符的迭代器，通常与begin一起使用，遍历字符串中的每一个字符

3.rbegin：reverse_iterator rbegin() noexcept;

              const_reverse_iterator rbegin() const noexcept;

返回指向字符串最后一个字符的迭代器

4.rend：reverse_iterator rend() noexcept;

            const_reverse_iterator rend() const noexcept;

返回指向字符串第一个字符前面一个理论元素的迭代器，通常与rbegin一起使用，反向遍历字符串中的每一个字符

std::string str ("now step live...");
for (std::string::reverse_iterator rit=str.rbegin(); rit!=str.rend(); ++rit)
    std::cout << *rit;

输出：...evil pets won

5.cbegin：const_iterator cbegin() const noexcept;（C++11）

返回指向字符串第一个字符的迭代器，与begin差不多，但是不能更新内容

6.cend：const_iterator cend() const noexcept;（C++11）

返回指向字符串最后一个字符再后面的一个字符的迭代器，通常与cbegin一起使用，遍历字符串中的每一个字符。与end差不多，但是不能用于更新内容

7.crbegin：const_reverse_iterator crbegin() const noexcept;（C++11）

返回指向字符串最后一个字符的迭代器

8.crend：const_reverse_iterator crend() const noexcept;（C++11）

返回指向字符串第一个字符前面一个理论元素的迭代器，通常与crbegin一起使用，反向遍历字符串中的每一个字符

三、容量相关函数：

1.size：size_t size() const;

返回字符串的长度，即多少bytes

2.length：size_t length() const;

返回字符串的长度，即多少bytes，与size差不多

3.max_size：size_t max_size() const;

返回string可达到的最大长度

4.resize：void resize (size_t n);

             void resize (size_t n, char c);

将string的长度设为n个字符，若第二个参数也有，则将新增加的字符空间用字符c填充

5.capacity：size_t capacity() const;

返回当前分配给string的存储空间，多少bytes

6.reserve：void reserve (size_t n = 0)

请求string capacity，以可以容纳将改变string的长度到n字符。如果n比当前capacity大，则增加capacity到n个字符，否则不改变。

7.clear：void clear();

清除string中的内容，使之成为一个空string，长度为0字符

8.empty：bool empty() const;

返回string是否为空，即其长度是否为0，如果是返回true，否则返回false

9.shrink_to_fit：void shrink_to_fit();

请求string减小capacity来适应它的size。

四、元素访问函数：

1.[]操作：char& operator[] (size_t pos);

              const char& operator[] (size_t pos) const;

数组形式，返回位置pos处的字符

2.at：char& at (size_t pos);

        const char& at (size_t pos) const;

返回位置pos处的字符

3.back：char& back();

            const char& back() const;

返回string的最后一个字符的引用

4.front：char& front();

            const char& front() const;

返回string中的第一个字符的引用

五、修改相关的函数

1.+=操作：string& operator+= (const string& str);

                string& operator+= (const char* s);

                string& operator+= (char c);

                string& operator+= (initializer_list<char> il);（C++11）

将字符串或字符添加到string末尾。

2.append：string& append (const string& str);

                  string& append (const string& str, size_t subpos, size_t sublen);

                  string& append (const char* s);

                  string& append (const char* s, size_t n);

                  string& append (size_t n, char c);

                  template <class InputIterator>      string& append (InputIterator first, InputIterator last);

                  string& append (initializer_list<char> il);（C++11）

在string末尾添加字符串或字符

3.push_back：void push_back (char c);

增加一个字符c在string末尾

4.assign：string& assign (const string& str);

              string& assign (const string& str, size_t subpos, size_t sublen);

              string& assign (const char* s);

              string& assign (const char* s, size_t n);

              string& assign (size_t n, char c);

              template <class InputIterator>          string& assign (InputIterator first, InputIterator last);（C++11）

              string& assign (initializer_list<char> il);（C++11）

              string& assign (string&& str) noexcept;（C++11）

用新的字符串替换当前string内容

5.insert：string& insert (size_t pos, const string& str);

              string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);

              string& insert (size_t pos, const char* s);

              string& insert (size_t pos, const char* s, size_t n);

              string& insert (size_t pos, size_t n, char c);

              void insert (iterator p, size_t n, char c);

              iterator insert (const_iterator p, size_t n, char c);（C++11）

              iterator insert (const_iterator p, char c);

              template <class InputIterator>          iterator insert (iterator p, InputIterator first, InputIterator last);（C++11）

              template <class InputIterator>          void insert (iterator p, InputIterator first, InputIterator last);

             string& insert (const_iterator p, initializer_list<char> il);（C++11）

             string& insert (string&& str) noexcept;（C++11）

在位置pos或p处插入字符串

6.erase：string& erase (size_t pos = 0, size_t len = npos);

             iterator erase (iterator p);

             iterator erase (iterator first, iterator last);

擦除字符或字符串，减小长度。

7.replace：string& replace (size_t pos, size_t len, const string& str);

                string& replace (iterator i1, iterator i2, const string& str);

                string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);

                string& replace (size_t pos, size_t len, const char* s);

                string& replace (iterator i1, iterator i2, const char* s);

                string& replace (size_t pos, size_t len, const char* s, size_t n);

                string& replace (iterator i1, iterator i2, const char* s, size_t n);

                string& replace (size_t pos, size_t len, size_t n, char c);

                string& replace (iterator i1, iterator i2, size_t n, char c);

                template <class InputIterator>      string& replace (iterator i1, iterator i2, InputIterator first, InputIterator last);

                string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il);（C++11）

8.swap：void swap (string& str);

交换两个string里面的内容

9.pop_back：void pop_back();

清除string中最后一个元素

六、string操作：

1.c_str：const char* c_str() const;

返回指向string内容的指针

  std::string str ("Please split this sentence into tokens");
  char * cstr = new char [str.length()+1];
  std::strcpy (cstr, str.c_str());
  char * p = std::strtok (cstr," ");
  while (p!=0)
  {
    std::cout << p << '
';
    p = std::strtok(NULL," ");
  }
  delete[] cstr;

输出：

Please
split
this
sentence
into
tokens

2.data：const char* data() const;

返回指向string内容的指针，与c_str()函数作用差不多

3.get_allocator：allocator_type get_allocator() const;

返回一个string相关的分配器的拷贝

4.copy：size_t copy (char* s, size_t len, size_t pos = 0) const;

拷贝string中pos位置开始的len个字符到s指向的数组中

5.find：size_t find (const string& str, size_t pos = 0) const;

           size_t find (const char* s, size_t pos = 0) const;

           size_t find (const char* s, size_t pos, size_t n) const;

           size_t find (char c, size_t pos = 0) const;

从pos处开始搜索字符或子串，返回第一次匹配的位置，如果搜索不到，返回string::npos

6.rfind：size_t rfind (const string& str, size_t pos = npos) const;

            size_t rfind (const char* s, size_t pos = npos) const;

            size_t rfind (const char* s, size_t pos, size_t n) const;

            size_t rfind (char c, size_t pos = npos) const;

在pos处前面搜索字符或子串，返回最后一次匹配的第一个字符的位置，如果搜索不到，返回string::npos

7.find_first_of：用法与find()用法相同

从pos处开始搜索参数字符或子串中的任意字符，返回第一次匹配的位置，如果搜索不到，返回string::npos

8.find_last_of：用法与rfind()用法相同

在pos处前面搜索参数字符或子串中的任意字符，返回最后一次匹配的字符的位置，如果搜索不到，返回string::npos

9.find_first_not_of：用法与find()相同

从pos处开始搜索与参数字符或子串中的任意字符都不匹配的字符，返回第一个不匹配的字符的位置，如果都匹配，返回string::npos

10.find_last_not_of：用法与rfind()用法相同

在pos处前面搜索与参数字符或子串中的任意字符都不匹配的字符，返回最后一个不匹配的字符的位置，如果都匹配，返回string::npos

11.substr：string substr (size_t pos = 0, size_t len = npos) const;

返回pos处开始len个字符的子串

12.compare：int compare (const string& str) const;

                    int compare (size_t pos, size_t len, const string& str) const;

                    int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const; 

                    int compare (const char* s) const;

                    int compare (size_t pos, size_t len, const char* s) const;

                    int compare (size_t pos, size_t len, const char* s, size_t n) const;

比较两个字符串，如果相等返回0，如果第一个不匹配的字符比比较的小返回负数，否则返回正数

七、非成员函数，但是string对象经常用的

1.+操作

2.关系运算符

3.>>、<<

4.swap：void swap (string& x, string& y);

5.getline：istream& getline (istream& is, string& str);