STRING类函数用法总结3

合集下载

C++string类成员函数c_str（）的用法

C++string类成员函数c_str（）的⽤法1.string类成员函数c_str()的原型:const char *c_str()const;//返回⼀个以null终⽌的c字符串2.c_str()函数返回⼀个指向正规c字符串的指针,内容和string类的本⾝对象是⼀样的,通过string类的c_str()函数能够把string对象转换成c中的字符串的样式;3.操作c_str()函数的返回值时,只能使⽤c字符串的操作函数,如:strcpy()等函数.因为,string对象可能在使⽤后被析构函数释放掉,那么你所指向的内容就具有不确定性.eg: char * name[20];string ptr = "tongnono";strcpy(name,ptr.c_str());//c_str()返回的是⼀个临时的指针变量,不能对其操作.语法:const char *c_str();c_str()函数返回⼀个指向正规C字符串的指针常量, 内容与本string串相同.这是为了与c语⾔兼容，在c语⾔中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。

注意：⼀定要使⽤strcpy()函数等来操作⽅法c_str()返回的指针⽐如：最好不要这样:char* c;string s="1234";c = s.c_str(); //c最后指向的内容是垃圾，因为s对象被析构，其内容被处理，同时，编译器也将报错——将⼀个const char *赋与⼀个char *。

应该这样⽤：char c[20];string s="1234";strcpy(c,s.c_str());这样才不会出错，c_str()返回的是⼀个临时指针，不能对其进⾏操作再举个例⼦c_str() 以 char* 形式传回 string 内含字符串如果⼀个函数要求char*参数，可以使⽤c_str()⽅法：string s = "Hello World!";printf("%s", s.c_str()); //输出 "Hello World!"⽐如定义⼀个函数func(const char *s){ //s+1这个指针是对的};func(string s){//s+1是错的}；主函数中： string str;调⽤这个函数时可以为 func(s.c_str());。

stdstring用法总结

stdstring用法总结std::string是C++标准库中的一个类，用于表示和处理字符串。

它提供了一系列的方法和功能，使得字符串的处理更加方便和高效。

下面是std::string的用法总结：1.创建字符串- 使用构造函数：std::string str("hello world");- 使用赋值操作符：std::string str = "hello world";- 使用拷贝构造函数：std::string str2(str);2.基本操作- 获取字符串长度：str.length( 或 str.size- 判断字符串是否为空：str.empty- 清空字符串内容：str.clear- 访问字符串中的字符：str[index] 或 str.at(index)- 修改字符串中的字符：str[index] = 'c' 或 str.at(index) = 'c'- 获取字符串的子串：str.substr(start, length)- 追加字符串：str.append("world")- 插入字符串：str.insert(index, "hello")3.字符串的比较4.字符串的查找和替换- 查找一些字符首次出现的位置：str.find('c')- 查找一些字符串首次出现的位置：str.find("hello")- 替换字符串中的一些字符：str.replace(index, 1, "c")- 替换字符串中的一些子串：str.replace(start, length, "world")5.字符串的拼接和分割- 字符串拼接：str1 + str2 或 str1.append(str2)- 字符串分割为子串：使用std::stringstream或std::istringstream进行分割6.字符串的遍历- 使用for循环遍历字符串中的每个字符-使用迭代器遍历字符串中的每个字符：```for (auto it = str.begin(; it != str.end(; ++it)//处理当前字符}```7.字符串中的转换- 将字符串转为整数类型：std::stoi(str)- 将字符串转为浮点类型：std::stof(str)- 将整数转为字符串：std::to_string(num)8. C风格字符串与std::string的转换- C风格字符串转为std::string：std::string str(cstr)- std::string转为C风格字符串：str.c_str9.字符串的性能优化-避免频繁的字符串拼接，尽量使用字符流操作- 使用reserve函数预先分配足够的内存空间-使用迭代器代替下标访问字符串中的字符，以提高性能总结：std::string提供了丰富实用的方法和功能，用于处理和操作字符串。

C++-string常用函数整理（建议收藏）

本文后续持续更新。

构造函数：1.string s; // 声明一个s字符串，为空2.string s(ss); // 声明一个s字符串，将ss字符串复制过来3.string s(ss,2); // 声明一个s字符串，将ss字符串从2位置（也就是第三个字符）后的所有字符复制过来4.string s(ss,1,3); // 声明一个s字符串，将ss字符串从1位置（也就是第二个字符）起的3个字符复制过来5.string s(chars); // 声明一个s字符串，将C字符串复制过来6.string s(chars,5); // 声明一个s字符串，将C字符串的前5个字符复制过来7.string s(6,char); // 声明一个s字符串，初值为6个char类型的字符，比如char为'a'，则s为aaaaaa析构函数：1.s.~string(); // 将s字符串析构赋值函数：1.string s=c; // 赋值函数，c既可以是字符串，也可以是C字符串，比如char a[]=“123”2.s.assign(ss); // 赋值函数，ss既可以是字符串，也可以是C字符串3.s.assign(ss,1,3); // 赋值函数，ss无论是string字符串还是C字符串，均从1位置开始的3个字符赋值4.s.assign(ss,1); // 赋值函数，ss若为string字符串，则从1位置开始的所有字符赋值；若ss为C字符串，则赋值前1个字符5.s.assign(6,char); //赋值函数，赋为6个char类型的字符6.s.assign(s1.begin(),s1.end()-1); //赋值函数，将s1字符串从开始到倒数第二个字符赋值给s，string有begin和end，C字符串没有哦操作函数：1.swap(s1,s2); // 交换两个字符串2.s.size(); // 返回字符串字符个数3.s.length(); // 返回字符串字符个数4.s.clear(); // 清除所有字符5.s.empty(); // 返回字符串是否为空，若空则true，非空则false6.s.begin(); // 字符串迭代器-开始位置7.s.rbegin(); // 字符串迭代器-逆向开始位置，逆向开始是跳过结束符的第一个字符8.s.end(); // 字符串迭代器-结束位置，注意结束一般是'\0'9.s.rend(); // 字符串迭代器-逆向结束位置10.s.capacity(); // 返回已分配存储的大小11.s.resize(n); // 把字符串的长度设置为n个字符，若s字符串原本为1234，n为2，则resize后的s字符为1212.s.max_size(); // 返回字符串的最大大小13.s.capacity(); // 保留一定量内存以容纳一定数量的字符14.s.at(5); // 输出s字符串5位置的字符（第六个字符）15.getline(cin,s); // 获取一行字符串给s16.s.copy(cs,3,2); // 将s字符串第二个字符后的三个字符，复制到C字符串cs的前三个字符的位置，原字符被替换掉，cs只能是C字符串17.s.c_str(); // 将内容以C_string返回18.s.data(); // 将内容以字符数组形式返回，和c_str()输出基本一致，区别在于data()结尾不补\0，毕竟是数组形式添加函数：1.s+=s1; // 添加函数，直接添加字符串至后方，s1可以是string字符串也可以是C字符串2.s.append(ss); // 添加函数，将ss添加到后方3.s.append(ss,1,3); // 添加函数，ss无论是string字符串还是C 字符串，均将从1位置开始的3个字符添加4.s.append(ss,1); // 添加函数，ss若为string字符串，则将从1位置开始的所有字符添加；若ss为C字符串，则添加前1个字符5.s.append(6,char); //添加函数，添加6个char类型的字符6.s.append(s1.begin(),s1.end()-1); //添加函数，将s1字符串从开始到倒数第二个字符添加到s后面，string有begin和end，C字符串没有哦插入函数：1.s.insert(2,ss); // 插入函数，在s字符串的第二个字符后插入ss2.s.insert(2,ss,4); // 插入函数，若ss为string字符串，则在s字符串的第二个字符后插入ss的前四个字符；若ss为C字符串，则在s 字符串的第二个字符后插入ss第四个字符后的所有字符3.s.insert(2,ss,4,2); // 插入函数，s字符串的第二个字符后插入ss 第四个字符后的2个字符4.s.insert(2,6,char); //插入函数，s字符串的第二个字符后6个char类型的字符5.s.insert(s.begin()+3,'A'); // 插入函数，通过迭代器在s字符串第三个字符后添加1个A字符6.s.insert(s.begin()+3,6,'A'); // 插入函数，通过迭代器在s字符串第三个字符后添加6个A字符7.s.insert(s.begin()+3,ss.begin(),ss.end()); // 插入函数，通过迭代器在s字符串第三个字符后添加ss字符串从开始到结尾的所有字符删除函数：1.s.erase(s.begin()+3); // 删除函数，删除字符串第3个字符后的第一个字符，也就是第四个字符2.s.erase(s.begin(),s.begin()+3); // 删除函数，删除字符串第1到第3的所有字符，虽然s.begin()+3指向从头起第四个字符，但是最后这个字符是不删除的3.s.erase(1,3); // 删除函数，删除字符串从1位置（第二个字符）起的3个字符提取函数：1.s=ss.substr(1,3); // 提取函数，提取ss字符串从1位置起的3个字符给s字符串2.s=ss.substr(); // 提取函数，提取ss字符串的所有内容给s字符串3.s=ss.substr(3); // 提取函数，提取ss字符串从3位置起的所有内容给s字符串查找函数：1.a=s.find('A',1); // 提取函数，a是string::size_type类型，从前面1位置开始查找，查找A字符最早出现的位置，若没找到，则返回string::npos2.a=s.find(ss,1); // 提取函数，从前面1位置开始查找，查找ss 字符串最早出现在s字符串的位置，若没找到，则返回string::npos3.a=s.find(cs,1); // 提取函数，从前面1位置开始查找，查找C字符串cs最早出现在s字符串的位置，若没找到，则返回string::npos4.a=s.find(cs,1,2); // 提取函数，从前面1位置开始查找，查找C 字符串cs中前两个字符最早出现在s字符串的位置，若没找到，则返回string::npos；注意string字符串没有该格式函数5.a=s.rfind('A'); // 提取函数，从后查找，查找A字符最先出现的位置，若没找到，则返回string::npos6.a=s.find_first_of(ss); // 提取函数，从前查找，ss字符串中任一字符出现在s字符串中的位置7.a=s.find_first_of(ss,3); // 提取函数，从第3个字符后查找（即第4个字符开始），ss字符串中任一字符最先出现在s字符串中的位置8.a=s.find_last_of(ss); // 提取函数，从前查找，ss字符串中任一字符最后一次出现在s字符串中的位置；换句话说，从后查找，最先出现的位置9.a=s.find_last_of(ss,3); // 提取函数，从后面第3个字符后查找（即第4个字符开始），ss字符串中任一字符最先出现在s字符串中的位置；换句话说，在s后面第3个字符位置前的字符串中，ss任一字符最后一次出现在此字符串中的位置10.a=s.find_first_not_of(ss); // 提取函数，从前查找，任一非ss 字符串中字符最早出现在s字符串中的位置11.a=s.find_first_not_of(ss,3); // 提取函数，从第3个字符后查找（即第4个字符开始），任一非ss字符串中字符最先出现在s字符串中的位置12.a=s.find_last_not_of(ss); // 提取函数，从前查找，任一非ss 字符串中字符最后一次出现在s字符串中的位置；换句话说，从后查找，最先出现的位置13.a=s.find_last_not_of(ss,3); // 提取函数，从后面第3个字符后查找（即第4个字符开始），任一非ss字符串中字符最先出现在s 字符串中的位置；换句话说，在s后面第3个字符位置前的字符串中，任一非ss字符串中字符最后一次出现在此字符串中的位置哈哈哈，后面这几个find函数是不是看晕了，沉下心来理解一下我说的逻辑，然后自己写个测试代码试试就懂了，编程一定不要背，而是去体会和理解，这样才能活学活用~比较函数：pare(ss); // 比较函数，直接比较s和ss的字符串大小，从第一个字符开始比，若一样则下一个；若s大于ss则返回1，等于返回0，小于返回-1pare(2,2,ss); // 比较函数，用s字符串第二个字符后的两个字符作为子字符串，来和ss比较pare(2,2,ss,1,3); // 比较函数，用s字符串第二个字符后的两个字符作为子字符串，来和ss第一个字符后三个字符组成的子字符串比较替换函数：1.s.replace(1,2,ss); // 替换函数，将s字符串第一个字符后的两个字符替换为ss字符串2.s.replace(s.begin(),s.begin()+3,ss); // 替换函数，将s字符串从头起的三个字符替换为ss字符串3.s.replace(1,2,ss,2,3); // 替换函数，将s字符串第一个字符后的两个字符替换为ss字符串第二个字符后的三个字符4.s.replace(1,2,ss,2); // 替换函数，将s字符串第一个字符后的两个字符被替换，若ss为string字符串，则进行替换的字符串为ss字符串第二个字符后的所有字符；若ss为C字符串，则进行替换的字符串为ss字符串的前两个字符5.s.replace(s.begin(),s.begin()+3,ss,2); // 替换函数，将s字符串从头起的三个字符替换为C字符串ss的前两个字符，注意ss字符串只能是C字符串而不是string字符串6.s.replace(0,3,5,'A’); //替换函数，将s字符串从头起的三个字符替换为5个A字符7.s.replace(s.begin(),s.begin()+3,5,'A’); //替换函数，将s字符串从头起的三个字符替换为5个A字符总结：细心的朋友应该发现了，在string函数的调用过程中，输入参数个数、类型不同可能会带来不同的结果，而string字符串和C字符串（也就是char*）大多数情况下的调用情况一致，比如输入2个数字的时候，第一个数字往往代表了字符操作的起点位置，第二个数字代表了操作的字符个数；但是，如果只输入1个数字X的时候，就有所不同，若字符串是string，则表示从该数字X对应位置往后的所有字符进行操作，若字符串是C字符串，则表示取前X个字符进行操作。

string的几种构造函数

string的几种构造函数在编程中，字符串（string）是一种非常常用的数据类型，用于存储和操作文本。

在C++语言中，string类是用来表示和操作字符串的类。

string类提供了多个构造函数，用于创建字符串对象。

本文将介绍string的几种构造函数，并详细解释它们的用法。

1. 默认构造函数string类的默认构造函数创建一个空的字符串对象。

空字符串是一个长度为0的字符串，不包含任何字符。

我们可以使用以下语法来创建一个空字符串对象：string str;2. 字符数组构造函数string类还提供了一个构造函数，可以使用字符数组来创建字符串对象。

字符数组是一系列字符的集合，以null字符('\0')结尾。

我们可以使用以下语法来创建一个字符串对象：char arr[] = "Hello";string str(arr);这样，str将包含字符数组arr中的所有字符，并以null字符结尾。

需要注意的是，字符数组的长度必须小于或等于字符串对象的最大长度。

3. 字符串构造函数除了字符数组，我们还可以使用另一个字符串来创建字符串对象。

string类提供了一个接受另一个字符串作为参数的构造函数。

我们可以使用以下语法来创建一个字符串对象：string str1 = "Hello";string str2(str1);这样，str2将包含与str1相同的内容。

这个构造函数会创建一个新的字符串对象，而不是简单地将str2指向str1。

4. 子字符串构造函数string类还提供了一个构造函数，可以使用另一个字符串的一部分来创建一个新的字符串对象。

我们可以使用以下语法来创建一个子字符串对象：string str1 = "Hello World";string str2(str1, 0, 5);这样，str2将包含str1中从索引0开始的5个字符，即"Hello"。

C++中的string常用函数用法总结

C++中的string常用函数用法总结首先，为了在我们的程序中使用string类型，我们必须包含头文件<string>。

如下：#include <string> //注意这里不是string.h string.h是C字符串头文件#include <string>using namespace std;1．声明一个C++字符串声明一个字符串变量很简单：string Str;这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。

上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str 初始化为一个空字符串。

String类的构造函数和析构函数如下：a) string s; //生成一个空字符串sb) string s(str) //拷贝构造函数生成str的复制品c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多st rlen”的部分作为字符串的初值e) string s(cstr) //将C字符串作为s的初值f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。

g) string s(num,c) //生成一个字符串，包含num个c字符h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值i) s.~string() //销毁所有字符，释放内存都很简单，我就不解释了。

2．字符串操作函数这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。

a) =,assign() //赋以新值b) swap() //交换两个字符串的内容c) +=,append(),push_back() //在尾部添加字符d) insert() //插入字符e) erase() //删除字符f) clear() //删除全部字符g) replace() //替换字符h) + //串联字符串i) ==,!=,<,<=,>,>=,compare() //比较字符串j) size(),length() //返回字符数量k) max_size() //返回字符的可能最大个数l) empty() //判断字符串是否为空m) capacity() //返回重新分配之前的字符容量n) reserve() //保留一定量内存以容纳一定数量的字符o) [ ], at() //存取单一字符p) >>,getline() //从stream读取某值q) << //将谋值写入streamr) copy() //将某值赋值为一个C_strings) c_str() //将内容以C_string返回t) data() //将内容以字符数组形式返回u) substr() //返回某个子字符串v)查找函数w)begin() end() //提供类似STL的迭代器支持x) rbegin() rend() //逆向迭代器y) get_allocator() //返回配置器下面详细介绍：2．1 C++字符串和C字符串的转换C ++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy()，其中，data()以字符数组的形式返回字符串内容，但并不添加'/0'。

c++ string用法总结

c++ string用法总结C++中的string是一种使用较广泛的字符串类型，相比于传统的C语言字符串，其便利性更高，使用简单方便。

下面是一些C++ string的用法总结：1. 定义string变量：可以使用下面的语句来定义string变量```string str;```2. 给string变量赋值：可以使用以下方式来给string变量赋值```str = "Hello world"; // 直接赋值str = str1 + str2; // 字符串拼接getline(cin, str); // 从键盘输入一行字符串```3. 访问string的字符：使用下标访问的方式可以访问string 中的字符，例如：```char ch = str[0]; // 取得第一个字符```4. 获取string的长度：可以使用size()函数或length()函数来获取string变量的长度，例如：```int len = str.size(); // 获取字符串长度```5. 字符串比较：可以使用比较运算符和compare函数来比较两个字符串的大小，例如：```if (str1 == str2) // 使用比较运算符if (pare(str2) == 0) // 使用compare函数```6. 查找字符串：可以使用find()函数来查找一个字符串在另一个字符串中的位置，例如：```int pos = str.find("world"); // 查找子串所在位置```7. 截取字符串：可以使用substr()函数来截取一个字符串的某个子串，例如：```string sub = str.substr(0, 5); // 截取前五个字符```8. 插入和删除字符串：可以使用insert()函数和erase()函数来插入和删除字符串中的某个部分，例如：```str.insert(5, "good "); // 在指定位置插入字符串str.erase(0, 6); // 删除指定位置及其后面的字符```总之，C++中的string提供了丰富的操作函数和方便的语法，在使用中只需要注意不要越界和空指针异常即可。

delphi string用法 -回复

delphi string用法-回复【Delphi String用法】一步一步回答Delphi语言是一种强大的编程语言，广泛用于Windows平台的开发。

在Delphi中，String类型是最常用的数据类型之一，用于处理文本和字符数据。

本文将逐步介绍Delphi String的用法，包括创建、操作和处理String 类型的变量。

一、创建String类型变量在Delphi中，使用String关键字声明一个String类型的变量。

可以使用以下语法声明String变量：varmyString: String;上述代码声明了一个名为myString的String类型变量。

二、赋值String变量可以使用多种方式为String变量赋值。

下面是几种常见的方法：1. 使用赋值运算符"："直接赋值给String变量：myString := 'Hello, World!';2. 通过输入和输出语句从用户那里获取String类型的输入：Readln(myString); 接收用户输入并赋值给myStringWriteLn(myString); 将myString的内容输出到控制台3. 通过函数返回值给String变量赋值：function GetGreeting: String;beginResult := 'Hello, World!';end;myString := GetGreeting;三、String类型的操作Delphi提供了一些内置的函数和过程，用于操作和处理String类型的变量。

以下是一些常见的操作：1. 字符串拼接：使用"+"运算符可以将两个字符串连接起来，生成一个新的字符串。

示例代码如下：varstr1, str2, strResult: String;beginstr1 := 'Hello, ';str2 := 'World!';strResult := str1 + str2; 拼接字符串ShowMessage(strResult); 显示结果end;2. 获取字符串长度：使用Length函数可以获得字符串的长度，即字符的数量。

sstream用法

标题：C++中的stringstream用法详解引言：在C++编程中，字符串处理是非常常见的需求之一。

而sstream 是一个非常有用的类，它提供了一种方便的方式来处理字符串，包括字符串的输入和输出。

本文将详细介绍C++中sstream的用法，帮助读者更好地理解和应用该类。

一、sstream的基本概述sstream是C++标准库中的一个类，位于<sstream>头文件中。

它提供了一个流对象，可以将字符串作为输入或输出，并且可以像处理流一样使用操作符进行处理。

sstream主要由istringstream、ostringstream和stringstream三个类组成。

二、istringstream的用法1. 创建istringstream对象使用istringstream对象之前，首先需要包含<sstream>头文件。

然后，可以使用构造函数创建istringstream对象，如下所示：```include <sstream>// ...std::string inputString = "Hello World";std::istringstream iss(inputString);```2. 从字符串中读取数据通过使用>>运算符，可以从istringstream对象中读取数据并存储到其他变量中。

以下是一个简单的示例：```std::string word1, word2;iss >> word1 >> word2;```3. 检查读取状态在读取数据时，可以使用istringstream对象的成员函数eof()、fail()、bad()和good()来检查读取状态。

例如： ```if (iss.fail()) {// 读取失败的处理逻辑}```三、ostringstream的用法1. 创建ostringstream对象使用ostringstream对象之前，同样需要包含<sstream>头文件。

C++中LIST和String用法

1.c++中的list用法#include <iostream>#include <list>#include <numeric>#include <algorithm>using namespace std;//创建一个list容器的实例LISTINTtypedef list<int> LISTINT;//创建一个list容器的实例LISTCHARtypedef list<int> LISTCHAR;void main(void){//--------------------------//用list容器处理整型数据//--------------------------//用LISTINT创建一个名为listOne的list对象LISTINT listOne;//声明i为迭代器LISTINT::iterator i;//从前面向listOne容器中添加数据listOne.push_front (2);listOne.push_front (1);//从后面向listOne容器中添加数据listOne.push_back (3);listOne.push_back (4);//从前向后显示listOne中的数据cout<<"listOne.begin()--- listOne.end():"<<endl;for (i = listOne.begin(); i != listOne.end(); ++i)cout<< *i << " ";cout<<endl;//从后向后显示listOne中的数据LISTINT::reverse_iteratorir;cout<<"listOne.rbegin()---listOne.rend():"<<endl;for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {cout<< *ir<< " ";}cout<<endl;//使用STL的accumulate(累加)算法int result = accumulate(listOne.begin(), listOne.end(),0);cout<<"Sum="<<result<<endl;cout<<"------------------"<<endl;//--------------------------//用list容器处理字符型数据//--------------------------//用LISTCHAR创建一个名为listOne的list对象LISTCHAR listTwo;//声明i为迭代器LISTCHAR::iterator j;//从前面向listTwo容器中添加数据listTwo.push_front ('A');listTwo.push_front ('B');//从后面向listTwo容器中添加数据listTwo.push_back ('x');listTwo.push_back ('y');//从前向后显示listTwo中的数据cout<<"listTwo.begin()---listTwo.end():"<<endl;for (j = listTwo.begin(); j != listTwo.end(); ++j)cout<< char(*j) << " ";cout<<endl;//使用STL的max_element算法求listTwo中的最大元素并显示j=max_element(listTwo.begin(),listTwo.end());cout<< "The maximum element in listTwo is: "<<char(*j)<<endl;}#include <iostream>#include <list>using namespace std;typedef list<int> INTLIST;//从前向后显示list队列的全部元素voidput_list(INTLIST list, char *name){INTLIST::iterator plist;cout<< "The contents of " << name << " : ";for(plist = list.begin(); plist != list.end(); plist++)cout<< *plist<< " ";cout<<endl;}//测试list容器的功能void main(void){//list1对象初始为空INTLIST list1;//list2对象最初有10个值为6的元素INTLIST list2(10,6);//list3对象最初有3个值为6的元素INTLIST list3(list2.begin(),--list2.end());//声明一个名为i的双向迭代器INTLIST::iterator i;//从前向后显示各list对象的元素put_list(list1,"list1");put_list(list2,"list2");put_list(list3,"list3");//从list1序列后面添加两个元素list1.push_back(2);list1.push_back(4);cout<<"list1.push_back(2) and list1.push_back(4):"<<endl; put_list(list1,"list1");//从list1序列前面添加两个元素list1.push_front(5);list1.push_front(7);cout<<"list1.push_front(5) and list1.push_front(7):"<<endl; put_list(list1,"list1");//在list1序列中间插入数据list1.insert(++list1.begin(),3,9);cout<<"list1.insert(list1.begin()+1,3,9):"<<endl;put_list(list1,"list1");//测试引用类函数cout<<"list1.front()="<<list1.front()<<endl;cout<<"list1.back()="<<list1.back()<<endl;//从list1序列的前后各移去一个元素list1.pop_front();list1.pop_back();cout<<"list1.pop_front() and list1.pop_back():"<<endl;put_list(list1,"list1");//清除list1中的第2个元素list1.erase(++list1.begin());cout<<"list1.erase(++list1.begin()):"<<endl;put_list(list1,"list1");//对list2赋值并显示list2.assign(8,1);cout<<"list2.assign(8,1):"<<endl;put_list(list2,"list2");//显示序列的状态信息cout<<"list1.max_size(): "<<list1.max_size()<<endl;cout<<"list1.size(): "<<list1.size()<<endl;cout<<"list1.empty(): "<<list1.empty()<<endl;//list序列容器的运算put_list(list1,"list1");put_list(list3,"list3");cout<<"list1>list3: "<<(list1>list3)<<endl;cout<<"list1<list3: "<<(list1<list3)<<endl;//对list1容器排序list1.sort();put_list(list1,"list1");//结合处理list1.splice(++list1.begin(), list3);put_list(list1,"list1");put_list(list3,"list3");}2.标准C++中的string类的用法总结相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧？的确，MFC中的CString类使用起来真的非常的方便好用。

delphi string用法

delphi string用法Delphi是一种编程语言，其中的string是一种数据类型，用于存储文本或字符数据。

在Delphi中，string是一种动态变长的数据类型，由字符构成。

它可以用于存储任意长度的文本字符串，并且可以进行各种字符串操作。

以下是一些常见的Delphi string用法：1.字符串赋值：可以使用等号将一个字符串赋值给另一个字符串。

```vars1, s2: string;begins1 := 'Hello'; //字符串赋值s2 := s1; //将s1的值赋给s2```2.字符串连接：使用加号操作符可以将两个字符串连接在一起。

```vars1, s2, s3: string;begins1 := 'Hello';s2 := 'World';s3 := s1 + s2; //将s1和s2连接在一起end;```3.字符串长度：使用Length函数可以获取一个字符串的长度。

```s: string;len: Integer;begins := 'Hello';len := Length(s); //获取字符串的长度end;```4.字符串比较：可以使用等号、小于号、大于号等操作符对字符串进行比较。

```vars1, s2: string;isEqual: Boolean;isLess: Boolean;isGreater: Boolean;begins1 := 'Hello';s2 := 'World';isEqual := (s1 = s2); //检查两个字符串是否相等isLess := (s1 < s2); //检查s1是否小于s2isGreater := (s1 > s2); //检查s1是否大于s2end;```除了上述用法，Delphi还提供了一些其他的string操作函数和过程，用于处理字符串的拆分、替换、查找、插入等操作。

c++的string的find函数

c++的string的find函数C++的string类是C++标准库中的一部分，它提供了许多字符串操作的函数。

其中一个常用的函数是find()函数，它用于查找字符串中某个子串的位置。

下面将详细介绍这个函数以及它的用法。

find()函数的原型如下：```size_t find(const string& str, size_t pos = 0) const noexcept;```它接受两个参数，第一个参数是要查找的子串，第二个参数是搜索的起始位置（默认为0）。

函数返回一个size_t类型的值，表示子串在字符串中的索引位置。

如果找到子串，则返回第一次出现的位置索引；如果找不到子串，则返回string::npos。

下面是一个示例代码，演示了find()函数的基本用法：```cpp#include <iostream>#include <string>int main() {std::string str("Hello, world!");std::size_t found = str.find("world");if (found != std::string::npos) {std::cout << "子串在位置" << found << "处找到了。

" << std::endl;} else {std::cout << "子串未找到。

" << std::endl;}return 0;}```输出结果为：```子串在位置7处找到了。

```在上面的示例中，我们通过find()函数查找了字符串"world"在变量str中第一次出现的位置。

由于子串存在于字符串中，所以返回了7，正是子串的起始位置。

string substr函数用法

string substr函数用法substr函数是C++中string类中的一个函数，它可以从一个字符串中返回指定的子字符串。

substr函数的语法格式为：string substr (size_t pos = 0, size_t len = npos) const;其中，pos是要截取的子字符串的起始位置，len是要截取的子字符串的长度，npos 是一个常量，它代表字符串中的最大长度。

如果省略len参数，那么substr函数将返回从pos位置到字符串结尾的子字符串。

下面我们来看看substr函数的用法示例。

1. 截取字符串的一部分我们可以使用substr函数来截取已有字符串的一部分。

以下是一个代码示例：#include <iostream>#include <string>using namespace std;cout << part_str << endl; // 输出 Worldreturn 0;}在第6行代码中，我们使用substr函数从字符串的第6个字符开始截取，由于没有指定截取的长度，因此返回的是从第6个字符到字符串结尾的子字符串。

3. 截取字符串的最后几个字符string new_str = part_str; // 将截取的子字符串赋值给新的string变量在第8行代码中，我们将截取的子字符串赋值给一个新的string变量new_str，最终输出截取的子字符串。

总结substr函数是C++中string类中的一个非常常用的函数，它可以从一个字符串中返回指定的子字符串。

在使用substr函数时，我们需要指定要截取的子字符串的起始位置和长度，也可以省略长度参数来返回从起始位置到字符串结尾的子字符串。

除此之外，我们还可以使用size函数来获取字符串的长度，并结合substr函数来截取字符串的最后几个字符，或者结合string的赋值运算符将截取的子字符串赋给一个新的string变量。

c++ string find使用正则表达式

c++ string find使用正则表达式摘要：1.简介2.C++ string find 函数3.正则表达式的基本概念4.使用C++ string find 函数查找正则表达式5.示例代码及解析6.总结正文：C++中的string 类为我们提供了许多便利的操作字符串的方法，其中一个重要的方法就是find 函数。

find 函数可以用于查找给定子串或正则表达式在字符串中首次出现的位置。

本文将重点介绍如何使用C++ string find 函数结合正则表达式进行查找。

首先，我们需要了解C++ string find 函数的基本用法。

find 函数接收两个参数：第一个参数是需要查找的子串或正则表达式，第二个参数是查找起始位置（默认为0）。

函数返回值是子串或正则表达式首次出现的位置，如果未找到则返回string::npos。

在C++中，正则表达式是一种用于匹配字符串的强大工具。

它们由一系列字符和元字符组成，用于描述需要查找的字符串模式。

这里有一些基本的正则表达式元字符：- "^"：匹配字符串的开头- "$"：匹配字符串的结尾- "*"：匹配前面的字符0 次或多次- "+"：匹配前面的字符1 次或多次- "?"：匹配前面的字符0 次或1 次- "["：匹配字符集合，如[a-z] 表示匹配小写字母- ""：转义特殊字符，如d表示匹配数字，D表示匹配非数字了解了这些基本概念后，我们可以开始使用C++ string find 函数查找正则表达式了。

以下是一个简单的示例：```cpp#include <iostream>#include <string>#include <regex>int main() {std::string str = "Hello, I am a student.";std::string pattern = "b[A-Z]b"; // 匹配单词的开头大写字母std::string::size_type pos = str.find(pattern);if (pos != std::string::npos) {std::cout << "找到匹配项，位置为：" << pos << std::endl;} else {std::cout << "未找到匹配项" << std::endl;}return 0;}```在这个示例中，我们使用了正则表达式"b[A-Z]b"来查找字符串"Hello, I am a student."中的单词开头大写字母。

python中string.index的用法

python中string.index的用法【Python中string.index的用法】string.index方法是字符串类型的一个内置函数，用于返回字符串中指定子字符串的第一个匹配项的索引。

本文将详细介绍string.index方法的用法，并提供一些示例以加深理解。

一、基本定义与语法string.index(sub[, start[, end]])方法的基本定义如下：- string：需要检索的字符串。

- sub：要查找的子字符串。

- start：可选参数，指定开始查找的索引位置，默认为0，即从字符串的第一个字符开始查找。

- end：可选参数，指定结束查找的索引位置（不包含该位置）。

二、方法的返回值string.index方法的返回值是子字符串第一次出现的索引位置。

若找不到子字符串，则会引发ValueError异常。

如果指定了start和end参数，则查找的范围是[start, end)，即包括start位置，不包括end位置。

三、示例演示接下来，我们通过一些示例来演示string.index方法的用法。

示例一：查找子字符串的位置pythons = "Hello, World!"print(s.index("o")) # 输出结果为：4在上述示例中，我们使用string.index方法查找字符串"s"中第一个出现的子字符串"o"并返回其索引位置。

由于字符串索引从0开始，故输出结果为4。

示例二：使用start参数控制查找的起始位置pythons = "Hello, World!"print(s.index("o", 5)) # 输出结果为：7在上述示例中，我们使用start参数指定查找的起始位置为5，即从字符串的第6个字符开始查找。

由于子字符串"o"在字符"o"之后的索引位置为7，故输出结果为7。

delphi string用法

在 Delphi 中，string 是一种用于表示文本数据的基本数据类型。

Delphi 的 string 类型是动态长度的，这意味着它可以存储任意长度的文本，并且会根据需要自动分配内存。

下面是一些在 Delphi 中使用 string 类型的常见用法：声明字符串变量：delphivarmyString: string;赋值给字符串变量：delphimyString := 'Hello, World!';字符串连接：可以使用 + 运算符将两个字符串连接起来：delphivarstring1: string;string2: string;beginstring1 := 'Hello, ';string2 := 'World!';myString := string1 + string2; // 结果为 'Hello, World!'end;字符串长度：可以使用 Length 函数获取字符串的长度（即字符数）：delphivarlength: Integer;beginlength := Length(myString); // 结果为 13end;子字符串：可以使用 Copy 函数从字符串中提取子字符串：delphivarsubString: string;beginsubString := Copy(myString, 8, 5); // 从索引 8 开始提取长度为 5 的子字符串，结果为 'World'end;字符串比较：可以使用 =、<>、<、>、<=、>= 运算符来比较两个字符串的大小关系：delphivarstring3: string;beginstring3 := 'Hello';if myString = string3 thenShowMessage('字符串相等');if myString <> string3 thenShowMessage('字符串不相等');end;字符串转换：可以使用 IntToStr 函数将整数转换为字符串，使用 StrToInt 函数将字符串转换为整数：delphivarnumber: Integer;numberString: string;beginnumber := 42;numberString := IntToStr(number); // 将整数转换为字符串，结果为 '42'number := StrToInt(numberString); // 将字符串转换为整数，结果为 42end;这些只是 Delphi 中 string 类型的一些基本用法示例。

strncmp用法

strncmp用法在C语言中，字符串是一种非常常见的数据类型。

在处理字符串时，我们经常需要比较两个字符串是否相等。

C语言提供了许多字符串比较函数，其中最常用的是strncmp函数。

本文将详细介绍strncmp函数的用法。

1. 函数原型strncmp函数的函数原型如下：```cint strncmp(const char *s1, const char *s2, size_t n);```其中，s1和s2是要比较的两个字符串，n是要比较的字符数。

2. 函数功能strncmp函数用于比较两个字符串的前n个字符是否相等。

如果相等，返回0；如果s1小于s2，返回一个负数；如果s1大于s2，返回一个正数。

3. 函数用法下面是一个简单的例子，演示了如何使用strncmp函数：#include <stdio.h>#include <string.h>int main(){char str1[] = "hello";char str2[] = "world";int result = strncmp(str1, str2, 3);if (result == 0){printf("The first 3 characters of str1 and str2 are equal.\n");}else if (result < 0){printf("The first 3 characters of str1 are less than str2.\n"); }else{printf("The first 3 characters of str1 are greater than str2.\n");return 0;}```输出结果为：```The first 3 characters of str1 are less than str2.```在这个例子中，我们比较了字符串"hello"和"world"的前3个字符。

C++中数字与字符串之间的转换scanfstring总结（复习必读）

C++中数字与字符串之间的转换scanfstring总结（复习必读） 1　string的scanf读⼊操作C++⾥⾯控制台输⼊直接使⽤cin操作就可以了；或者getline(istringstream,string);字符和数字加减就是字符的ASCII码和数字直接加减。

只有内置类型int,float,char,double,bool可以直接赋值，scanf读⼊string不能直接使⽤scanf直接赋值，因为string是⼀个类class，有专门的初始化函数，不能使⽤scanf，同理gets接收的也是⼀个char指针。

编程语⾔⾃带的sizeof也是⼀样，不能对string进⾏直接操作。

string s;s.resize(100);scanf("%s",&s[0]);或者：string s;char *c = new char(100);scanf("%s",c);//scanf("%s",&c[0]);s = c;//给⾸地址strlen是得到输⼊的有效字符串，⽽不是开辟的空间⼤⼩100.strlen所作的仅仅是⼀个计数器的⼯作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚⾄是某个不确定的内存区域）开始扫描，直到碰到第⼀个字符串结束符'\0'为⽌，然后返回计数器值。

--就是指实际字符串或字符数组的实际长度（不是所占空间的字节数）。

char A[6]={'a','b','\0','d','e','r'};int i=strlen(A); //i为2，因为到’\0’结束，故实际A[]只有2个元素sizeof()string s;char *c = new char(100);scanf("%s",c);int len = strlen(c);s1.resize(len);//动态编译s1.assign(c,c + len);//copy(c,c + len,s1.begin());针对其他结构class X { int i; int j; char k; }; X x;cout<<sizeof(X)<<endl; 结果 12 ===》内存补齐cout<<sizeof(x)<<endl; 结果 12 同上解释⼀下，在class X中，成员中最⼤的所占的空间为int类型所占的空间4个字节，故内存补齐，最后结果为: ((int)(实际成员所占内存空间的和/4)+1)*4*所以不能通过sizeof(string) / sizeof(string[0])得到实际char元素个数，不管string等于多少，最后的结果都是28；因为string是⼀个class。

无效的聚合函数 sum()和类型 string 的用法。

无效的聚合函数sum()和类型string 的用法
在常见的编程语言中，聚合函数`sum()` 通常用于对数字类型的值进行求和操作，而不适用于字符串类型的值。

当你尝试使用`sum()` 函数对字符串类型的值进行求和时，会导致错误或不符合预期的结果。

这是因为字符串是一种不可变的序列类型，它的加法运算是将两个字符串连接在一起，而不是对字符串进行求和操作。

例如，在Python中，尝试对字符串列表使用`sum()` 函数会引发错误：
```python
my_list = ['Hello', 'World', '!']
result = sum(my_list)
```
运行上述代码会引发`TypeError`，因为`sum()` 函数无法处理字符串类型的值。

如果你想要对字符串进行聚合操作，通常需要编写自定义的函数来实现你的需求。

例如，如果你想要连接一个字符串列表中的所有字符串，可以使用`join()` 方法：
```python
my_list = ['Hello', 'World', '!']
result = ''.join(my_list)
```
以上代码使用了空字符串`''` 作为分隔符，将列表中的所有字符串连接在一起。

结果将是`'HelloWorld!'`。

总结来说，聚合函数`sum()` 通常用于数字类型的值，而对于字符串类型的值，你需要考虑使用其他方法来实现你的需求，比如字符串的连接操作。

halcon string类型

halcon string类型Halcon String类型Halcon是一种用于机器视觉领域的图像处理软件库，它提供了丰富的函数和工具，用于图像处理、分析和识别。

在Halcon中，String 类型是一种用于存储和操作文本数据的数据类型。

本文将介绍Halcon中的String类型的特点和用法，并针对其常见应用场景进行详细说明。

一、String类型的定义和特点1. String类型是一种动态长度的数据类型，可以存储任意长度的文本数据。

在Halcon中，String类型的变量可以通过赋值或函数返回值来进行初始化。

2. String类型的变量可以进行常见的字符串操作，如连接、分割、查找、替换等。

这些操作可以通过Halcon提供的函数来实现。

3. String类型的变量可以与其他类型的变量进行转换。

例如，可以将String类型的变量转换为Integer或Real类型的变量，也可以将Integer或Real类型的变量转换为String类型的变量。

4. String类型的变量可以通过索引来访问和修改其中的字符。

索引从1开始，表示字符串的第一个字符。

5. String类型的变量可以通过比较运算符进行比较。

比较运算符可以用于判断两个字符串是否相等、大小关系等。

二、String类型的常见用法1. 字符串拼接String类型可以用于将多个字符串拼接成一个字符串。

例如，可以将名字和年龄拼接成一个句子，用于输出或保存。

拼接字符串可以使用字符串连接运算符"+"，也可以使用Halcon提供的字符串连接函数Concat。

2. 字符串分割String类型可以用于将一个字符串分割成多个子字符串。

例如，可以将一个包含多个姓名的字符串，按照逗号进行分割，并将每个姓名存储到一个String类型的数组中。

字符串分割可以使用字符串分割函数SplitStr。

3. 字符串查找和替换String类型可以用于在一个字符串中查找指定的子字符串，并进行替换。

c++的string的find函数

c++的string的find函数摘要：1.引言2.C++中的string 类型3.string 的find 函数介绍4.find 函数的参数5.find 函数的返回值6.find 函数的用法示例7.总结正文：C++是一种通用的编程语言，广泛应用于各种领域。

在C++中，string 类型是一个用于表示文本数据的重要数据类型。

string 类型提供了许多方便的函数来处理文本数据，其中find 函数是用来查找给定子串或字符在字符串中首次出现的位置。

string 的find 函数是一个重要的字符串查找函数。

它可以在给定字符串中查找子串或字符首次出现的位置。

这个函数的参数包括：- 要查找的子串或字符（需要查找的文本）- 子串或字符在字符串中首次出现的位置（起始位置）find 函数的返回值是一个size_t 类型的数值，表示子串或字符在字符串中首次出现的位置。

如果未找到指定的子串或字符，函数将返回string::npos，即表示查找失败。

下面通过一个示例来说明find 函数的使用：```cpp#include <iostream>#include <string>int main() {std::string str = "C++的string 的find 函数";std::string sub_str = "的";size_t pos = str.find(sub_str);if (pos != string::npos) {std::cout << "找到子串"" << sub_str << ""，位置为：" << pos << std::endl;} else {std::cout << "未找到子串"" << sub_str << """ << std::endl;}return 0;}```在这个示例中，我们定义了一个字符串str，并在其中查找子串"的"。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

C++中的string类前言:string的角色1string使用1.1充分使用string操作符1.2眼花缭乱的string find函数1.3string insert,replace,erase2string和C风格字符串3string和Charactor Traits4string建议5小结6附录前言:string的角色C++语言是个十分优秀的语言，但优秀并不表示完美。

还是有许多人不愿意使用C或者C++，为什么？原因众多，其中之一就是C/C++的文本处理功能太麻烦，用起来很不方便。

以前没有接触过其他语言时，每当别人这么说，我总是不屑一顾，认为他们根本就没有领会C++的精华，或者不太懂C++，现在我接触perl,php,和Shell脚本以后，开始理解了以前为什么有人说C++文本处理不方便了。

举例来说，如果文本格式是：用户名电话号码，文件名name.txtTom23245332Jenny22231231Heny22183942Tom23245332...现在我们需要对用户名排序，且只输出不同的姓名。

那么在shell编程中，可以这样用：awk'{print$1}'name.txt|sort|uniq简单吧？如果使用C/C++就麻烦了，他需要做以下工作：先打开文件，检测文件是否打开，如果失败，则退出。

声明一个足够大得二维字符数组或者一个字符指针数组读入一行到字符空间然后分析一行的结构，找到空格，存入字符数组中。

关闭文件写一个排序函数，或者使用写一个比较函数，使用qsort排序遍历数组，比较是否有相同的，如果有，则要删除，copy...输出信息你可以用C++或者C语言去实现这个流程。

如果一个人的主要工作就是处理这种类似的文本(例如做apache的日志统计和分析),你说他会喜欢C/C++么？当然，有了STL，这些处理会得到很大的简化。

我们可以使用fstream来代替麻烦的fopen fread fclose,用vector来代替数组。

最重要的是用string来代替char*数组，使用sort排序算法来排序，用unique函数来去重。

听起来好像很不错。

看看下面代码(例程1）：＃i nclude<string>＃i nclude<iostream>＃i nclude<algorithm>＃i nclude<vector>＃i nclude<fstream>using namespace std;int main(){ifstream in("name.txt");string strtmp;vector<string>vect;while(getline(in,strtmp,'\n'))vect.push_back(strtmp.substr(0,strtmp.find('')));sort(vect.begin(),vect.end());vector<string>::iterator it=unique(vect.begin(),vect.end());copy(vect.begin(),it,ostream_iterator<string>(cout,"\n"));return0;}也还不错吧，至少会比想象得要简单得多！（代码里面没有对错误进行处理，只是为了说明问题，不要效仿).当然，在这个文本格式中，不用vector而使用map会更有扩充性，例如，还可通过人名找电话号码等等，但是使用了map就不那么好用sort了。

你可以用map 试一试。

这里string的作用不只是可以存储字符串，还可以提供字符串的比较，查找等。

在sort和unique函数中就默认使用了less和equal_to函数,上面的一段代码，其实使用了string的以下功能：存储功能，在getline()函数中查找功能，在find()函数中子串功能，在substr()函数中string operator<,默认在sort()函数中调用string operator==,默认在unique()函数中调用总之，有了string后，C++的字符文本处理功能总算得到了一定补充，加上配合STL其他容器使用，其在文本处理上的功能已经与perl,shell,php的距离缩小很多了。

因此掌握string会让你的工作事半功倍。

1string使用其实，string并不是一个单独的容器，只是basic_string模板类的一个typedef 而已，相对应的还有wstring,你在string头文件中你会发现下面的代码:extern"C++"{typedef basic_string<char>string;typedef basic_string<wchar_t>wstring;}//extern"C++"由于只是解释string的用法，如果没有特殊的说明，本文并不区分string和basic_string的区别。

string其实相当于一个保存字符的序列容器，因此除了有字符串的一些常用操作以外，还有包含了所有的序列容器的操作。

字符串的常用操作包括：增加、删除、修改、查找比较、链接、输入、输出等。

详细函数列表参看附录。

不要害怕这么多函数，其实有许多是序列容器带有的，平时不一定用的上。

如果你要想了解所有函数的详细用法，你需要查看basic_string，或者下载STL 编程手册。

这里通过实例介绍一些常用函数。

1.1充分使用string操作符string重载了许多操作符，包括+,+=,<,=,,[],<<,>>等，正式这些操作符，对字符串操作非常方便。

先看看下面这个例子：tt.cpp（例程2）＃i nclude<string>＃i nclude<iostream>using namespace std;int main(){string strinfo="Please input your name:";cout<<strinfo;cin>>strinfo;if(strinfo=="winter")cout<<"you are winter!"<<endl;else if(strinfo!="wende")cout<<"you are not wende!"<<endl;else if(strinfo<"winter")cout<<"your name should be ahead of winter"<<endl;elsecout<<"your name should be after of winter"<<endl;strinfo+=",Welcome to China!";cout<<strinfo<<endl;cout<<"Your name is:"<<endl;string strtmp="How are you?"+strinfo;for(int i=0;i<strtmp.size();i++)cout<<strtmp[i];return0;}下面是程序的输出-bash-2.05b$make ttc++-O-pipe-march=pentiumpro tt.cpp-o tt-bash-2.05b$./ttPlease input your name:Heroyou are not wende!Hero,Welcome to China!How are you?Hero,Welcome to China!有了这些操作符，在STL中仿函数都可以直接使用string作为参数，例如less, great,equal_to等，因此在把string作为参数传递的时候，它的使用和int或者float等已经没有什么区别了。

例如，你可以使用：map<string,int>mymap;//以上默认使用了less<string>有了operator+以后，你可以直接连加，例如：string strinfo="Winter";string strlast="Hello"+strinfo+"!";//你还可以这样：string strtest="Hello"+strinfo+"Welcome"+"to China"+"!";看见其中的特点了吗？只要你的等式里面有一个string对象，你就可以一直连续"+"，但有一点需要保证的是，在开始的两项中，必须有一项是string对象。

其原理很简单：系统遇到"+"号，发现有一项是string对象。

系统把另一项转化为一个临时string对象。

执行operator+操作，返回新的临时string对象。

如果又发现"+"号，继续第一步操作。

由于这个等式是由左到右开始检测执行，如果开始两项都是const char*，程序自己并没有定义两个const char*的加法，编译的时候肯定就有问题了。

有了操作符以后，assign(),append(),compare(),at()等函数，除非有一些特殊的需求时，一般是用不上。

当然at()函数还有一个功能，那就是检查下标是否合法，如果是使用：string str="winter";//下面一行有可能会引起程序中断错误str[100]='!';//下面会抛出异常:throws:out_of_rangecout<<str.at(100)<<endl;了解了吗？如果你希望效率高，还是使用[]来访问，如果你希望稳定性好，最好使用at()来访问。

1.2眼花缭乱的string find函数由于查找是使用最为频繁的功能之一，string提供了非常丰富的查找函数。

其列表如下：函数名描述find查找rfind反向查找find_first_of查找包含子串中的任何字符，返回第一个位置find_first_not_of查找不包含子串中的任何字符，返回第一个位置find_last_of查找包含子串中的任何字符，返回最后一个位置find_last_not_of查找不包含子串中的任何字符，返回最后一个位置以上函数都是被重载了4次，以下是以find_first_of函数为例说明他们的参数，其他函数和其参数一样，也就是说总共有24个函数：size_type find_first_of(const basic_string&s,size_type pos=0)size_type find_first_of(const charT*s,size_type pos,size_type n) size_type find_first_of(const charT*s,size_type pos=0)size_type find_first_of(charT c,size_type pos=0)所有的查找函数都返回一个size_type类型，这个返回值一般都是所找到字符串的位置，如果没有找到，则返回string::npos。