前言：

• std::string 是 C++ 标准库的一部分，但它不是 STL 容器的一部分。STL 容器是指那些基于模板的容器，如 std::vector、std::list 等。std::string 提供了类似于 STL 容器的功能，比如动态内存管理、迭代器支持等，但它的设计和实现是独立的。
• std::string 被归为 STL 是因为它具有类似于 STL 容器的特性和功能，尽管它在技术上并不属于 STL。这种归类更多是出于功能和使用上的相似性，而不是严格的分类。
• std::string 是 C++ 标准库中的一个类，它提供了一种方便的方式来创建、操作和处理字符串。

1. string的介绍

std::string 在 C++ 中是一个非常重要的概念，它代表了字符串（String）类型，用于处理文本数据。字符串是由字符（通常是字母、数字、标点符号等）组成的序列。在 C++ 中，std::string 是一个类，它封装了字符串的存储和操作，提供了一系列的成员函数和操作符重载来方便地进行字符串操作。

2. string类对象的常见构造

// string constructor
#include <iostream>
#include <string>int main ()
{std::string s0 ("Initial string");// constructors used in the same order as described above:std::string s1;std::string s2 (s0);std::string s3 (s0, 8, 3);std::string s4 ("A character sequence");std::string s5 ("Another character sequence", 12);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 << "\ns2: " << s2 << "\ns3: " << s3;std::cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6a: " << s6a;std::cout << "\ns6b: " << s6b << "\ns7: " << s7 << '\n';return 0;
}

1. std::string s1;：这是默认构造函数，创建了一个空的字符串对象s1。
2. std::string s2(s0);：这是复制构造函数，创建了一个新字符串对象s2，它是另一个字符串对象s0的副本。
3. std::string s3(s0, 8, 3);：这是带参数的构造函数，创建了一个新字符串对象s3，它从s0的第8个字符开始（注意C++中字符串索引从0开始），提取长度为3的子字符串。
4. std::string s4("A character sequence");：这是从C风格字符串构造函数，创建了一个新字符串对象s4，初始化为给定的C风格字符串。
5. std::string s5("Another character sequence", 12);：这是带长度参数的构造函数，创建了一个新字符串对象s5，初始化为给定的C风格字符串的前12个字符。
6. std::string s6a(10, 'x');：这是从字符和重复次数构造函数，创建了一个新字符串对象s6a，包含10个字符’x’。
7. std::string s6b(10, 42);：这也是从字符和重复次数构造函数，创建了一个新字符串对象s6b，包含10个字符，其ASCII码为42，对应字符’*'。
8. std::string s7(s0.begin(), s0.begin() + 7);：这是从迭代器范围构造函数，创建了一个新字符串对象s7，包含从s0的开始迭代器到第7个元素的子字符串。

3. string类对象的容量操作

// string::size
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");std::cout << "The size of str is " << str.size() << " bytes.\n";return 0;
}// string::length
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");std::cout << "The size of str is " << str.length() << " bytes.\n";return 0;
}// comparing size, length, capacity and max_size
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");std::cout << "size: " << str.size() << "\n";std::cout << "length: " << str.length() << "\n";std::cout << "capacity: " << str.capacity() << "\n";std::cout << "max_size: " << str.max_size() << "\n";return 0;
}// resizing string
#include <iostream>
#include <string>
int main ()
{std::string str ("I like to code in C");std::cout << str << '\n';unsigned sz = str.size();str.resize (sz+2,'+');std::cout << str << '\n';str.resize (14);std::cout << str << '\n';return 0;
}// string::reserve
#include <iostream>
#include <fstream>
#include <string>
int main ()
{std::string str;std::ifstream file ("test.txt",std::ios::in|std::ios::ate);if (file) {std::ifstream::streampos filesize = file.tellg();str.reserve(filesize);file.seekg(0);while (!file.eof()){str += file.get();}std::cout << str;}return 0;
}// string::clear
#include <iostream>
#include <string>
int main ()
{char c;std::string str;std::cout << "Please type some lines of text. Enter a dot (.) to finish:\n";do {c = std::cin.get();str += c;if (c=='\n'){std::cout << str;str.clear();}} while (c!='.');return 0;
}// string::empty
#include <iostream>
#include <string>
int main ()
{std::string content;std::string line;std::cout << "Please introduce a text. Enter an empty line to finish:\n";do {getline(std::cin,line);content += line + '\n';} while (!line.empty());std::cout << "The text you introduced was:\n" << content;return 0;
}// string::shrink_to_fit
#include <iostream>
#include <string>
int main ()
{std::string str (100,'x');std::cout << "1. capacity of str: " << str.capacity() << '\n';str.resize(10);std::cout << "2. capacity of str: " << str.capacity() << '\n';str.shrink_to_fit();std::cout << "3. capacity of str: " << str.capacity() << '\n';return 0;
}

1. size() 或 length()：这两个方法作用相同，都用来获取字符串当前的长度，也就是字符串中实际有多少个字符。
2. max_size()：这个方法返回字符串对象能够拥有的最大字符数。这通常取决于你的系统能够处理的内存大小。
3. resize()：这个方法用来改变字符串的长度。你可以指定一个新的长度，如果新长度比当前长度长，字符串会用额外的空格填充；如果新长度比当前长度短，字符串会被截断。
4. capacity()：这个方法返回当前为字符串分配的存储空间大小，也就是在不重新分配内存的情况下，字符串能够扩展到的最大长度。
5. reserve()：**这个方法用来请求改变字符串的容量。**你可以指定一个希望的容量大小，如果当前容量小于这个值，字符串会分配更多的内存以满足这个请求。如果当前容量已经足够，这个调用可能不会有任何效果。
6. clear()：这个方法用来清空字符串，使其长度变为0，但是分配的存储空间大小（容量）不会改变。
7. empty()：这个方法用来检查字符串是否为空。如果字符串长度为0，它会返回true，否则返回false。
8. shrink_to_fit()：**这个方法用来减少字符串的容量，使其与当前字符串的长度相匹配。**如果当前容量大于字符串的长度，这个方法可能会释放多余的内存。

4. string类对象的访问

// string::operator[]
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");for (int i=0; i<str.length(); ++i){std::cout << str[i];}return 0;
}// string::at
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");for (unsigned i=0; i<str.length(); ++i){std::cout << str.at(i);}return 0;
}// string::back
#include <iostream>
#include <string>
int main ()
{std::string str ("hello world.");str.back() = '!';std::cout << str << '\n';return 0;
}// string::front
#include <iostream>
#include <string>
int main ()
{std::string str ("test string");str.front() = 'T';std::cout << str << '\n';return 0;
}

1. operator[]：这是方括号操作符，它允许你通过索引来访问字符串中的任意字符。索引是从0开始的，所以如果你想访问字符串的第一个字符，你会使用string[0]。这个操作符允许你读取和修改字符。

2. at：这个方法也允许你通过索引来访问字符串中的字符，但它在访问时会进行边界检查。如果你尝试访问一个不存在的索引（比如一个大于或等于字符串长度的索引），它会抛出一个std::out_of_range异常。这使得at方法比operator[]更安全，但只能用于读取字符，不能用来修改字符。

3. back：这个方法让你访问字符串的最后一个字符。它相当于访问string[string.length() - 1]，但是更直观且易于理解。

4. front：这个方法让你访问字符串的第一个字符，相当于访问string[0]。

5. 迭代器

// string::begin/end
#include <iostream>
#include <string>
int main ()
{std::string str ("Test string");for ( std::string::iterator it=str.begin(); it!=str.end(); ++it)std::cout << *it;std::cout << '\n';return 0;
}// string::rbegin/rend
#include <iostream>
#include <string>
int main ()
{std::string str ("now step live...");for (std::string::reverse_iterator rit=str.rbegin(); rit!=str.rend(); ++rit)std::cout << *rit;return 0;
}// string::cbegin/cend
#include <iostream>
#include <string>
int main ()
{std::string str ("Lorem ipsum");for (auto it=str.cbegin(); it!=str.cend(); ++it)std::cout << *it;std::cout << '\n';return 0;
}// string::crbegin/crend
#include <iostream>
#include <string>int main ()
{std::string str ("lorem ipsum");for (auto rit=str.crbegin(); rit!=str.crend(); ++rit)std::cout << *rit;std::cout << '\n';return 0;
}

1. begin()：这个方法返回一个迭代器，指向字符串的第一个字符。你可以从这个点开始遍历字符串。

2. end()：这个方法返回一个迭代器，指向字符串最后一个字符之后的“位置”。这并不是字符串中的一个实际字符，而是一个表示字符串结束的标记。当你遍历到这个点时，就意味着你已经到达了字符串的末尾。

3. rbegin()：这个方法返回一个反向迭代器，指向字符串的最后一个字符。反向迭代器允许你从字符串的末尾开始向前遍历。

4. rend()：这个方法返回一个反向迭代器，指向字符串第一个字符之前的“位置”。这同样是一个表示反向遍历结束的标记。

5. cbegin()：这个方法与begin()类似，但它返回的是一个常量迭代器，意味着你不能通过这个迭代器修改字符串中的字符。

6. cend()：这个方法与end()类似，它也返回一个常量迭代器，指向字符串末尾之后的位置。

7. crbegin()：这个方法与rbegin()类似，返回一个常量反向迭代器，指向字符串的最后一个字符。

8. crend()：这个方法与rend()类似，返回一个常量反向迭代器，指向字符串第一个字符之前的位置。

6. string类对象的修改操作

1. operator+=：这个操作符允许你将另一个字符串或者单个字符追加到当前字符串的末尾。比如，如果有一个字符串 str，使用 str += "app"; 会将 "app" 追加到 str 的末尾。

  // string::operator+=#include <iostream>#include <string>int main (){std::string name ("John");std::string family ("Smith");name += " K. ";         // c-stringname += family;         // stringname += '\n';           // characterstd::cout << name;return 0;}//John K. Smith

2. append：这个方法用于将另一个字符串或者字符串的一部分追加到当前字符串的末尾。你可以指定要追加的字符串，以及可选的起始位置和长度。

   

  // appending to string#include <iostream>#include <string>int main (){std::string str;std::string str2="Writing ";std::string str3="print 10 and then 5 more";// used in the same order as described above:str.append(str2);                       // "Writing "str.append(str3,6,3);                   // "10 "str.append("dots are cool",5);          // "dots "str.append("here: ");                   // "here: "str.append(10u,'.');                    // ".........."str.append(str3.begin()+8,str3.end());  // " and then 5 more"str.append(5,0x2E);                // "....."std::cout << str << '\n';return 0;}//Writing 10 dots here: .......... and then 5 more.....

• str.append(str2); 将 str2 的内容 "Writing " 追加到 str 的末尾。

• str.append(str3,6,3); 从 str3 的第6个字符（“print” 的 ‘p’）开始，追加3个字符（"10 "）到 str 的末尾。
• str.append("dots are cool",5); 追加字符串 "dots "（“dots are cool” 的前5个字符）到 str 的末尾。
• str.append("here: "); 追加字符串 "here: " 到 str 的末尾。
• str.append(10u,'.'); 追加10个点字符（‘.’）到 str 的末尾。(这里的 u 表示 “unsigned”，即无符号的.u 后缀并不是必需的)
• str.append(str3.begin()+8,str3.end()); 从 str3 的第8个字符（“and then” 的 ‘a’）开始，追加到 str3 的末尾，即 " and then 5 more"。
• str.append(5,0x2E); 追加5个字符，字符的ASCII码为0x2E（即点字符 ‘.’）。

3. push_back：这个方法用于在字符串的末尾追加一个字符。这相当于在字符串的末尾“推入”一个字符。

 // string::push_back#include <iostream>#include <fstream>#include <string>int main (){std::string myString = "Hello";// 使用 push_back 在字符串末尾追加字符myString.push_back(' '); // 追加一个空格myString.push_back('W'); // 追加字符 'W'myString.push_back('o'); // 追加字符 'o'myString.push_back('r'); // 追加字符 'r'myString.push_back('l'); // 追加字符 'l'myString.push_back('d'); // 追加字符 'd'// 输出追加后的字符串std::cout << myString << std::endl; // 输出 "Hello World"return 0;}

4. assign：这个方法用于将新的内容赋值给字符串，这会替换掉字符串当前的内容。你可以指定一个新的字符串或者字符串的一部分来赋值。

   

 // string::assign#include <iostream>#include <string>int main (){std::string str;std::string base="The quick brown fox jumps over a lazy dog.";// used in the same order as described above:str.assign(base);std::cout << str << '\n';str.assign(base,10,9);std::cout << str << '\n';         // "brown fox"str.assign("pangrams are cool",7);std::cout << str << '\n';         // "pangram"str.assign("c-string");std::cout << str << '\n';         // "c-string"str.assign(10,'*');std::cout << str << '\n';         // "**********"str.assign(10,0x2D);std::cout << str << '\n';         // "----------"str.assign(base.begin()+16,base.end()-12);std::cout << str << '\n';         // "fox jumps over"return 0;}

• str.assign(base); 将 base 的全部内容赋值给 str。

• str.assign(base,10,9); 从 base 的第10个字符开始，赋值9个字符给 str，即 “brown fox”。

  当你指定起始位置和字符数量时，赋值操作是从起始位置索引之后的字符开始的，直到指定的字符数量结束。

• str.assign("pangrams are cool",7); 将字符串 “pangrams are cool” 的前7个字符赋值给 str，即 “pangram”。

• str.assign("c-string"); 将字符串 “c-string” 赋值给 str。

• str.assign(10,'*'); 赋值10个星号（‘*’）给 str。

• str.assign(10,0x2D); 赋值10个字符，字符的ASCII码为0x2D（即破折号 ‘-’）给 str。

• str.assign(base.begin()+16,base.end()-12); 从 base 的第16个字符开始，到结束前12个字符结束，赋值给 str，即 “fox jumps over”。

5. insert：这个方法用于在字符串的指定位置插入一个新的字符串或者字符。你可以指定插入的位置，以及要插入的字符串或字符。

   

  // inserting into a string#include <iostream>#include <string>int main (){std::string str="to be question";std::string str2="the ";std::string str3="or not to be";std::string::iterator it;// used in the same order as described above:str.insert(6,str2);                 // to be (the )questionstr.insert(6,str3,3,4);             // to be (not )the questionstr.insert(10,"that is cool",8);    // to be not (that is )the questionstr.insert(10,"to be ");            // to be not (to be )that is the questionstr.insert(15,1,':');               // to be not to be(:) that is the questionit = str.insert(str.begin()+5,','); // to be(,) not to be: that is the questionstr.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)str.insert (it+2,str3.begin(),str3.begin()+3); // (or )std::cout << str << '\n';return 0;}

• str.insert(6, str2); 在 str 的第 7 个位置（索引 6）插入 str2 的内容 "the "，结果是 “to be the question”。
• str.insert(6, str3, 3, 4); 从 str3 的第 4 个字符（"not "）开始，插入 4 个字符到 str 的第 7 个位置，结果是 “to be not the question”。
• str.insert(10, "that is cool", 8); 插入字符串 "that is "（“that is cool” 的前 8 个字符）到 str 的第 11 个位置，结果是 “to be not that is the question”。
• str.insert(10, "to be "); 插入字符串 "to be " 到 str 的第 11 个位置，结果是 “to be not to be that is the question”。
• str.insert(15, 1, ':'); 在 str 的第 16 个位置插入 1 个冒号字符 ‘:’，结果是 “to be not to be: that is the question”。
• it = str.insert(str.begin()+5, ','); 在 str 的第 6 个位置插入一个逗号 ‘,’，并将迭代器 it 设置为插入位置的下一个位置，结果是 “to be, not to be: that is the question”。
• str.insert(str.end(), 3, '.'); 在 str 的末尾插入 3 个点字符 ‘.’，结果是 “to be, not to be: that is the question…”。
• str.insert(it+2, str3.begin(), str3.begin()+3); 在迭代器 it+2 指向的位置（即 ‘e’ 后面）插入 str3 的前 3 个字符 "or "，结果是 “to be, not to be: that is the question…(or )”。

6. erase：这个方法用于删除字符串中的一部分。你可以指定要删除的起始位置和长度，或者只删除一个字符。

 // string::erase#include <iostream>#include <string>int main (){std::string str ("This is an example sentence.");std::cout << str << '\n';// "This is an example sentence."str.erase (10,8);                        //            ^^^^^^^^std::cout << str << '\n';// "This is an sentence."str.erase (str.begin()+9);               //           ^std::cout << str << '\n';// "This is a sentence."str.erase (str.begin()+5, str.end()-9);  //       ^^^^^std::cout << str << '\n';// "This sentence."return 0;}

7. replace：这个方法用于替换字符串中的一部分。你可以指定要替换的起始位置、长度，以及新的字符串来替换旧的部分。

  // 在字符串中替换#include <iostream>#include <string>int main (){std::string base="this is a test string.";std::string str2="n example";std::string str3="sample phrase";std::string str4="useful.";// replace signatures used in the same order as described above:std::string str=base;           // "this is a test string."str.replace(9,5,str2);          // "this is an example string." (1)str.replace(19,6,str3,7,6);     // "this is an example phrase." (2)str.replace(8,10,"just a");     // "this is just a phrase."     (3)str.replace(8,6,"a shorty",7);  // "this is a short phrase."    (4)str.replace(22,1,3,'!');        // "this is a short phrase!!!"  (5)str.replace(str.begin(),str.end()-3,str3);                    // "sample phrase!!!"      (1)str.replace(str.begin(),str.begin()+6,"replace");             // "replace phrase!!!"     (3)str.replace(str.begin()+8,str.begin()+14,"is coolness",7);    // "replace is cool!!!"    (4)str.replace(str.begin()+12,str.end()-4,4,'o');                // "replace is cooool!!!"  (5)str.replace(str.begin()+11,str.end(),str4.begin(),str4.end());// "replace is useful."    (6)std::cout << str << '\n';return 0;}

8. swap：这个方法用于交换两个字符串的内容。你可以传递另一个字符串对象，两个字符串的内容会互相交换。

  // swap strings#include <iostream>#include <string>int main (){std::string buyer ("money");std::string seller ("goods");seller.swap (buyer);std::cout << " After the swap, buyer has " << buyer;std::cout << " and seller has " << seller << '\n';return 0;}

9. pop_back：这个方法用于删除字符串的最后一个字符。这相当于从字符串的末尾“弹出”一个字符。

  // string::pop_back#include <iostream>#include <string>int main (){std::string str ("hello world!");str.pop_back();std::cout << str << '\n';return 0;}

7. string类对象的字符串运算

1. c_str()：这个方法返回一个指向字符串的 C 风格字符串（即字符数组）的指针。这允许你将 std::string 对象用于需要 C 风格字符串的函数中。

2. data()：这个方法也返回一个指向字符串数据的指针，与 c_str() 类似，但它不会在字符串末尾添加空字符（‘\0’），这在某些情况下可能更有用。

3. get_allocator()：这个方法返回一个分配器对象，用于管理字符串的内存分配。这在需要自定义内存管理时很有用。

4. copy()：这个方法用于将字符串中的字符复制到一个字符数组中。你可以指定复制的起始位置、复制的字符数以及目标数组的起始位置。

5. find()：这个方法用于在字符串中查找子串。它返回第一次出现的子串在字符串中的起始位置，如果找不到则返回 std::string::npos。

   // string::find#include <iostream>       // std::cout#include <string>         // std::stringint main (){std::string str ("There are two needles in this haystack with needles.");std::string str2 ("needle");std::size_t found = str.find(str2);if (found!=std::string::npos)std::cout << "first 'needle' found at: " << found << '\n';return 0;}

6. rfind()：这个方法与 find() 类似，但它从字符串的末尾开始查找，返回最后一次出现的子串的起始位置，如果找不到同样返回 `std::string::npos。

 // string::rfind#include <iostream>#include <string>#include <cstddef>int main (){std::string str ("The sixth sick sheik's sixth sheep's sick.");std::string key ("sixth");std::size_t found = str.rfind(key);if (found!=std::string::npos)str.replace (found,key.length(),"seventh");std::cout << str << '\n';return 0;}

7. find_first_of()：这个方法用于查找字符串中第一次出现的任何指定字符。你可以传递一个字符或者字符集合，返回找到的第一个字符的位置。

 // string::find_first_of#include <iostream>       // std::cout#include <string>         // std::string#include <cstddef>        // std::size_tint main (){std::string str ("Please, replace the vowels in this sentence by asterisks.");std::size_t found = str.find_first_of("aeiou");//搜索字符串中第一次出现的所有元音字母（a, e, i, o, u）中的任意一个。while (found!=std::string::npos){str[found]='*';found=str.find_first_of("aeiou",found+1);}std::cout << str << '\n';return 0;}

8. find_last_of()：这个方法与 find_first_of() 类似，但它从字符串的末尾开始查找，返回最后一次出现的指定字符的位置。

9. find_first_not_of()：这个方法用于查找字符串中第一个不包含在指定字符集合中的字符。返回找到的第一个字符的位置。

10. find_last_not_of()：这个方法与 find_first_not_of() 类似，但它从字符串的末尾开始查找，返回最后一个不包含在指定字符集合中的字符的位置。

11. substr()：这个方法用于生成字符串的一个子串。你可以指定子串的起始位置和长度。

  // string::substr#include <iostream>#include <string>int main (){std::string str="We think in generalities, but we live in details.";std::string str2 = str.substr (3,5);     // "think"std::size_t pos = str.find("live");      // position of "live" in strstd::string str3 = str.substr (pos);     // get from "live" to the endstd::cout << str2 << ' ' << str3 << '\n';return 0;}

12. compare()：这个方法用于比较两个字符串。它返回一个整数，如果字符串相等则返回 0，如果第一个字符串小于第二个则返回负数，如果大于则返回正数。

 #include <iostream>#include <string>int main() {std::string str1 = "Hello";std::string str2 = "World";// 比较两个完整的字符串int result = str1.compare(str2);if (result < 0) {std::cout << "str1 is less than str2" << std::endl;} else if (result > 0) {std::cout << "str1 is greater than str2" << std::endl;} else {std::cout << "str1 is equal to str2" << std::endl;}return 0;}

8.string类成员函数

在 C++ 的 std::string 类中，成员函数是类的一部分，用于执行与类相关的操作。下面是这些成员函数的通俗解释：

1. 构造函数 (constructor)：这是创建 std::string 对象时自动调用的函数。它用于初始化新创建的字符串对象。std::string 提供了多种构造函数，允许你通过不同的方式初始化字符串，比如从空字符串、C 风格字符串、另一个 std::string 对象，或者指定数量的字符开始。

2. 析构函数 (destructor)：这是当 std::string 对象不再被使用，即将被销毁时自动调用的函数。它用于释放字符串对象占用的资源。在 std::string 的情况下，析构函数会释放存储字符串数据的内存。

3. 赋值操作符 (operator=)：这是一个特殊的成员函数，用于将一个字符串对象的内容赋值给另一个字符串对象。它允许你将一个字符串复制到另一个字符串，或者改变一个字符串对象的内容，使其与另一个字符串相同。

 // 字符串赋值#include <iostream>#include <string>int main (){std::string str1, str2, str3;str1 = "Test string: ";   // c-stringstr2 = 'x';               // single characterstr3 = str1 + str2;       // stringstd::cout << str3  << '\n';return 0;}

9.string类非成员函数

1. operator+：这个函数用于连接两个字符串。你可以使用 + 操作符将两个字符串放在一起，形成一个新的字符串。例如，str1 + str2 会创建一个包含 str1 和 str2 内容的新字符串。

 // 连接字符串#include <iostream>#include <string>int main (){std::string firstlevel ("com");std::string secondlevel ("cplusplus");std::string scheme ("http://");std::string hostname;std::string url;hostname = "www." + secondlevel + '.' + firstlevel;url = scheme + hostname;std::cout << url << '\n';return 0;}

2. relational operators：这些是比较运算符，用于比较两个字符串。包括 ==（等于）、!=（不等于）、<（小于）、>（大于）、<=（小于等于）和 >=（大于等于）。它们按照字典顺序比较字符串。

  // 字符串比较 #include <iostream>#include <vector>int main (){std::string foo = "alpha";std::string bar = "beta";if (foo==bar) std::cout << "foo and bar are equal\n";if (foo!=bar) std::cout << "foo and bar are not equal\n";if (foo< bar) std::cout << "foo is less than bar\n";if (foo> bar) std::cout << "foo is greater than bar\n";if (foo<=bar) std::cout << "foo is less than or equal to bar\n";if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";return 0;}

3. swap：这个函数用于交换两个字符串的内容。它直接交换两个字符串对象内部的数据，而不是交换对象本身。

4. operator>>：这个函数用于从输入流（如 std::cin）中提取字符串。它读取输入流中的字符，直到遇到空格、换行或其他分隔符，并将这些字符存储在字符串中。

   // 提取为字符串#include <iostream>#include <string>int main (){std::string name;std::cout << "Please, enter your name: ";std::cin >> name;std::cout << "Hello, " << name << "!\n";return 0;}

5. operator<<：这个函数用于将字符串插入到输出流（如 std::cout）。它将字符串的内容写入到指定的输出流中。

  // 在输出流中插入字符串#include <iostream>#include <string>int main (){std::string str = "Hello world!";std::cout << str << '\n';return 0;}

6. getline：这个函数用于从输入流中获取一行文本，并将其存储在字符串中。std::getline 会读取输入流中的所有字符，直到遇到换行符（\n）。它会将换行符之前的所有字符（包括空格）读取到 std::string 中。std::getline 不会读取换行符本身，所以换行符不会出现在存储的字符串中。

 // 提取为字符串#include <iostream>#include <string>int main (){std::string name;std::cout << "Please, enter your full name: ";std::getline (std::cin,name);std::cout << "Hello, " << name << "!\n";return 0;}

10.string类常量成员

1. 常量对象：当你声明一个 const std::string 对象时，意味着这个字符串对象是不可修改的。你不能对它调用任何会改变其内容的成员函数，比如 append、erase 或 replace。

   const std::string greeting = "Hello, World!";
   // greeting.append(" How are you?"); // 这行代码会导致编译错误，因为 greeting 是常量
   

2. 常量成员函数：这些函数不会修改字符串对象的状态，它们被声明为 const。你可以通过常量成员函数来读取字符串的内容，而不用担心会改变字符串。

   std::string name = "KK";
   const std::string& ref = name;
   std::cout << ref.size(); // 可以调用，因为 size() 是常量成员函数
   

3. 常量表达式：在 C++11 及以后版本中，std::string 类提供了一些静态成员常量，比如 std::string::npos，它是一个非常大的数，用于表示在字符串中没有找到某个子串。

   std::string str = "Moonshot AI";
   auto pos = str.find("Moon");
   if (pos == std::string::npos) {std::cout << "Sub-string not found." << std::endl;
   }
   

4. 常量迭代器：std::string 类提供了 cbegin() 和 cend() 函数，它们返回的是常量迭代器，这意味着你可以通过这些迭代器读取字符串中的字符，但不能修改它们。

   for (auto it = str.cbegin(); it != str.cend(); ++it) {std::cout << *it;
   }
   

最后，本篇文章到此结束，友友们如果还有不清楚的操作可以查询下面文档。感觉不错的友友们可以一键三连支持一下笔者，有任何问题欢迎在评论区留言哦~

string文档介绍