string类中函数介绍
c语言string()的用法
C语言string()的用法1.简介在C语言中，字符串是一系列字符的集合，常用的字符串操作包括拷贝、连接、长度计算等。
C语言提供了一系列的库函数来方便地操作字符串，其中`s tr in g()`函数是一个重要的函数之一。
本文将详细介绍`s tr in g()`函数的用法及示例。
2.函数概述`s tr in g()`函数用于对字符串进行各种操作，包括拷贝、连接、比较等。
其函数原型如下：#i nc lu de<s tr in g.h>c h ar*s tr in g(ch ar*d es t,co ns tc ha r*s r c);其中，`de st`表示目标字符串的指针，`s rc`表示源字符串的指针。
该函数将源字符串中的内容复制到目标字符串中，并返回目标字符串的指针。
3.示例下面通过几个示例来演示`s tr in g()`函数的使用方法。
3.1字符串拷贝字符串拷贝是`s tr in g()`函数最常用的功能之一。
示例代码如下：#i nc lu de<s td io.h>#i nc lu de<s tr in g.h>i n tm ai n(){c h ar so ur ce[]="Hel l o,Wo rl d!";c h ar de st in at io n[20];//使用st r i ng()函数进行字符串拷贝s t ri ng(d es ti na tio n,s ou rc e);p r in tf("拷贝后的字符串：%s\n",de st i na ti on);r e tu rn0;}输出结果为：拷贝后的字符串：He l lo,W or ld!3.2字符串连接`s tr in g()`函数还可以用于字符串的连接。
示例代码如下：#i nc lu de<s td io.h>#i nc lu de<s tr in g.h>i n tm ai n(){c h ar st r1[50]="Hel l o";c h ar st r2[]="Wo rld!";//使用st ri ng()函数进行字符串连接s t ri ng(s tr1,st r1);s t ri ng(s tr1,st r2);p r in tf("连接后的字符串：%s\n",st r1);r e tu rn0;}输出结果为：连接后的字符串：He l lo Wo rl d!3.3字符串比较`s tr in g()`函数还可以用于字符串的比较操作。
c中string函数库常用函数
c中string函数库常用函数C语言中的string函数库是一个非常重要的函数库，它包含了许多常用的字符串处理函数。
这些函数可以帮助我们更加方便地处理字符串，提高我们的编程效率。
在本文中，我们将介绍一些常用的string函数库函数。
1. strlen函数strlen函数用于计算字符串的长度，它的原型如下：size_t strlen(const char *s);其中，s是要计算长度的字符串。
该函数返回字符串s的长度，不包括字符串末尾的空字符。
2. strcpy函数strcpy函数用于将一个字符串复制到另一个字符串中，它的原型如下：char *strcpy(char *dest, const char *src);其中，dest是目标字符串，src是源字符串。
该函数将源字符串src 复制到目标字符串dest中，并返回目标字符串dest的指针。
3. strcat函数strcat函数用于将一个字符串连接到另一个字符串的末尾，它的原型如下：char *strcat(char *dest, const char *src);其中，dest是目标字符串，src是要连接的字符串。
该函数将源字符串src连接到目标字符串dest的末尾，并返回目标字符串dest的指针。
4. strcmp函数strcmp函数用于比较两个字符串是否相等，它的原型如下：int strcmp(const char *s1, const char *s2);其中，s1和s2是要比较的两个字符串。
该函数返回一个整数值，如果s1和s2相等，则返回0；如果s1小于s2，则返回一个负数；如果s1大于s2，则返回一个正数。
5. strchr函数strchr函数用于在一个字符串中查找一个字符，它的原型如下：char *strchr(const char *s, int c);其中，s是要查找的字符串，c是要查找的字符。
该函数返回一个指向第一个匹配字符的指针，如果没有找到匹配字符，则返回NULL。
c++ string类的常用方法
c++ string类的常用方法x1、string类的构造函数string类的构造函数有三种：（1）默认构造函数：string()；（2）以字符串常量指针为参数的构造函数：string (const char *s)；（3）以字符串对象为参数的构造函数：string (const string &str)；2、string类的赋值操作string类的赋值操作有以下几种：（1）以字符串常量指针为参数的赋值运算符重载：string & operator = (const char *s)；（2）以字符串对象为参数的赋值运算符重载：string & operator = (const string &str)；（3）拼接函数：string &append (const string &str)；（4）两个字符串的拼接：string + string；3、string类的比较操作string类的比较操作有如下几种：（1）比较两个字符串是否相等的比较操作符：string==string；（2）比较两个字符串是否不等的比较操作符：string!=string；（3）比较两个字符串大小的比较操作符：string>string；4、string类的查找操作string类的查找操作有以下几种：（1）查找从某个位置开始某个子串的位置的函数：size_tfind(const string &str,size_t pos = 0)；（2）查找从某个位置开始某个字符的位置的函数：size_tfind(char c,size_t pos = 0);（3）查找从右向左某个子串的位置的函数：size_t rfind(const string &str,size_t pos = string::npos)；（4）查找从右向左某个字符的位置的函数：size_t rfind(char c,size_t pos = string::npos)；5、string类的修改操作string类的修改操作有以下几种：（1）插入字符串的函数：string &insert (size_t pos, const string &str)；（2）替换某个子串的函数：string &replace (size_t pos, size_t len, const string &str)；（3）删除某个子串的函数：string &erase (size_t pos = 0, size_t len = npos)；（4）在字符串前面补充某字符的函数：string &insert (size_t pos, size_t n, char c)；（5）清除字符串的函数：void clear()；6、string类的截取操作string类的截取操作有以下几种：（1）从某个位置截取字符串的函数：string substr (size_t pos = 0, size_t n = npos)；（2）将字符串按照一定的字符分割成多个小字符串的函数：vector<string> split(char c)；（3）删除收尾处的某字符的函数：string &trim(char c);。
string类的函数
string类的函数1. length(：返回字符串的长度。
示例：string str = "Hello World!";int len = str.length(;2. size(：返回字符串的大小，与length(功能相同。
示例：string str = "Hello World!";int size = str.size(;3. empty(：判断字符串是否为空，返回true或false。
示例：string str = "";bool empty = str.empty(;4. clear(：清空字符串，将其长度设置为0。
示例：string str = "Hello World!";str.clear(;5. at(index)：返回指定位置的字符，使用索引访问字符串。
示例：string str = "Hello World!";char ch = str.at(0);6. append(str)：将字符串str追加到当前字符串的末尾。
示例：string str = "Hello ";str.append("World!");7. insert(index, str)：将字符串str插入到指定位置的前面。
示例：string str = "Hello!";str.insert(5, " World");8. erase(index, count)：删除从指定位置开始的指定数量的字符。
示例：string str = "Hello World!";str.erase(6, 6);9. replace(index, count, str)：用str替换从指定位置开始的指定数量的字符。
示例：string str = "Hello World!";str.replace(6, 5, "C++");10. substr(start, length)：返回从指定位置开始的指定长度的子字符串。
C++-string常用函数整理（建议收藏）
C++-string常用函数整理（建议收藏）作者：翟天保Steven版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处最近刷笔试题，涉及到许多字符串相关的题目，所以将一些常用的函数整理一下，便于后面查看。
本文后续持续更新。
构造函数：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"。
string的几种构造函数
string的几种构造函数String的构造函数是用于创建字符串对象的方法。
在Java中，有多种构造函数可用于创建字符串对象。
本文将介绍Java中的几种常用的String构造函数。
1. String()String()构造函数创建一个空字符串对象。
这个构造函数不需要任何参数，它只是创建一个空字符串对象。
例如：```String str = new String();```这将创建一个空字符串对象，即str对象不包含任何字符。
2. String(char[])String(char[])构造函数创建一个字符串对象，该对象包含char数组中的所有字符。
例如：```char[] chars = {'H', 'e', 'l', 'l', 'o'};String str = new String(chars);```这将创建一个字符串对象，即str对象包含字符数组中的所有字符。
3. String(char[], int, int)String(char[], int, int)构造函数创建一个字符串对象，该对象包含char数组中从指定索引开始的指定数量的字符。
例如：```char[] chars = {'H', 'e', 'l', 'l', 'o'};String str = new String(chars, 1, 3);```这将创建一个字符串对象，即str对象包含字符数组中从索引1开始的3个字符，即"ell"。
4. String(byte[])String(byte[])构造函数创建一个字符串对象，该对象包含byte数组中的所有字节。
例如：```byte[] bytes = {72, 101, 108, 108, 111};String str = new String(bytes);```这将创建一个字符串对象，即str对象包含字节数组中的所有字节，即"Hello"。
string的各种函数（系统学习）
string的各种函数（系统学习）1、按照⾯向对象的要求，可以把字符串看作⼀个对象，设计⼀个串类加以描述。
但是，在⼀般的情况下不必建⽴⾃⼰的串类，c++标准在库<string>中给出了类string,提供了丰富的串操作，程序员使⽤指令: #include<string>即存取这个类。
可将类string视为⼀个容器类，其部分操作如下：构造函数：string s:构造⼀个空串sstring s(a):构造串s,并⽤字符数组a初始化string s(a,n):构造串s,⽤字符数组a的前n个字符初始化string s(str):⽤串str构造串s(拷贝初始化）看下⾯代码验证#include<iostream>#include<string.h>#include<map>#include<cstdio>#include<cstring>#include<stdio.h>#include<cmath>#include<ctype.h>#include<math.h>#include<algorithm>#include<set>#include<queue>typedef long long ll;using namespace std;const ll mod=1e9+7;const int maxn=1e5+10;const int maxk=3e5+10;const int maxx=1e4+10;const ll maxe=1000+10;#define INF 0x3f3f3f3f3f3f#define Lson l,mid,rt<<1#define Rson mid+1,r,rt<<1|1int main(){char a[maxn];cin>>a;//输⼊abcdefghstring s(a);//结果为abcdefghstring s1(a,5);//结果为abcdestring s2(s1);//结果为abcdecout<<s<<endl;cout<<s1<<endl;cout<<s2<<endl;return0;}输⼊输出：getline(cin,s,delim):从cin中提取字符存⼊串s中，当遇到delim或者提取的字符个数等于s的长度时结束，如果⾃⼰不设定，默认为'\n' getline(cin,s):遇到'\n'结束cin>>s:遇到空⽩字符终⽌提取，空⽩字符不被读取cout<<s:输出s#include<iostream>#include<string.h>#include<map>#include<cstdio>#include<cstring>#include<stdio.h>#include<cmath>#include<ctype.h>#include<math.h>#include<algorithm>#include<set>#include<queue>typedef long long ll;using namespace std;const ll mod=1e9+7;const int maxn=1e5+10;const int maxk=3e5+10;const int maxx=1e4+10;const ll maxe=1000+10;#define INF 0x3f3f3f3f3f3f#define Lson l,mid,rt<<1#define Rson mid+1,r,rt<<1|1int main(){string s;while(getline(cin,s,'#')){getchar();//⾃⼰指定了字符要加getchar,不然结果会多出⼀个换⾏，但是默认情况下不⽤加getcharcout<<s<<endl;}return0;}操作符：s=val:赋值操作，val可以是⼀个串，⼀个字符或⼀个字符数组s+=val:将val添加到串s之后s[pos]:下标操作s+t,t+s:s和t的连接，返回连接的结果。
c string类的常用方法
c string类的常用方法在C语言中，字符串通常表示为字符数组，而不是像C++那样有专门的字符串类。
但C标准库中提供了一些用于操作和处理字符串的函数。
以下是其中的一些常用方法：1. strcpy()：将一个字符串复制到另一个字符串。
```cchar str1[50];strcpy(str1, "Hello, World!");```2. strcat()：将一个字符串连接到另一个字符串的末尾。
```cchar str1[50] = "Hello, ";strcat(str1, "World!");```3. strlen()：返回字符串的长度，不包括终止字符'\0'。
```cchar str[] = "Hello, World!";printf("%d", strlen(str)); // 输出 13```4. strcmp()：比较两个字符串。
```cchar str1[] = "Hello";char str2[] = "World";if (strcmp(str1, str2) < 0) {printf("%s is less than %s\n", str1, str2);} else if (strcmp(str1, str2) > 0) {printf("%s is greater than %s\n", str1, str2); } else {printf("%s is equal to %s\n", str1, str2);}```5. strstr()：在字符串中查找子串。
```cchar str[] = "Hello, World!";char sub[] = "World";char result = strstr(str, sub);if (result != NULL) {printf("Found '%s' in '%s'\n", sub, str);} else {printf("Did not find '%s' in '%s'\n", sub, str); }```6. sprintf()：将格式化的数据写入字符串。
string标准库函数
string标准库函数在C++中，std::string库提供了许多用于处理字符串的函数。
以下是一些常用的函数：1、构造函数：std::string(): 默认构造函数，创建一个空字符串。
std::string(const char*): 从C风格的字符串创建字符串。
std::string(const std::string&): 复制构造函数。
2、赋值操作：operator=: 赋值操作符。
3、访问和修改：at(int n): 访问指定位置的字符。
operator[] 或 operator(): 访问或修改指定位置的字符。
front(): 返回第一个字符。
back(): 返回最后一个字符。
c_str(): 返回指向一个C风格的字符串的指针。
4、长度和容量：size(): 返回字符串的长度。
max_size(): 返回字符串的最大可能长度。
empty(): 检查字符串是否为空。
5、插入和删除：insert(int pos, const std::string& str): 在指定位置插入字符串。
erase(int pos, int len): 删除指定位置和长度的字符。
6、连接：operator+: 连接两个字符串。
append(const std::string& str): 在末尾添加字符串。
7、比较：operator==, operator!=, <, >, <=, >=: 比较两个字符串。
8、查找：find(char c, int pos): 查找字符的位置。
find(const std::string& str, int pos): 查找字符串的位置。
9、修改：replace(int pos, int len, const std::string& str): 在指定位置和长度处替换字符串。
10、分割和合并：split(char delimiter): 根据给定的分隔符分割字符串。
string头文件常用成员函数
string头⽂件常⽤成员函数之前说过 string和vector⼀样，也是⼀种顺序容器，并且它也⾃带成员函数，⽤法和vector的成员函数差不多，不过它只能⽤来存放字符，也就是字符串。
在c++中，<string>基本上已经包含在<iostream>⾥⾯了，但即便如此，在我们⽤到string类的时候还是要加上头⽂件<string>的。
下⾯介绍⼀下string对象常⽤的成员函数。
1.构造函数，有三个常⽤的(1) string str1="hello world"；(2) string str2("abcde")；(3) string *str3=new string("12343543")；2. 获取字符串长度int len1=str1.length()； //获取字符串长度int len2=str1.size()； //获取string这个容器对象中元素的个数3. ⽤ '+' 串联字符串在<string>头⽂件⾥对 '+' 进⾏了重载，可以⽤来串联字符串string str4=str1+str2+str3；4. [ ] 随机访问在<string>头⽂件⾥对 [ ] 进⾏了重载，可以⽤来对字符串对象进⾏随机访问str1[3]，包括存取甚⾄修改操作，类似于数组。
5. 常⽤的成员函数push_back()；向string容器的末尾位置添加字符push_pop()；把string容器⾥的末尾元素弹出容器，即删除操作begin()；返回⼀个指向容器中第⼀个元素的迭代器end()；返回⼀个指向容器中最后⼀个元素的下⼀个位置的迭代器rebegin()；反向迭代，返回指向最后⼀个元素的下⼀个位置的迭代器rend()；反向迭代，返回指向第⼀个元素的的迭代器front()；返回容器中第⼀个元素的引⽤，可以对其进⾏存取及修改操作back()；返回容器中最后⼀个元素的引⽤，可以对其进⾏存取及修改操作at()；此成员函数有参数，参数是下标。
string类库所包含的函数
string类的构造函数：string(const char *s); //用c字符串s初始化string(int n,char c); //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。
当构造的string太长而无法表达时会抛出length_error异常string类的字符操作：const char &operator[](int n)const;const char &at(int n)const;char &operator[](int n);char &at(int n);operator[]和at()均返回当前字符串中第n个位置的字符（第n个字符的位置），但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。
const char *data()const;//返回一个非null终止的c字符数组const char *c_str()const;//返回一个以null终止的c字符串int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目string的特性描述:int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数）int max_size()const; //返回string对象中可存放的最大字符串的长度int size()const; //返回当前字符串的大小int length()const; //返回当前字符串的长度bool empty()const; //当前字符串是否为空void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分string类的输入输出操作:string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。
c++algorithm中的函数
c++algorithm中的函数
在C++算法中，有很多实用的函数可以帮助程序员提高编程效率。
例如：
1. string类型的函数：
（1）string::npos表示string类型的结束位置，可以用于判断字符串是否结束。
（2）string::find()函数可以在字符串中查找字符或子串，如果找到了就返回该位置的下标，否则返回string::npos。
（3）string::substr()函数可以从一个字符串中复制一段子串。
2. vector类型的函数：
（1）vector::push_back()函数可以在vector的尾部添加一个元素。
（2）vector::pop_back()函数可以删除vector的最后一个元素。
（3）vector::insert()函数可以在vector中的任意位置插入元素。
3. 迭代器类型的函数：
（1）advance()函数可以让迭代器向前或向后移动指定的距离。
（2）distance()函数可以计算两个迭代器之间的距离。
（3）next()函数返回指向迭代器后面第n个元素的迭代器。
这些函数是C++算法中非常常用的函数，可以帮助程序员提高编程效率。
string类型 函数参数
string类型函数参数String类型是一种常见的数据类型，在编写程序时经常使用。
String类型的函数参数是指在一个函数中，使用了String类型的变量来作为函数的参数。
在本篇文章中，我们将会分析String类型函数参数的使用方法，以及讨论一些常见的问题。
一、什么是String类型String类型是一种字符串类型，用于存储文本信息。
在Java语言中，String类型是不可变的，这意味着一旦字符串被创建，它就不能被修改。
String类型的变量可以被用于拼接字符串、表示文件名、路径等常见应用场景。
二、如何在函数中使用String类型的参数在函数中使用String类型的参数非常简单，只需在函数的括号中声明一个字符串变量即可。
例如，下面的代码演示了如何使用String类型的函数参数：```javapublic class StringParameter {public static void main(String[] args) {String name = "Lily";printName(name);}private static void printName(String name) {System.out.println("My name is " + name);}}```在这个例子中，我们声明了一个名为printName的函数，并将String类型的变量name作为它的参数。
函数printName的作用是打印出“我的名字是Lily”的句子。
我们将变量name的值传递给printName函数，并在函数内部使用。
三、常见的String类型函数参数问题1. String类型函数参数能否为null在Java中，String类型的变量可以为null。
因此，在声明一个String类型的函数参数时，必须考虑到该参数可能会为null的情况。
在函数内部，我们可以使用null检查语句，以确保程序不会因为操作空字符串引发空指针异常。
c语言string类型的find函数
c语言string类型的find函数C语言中的string类型是一种用来存储字符串的数据类型。
在C语言中，字符串是由一系列字符组成的，以空字符（'\0'）作为字符串的结束符。
在C语言中，我们经常需要在一个字符串中查找特定的字符或子串。
为了实现这个功能，C语言提供了一些内置的字符串处理函数，其中就包括了find函数。
find函数的作用是在一个字符串中寻找指定的字符或子串，并返回它们在字符串中第一次出现的位置。
这个函数可以帮助我们在一个字符串中快速定位我们需要的信息。
在使用find函数之前，我们需要先定义一个字符串变量并初始化它。
在C语言中，可以使用字符数组来表示字符串。
例如，我们可以定义一个名为str的字符数组来存储一个字符串。
接下来，我们可以使用find函数来查找字符串中的字符或子串。
该函数的原型如下：```cchar *find(char *str, char *substr);```其中，str是要查找的字符串，substr是要查找的字符或子串。
find函数的返回值是一个指向字符的指针，指向字符串中第一次出现指定字符或子串的位置。
如果找到了指定字符或子串，则返回该位置的指针；如果没有找到，则返回NULL。
下面是一个使用find函数的示例：```c#include <stdio.h>#include <string.h>char *find(char *str, char *substr){return strstr(str, substr);}int main(){char str[] = "Hello, world!";char *result = find(str, "world");if(result != NULL){printf("找到了指定的字符或子串：%s\n", result);}else{printf("没有找到指定的字符或子串\n");}return 0;}```在上面的示例中，我们定义了一个名为str的字符数组，并初始化它为"Hello, world!"。
string类的常用方法
string类的常用方法String 类是 Java 中最基本的字符串类,提供了许多常用的方法,以下是一些常见的字符串方法:1. 构造函数:String str = "Hello, World!";2. charAt(int index):返回字符串中指定位置的字符,如charAt(1) 返回字符串 "H" 的第一个字符。
3.concat(String str):将两个字符串连接在一起,如:concat(", ", str);4.indexOf(String str):返回字符串中指定字符串的起始索引,如:indexOf("Hello, World!", "Hello, World!");stIndexOf(String str):返回字符串中指定字符串的终止索引,如:lastIndexOf("Hello, World!", "W");6.match(String regex):将字符串匹配到指定字符串的子串中,如:match("Hello, World!");7.replace(String str, String regex):在字符串中替换指定的字符串,如:replace("Hello, World!", "World, Hello!");8.trim():将字符串前、后自动去除空格,如:trim(str);9. toString():返回字符串的打印字符串,如:toString();10. Underscore.indexOf(String str):返回字符串中指定字符串的当前 Underscore 首字母的索引,如: Underscore.indexOf("_" + str) = 0;11. toLowerCase():将字符串转换为大写字母,如:toLowerCase(str);12. toUpperCase():将字符串转换为大写字母,如:toUpperCase(str);13. toLowerCase();14. toUpperCase();15. equals(String str):检查两个字符串是否相等,如:equals(str);16. indexOf():返回指定字符串在字符串中出现的起始索引,如:indexOf("Hello, World!", "H") = 0;stIndexOf():返回指定字符串在字符串中出现的终止索引,如:lastIndexOf("Hello, World!", "W") = -1;18. charAt(int index):返回指定位置的字符,如:charAt(1) = "H";19. length():返回字符串的长度,如:length() = 15;20. toLocaleLowerCase():将字符串转换为小写字母,如:toLocaleLowerCase(str);21. toLocaleUpperCase():将字符串转换为大写字母,如:toLocaleUpperCase(str);22. toLowerCase();23. toUpperCase();24. toLowerCase();25. toUpperCase();26. trim();这些是 String 类的常用方法,还有其他的方法可以根据具体的需要进行调用。
字符串串的函数
字符串串的函数一、什么是字符串在计算机科学中，字符串（String）是字符的有序序列。
它是一种常见的数据类型，被广泛用于各种编程语言中。
字符串可以包含字母、数字、符号以及特殊字符，它们以特定的顺序排列在一起，形成一个字符串。
在编程中，我们经常需要对字符串进行操作，比如拼接、查找、替换等。
而字符串串的函数就是用来处理字符串的函数。
本文将深入探讨字符串串的函数以及它们在日常编程中的应用。
二、基本的字符串串函数在编程语言中，通常会提供一些基本的字符串串函数，用于对字符串进行常见的操作。
下面是其中几个常用的字符串串函数：2.1 len()函数len()函数用于获取字符串的长度，即字符串中字符的个数。
以Python语言为例，我们可以通过len()函数获取一个字符串的长度。
比如：string = "Hello, World!"length = len(string)print(length) # 输出：132.2 upper()函数和lower()函数upper()函数用于将字符串中的所有字母转为大写，lower()函数用于将字符串中的所有字母转为小写。
这两个函数在处理字符串时非常有用。
示例如下：string1 = "Hello, World!"string2 = "Python is Great!"uppercase1 = string1.upper()lowercase2 = string2.lower()print(uppercase1) # 输出：HELLO, WORLD!print(lowercase2) # 输出：python is great!2.3 strip()函数strip()函数用于去除字符串两端的空格或指定的字符。
这个函数在处理用户输入、文件读取等情况时经常用到。
示例如下：string = " Hello, World! "stripped_string = string.strip()print(stripped_string) # 输出：Hello, World!2.4 split()函数split()函数用于将字符串按照指定的分隔符分割成多个子字符串，并返回一个包含这些子字符串的列表。
string的几种构造函数
string的几种构造函数引言：在编程语言中，字符串（string）是一种常见的数据类型，用于存储和操作文本数据。
在许多编程语言中，字符串都有构造函数（constructor）来创建字符串对象。
构造函数可以接受不同的参数类型，并根据这些参数来创建字符串。
本文将介绍string的几种常见构造函数，并且使用丰富多样的词汇来描述它们。
一、空字符串构造函数空字符串构造函数是创建一个空字符串的一种方式。
它不接受任何参数，只需调用构造函数即可创建一个空字符串对象。
空字符串是一个长度为0的字符串，不包含任何字符。
使用空字符串构造函数可以方便地初始化一个字符串变量，然后再逐步向其中添加内容。
二、字符数组构造函数字符数组构造函数可以将一个字符数组转换为字符串。
它接受一个字符数组作为参数，并将该字符数组的内容复制到新创建的字符串对象中。
字符数组构造函数可以方便地将已有的字符数组转换为字符串，并对字符串进行进一步的操作和处理。
三、字符构造函数字符构造函数可以将一个字符转换为字符串。
它接受一个字符作为参数，并将该字符转换为一个长度为1的字符串。
字符构造函数可以方便地将单个字符转换为字符串，并进行字符串的各种操作。
四、整数构造函数整数构造函数可以将一个整数转换为字符串。
它接受一个整数作为参数，并将该整数转换为相应的字符串表示形式。
整数构造函数可以方便地将整数转换为字符串，并进行字符串与整数之间的相互转换。
五、浮点数构造函数浮点数构造函数可以将一个浮点数转换为字符串。
它接受一个浮点数作为参数，并将该浮点数转换为相应的字符串表示形式。
浮点数构造函数可以方便地将浮点数转换为字符串，并进行字符串与浮点数之间的相互转换。
六、布尔值构造函数布尔值构造函数可以将一个布尔值转换为字符串。
它接受一个布尔值作为参数，并将该布尔值转换为相应的字符串表示形式。
布尔值构造函数可以方便地将布尔值转换为字符串，并进行字符串与布尔值之间的相互转换。
七、子字符串构造函数子字符串构造函数可以从一个已有的字符串中提取出指定的子字符串。
string函数的用法
string函数的用法string函数是C++中常用的字符串处理函数，它可以对字符串进行各种操作，如拼接、查找、替换等。
下面介绍一些常用的string函数的用法。
1. string的定义和初始化定义string变量时，需要包含头文件<string>，可以使用以下两种方式进行初始化：string str1; //定义一个空字符串string str2 = "hello world"; //定义并初始化一个字符串2. string的拼接使用“+”运算符可以将两个字符串拼接起来，例如：string str1 = "hello";string str2 = "world";string str3 = str1 + " " + str2; //拼接后的字符串为"hello world"3. string的查找使用find函数可以查找字符串中是否包含某个子串，如果包含则返回子串在字符串中的位置，否则返回string::npos。
例如：string str = "hello world";int pos = str.find("world"); //pos的值为64. string的替换使用replace函数可以将字符串中的某个子串替换为另一个字符串，例如：string str = "hello world";str.replace(6, 5, "there"); //将"world"替换为"there"5. string的截取使用substr函数可以截取字符串中的某一段子串，例如：string str = "hello world";string sub = str.substr(6, 5); //截取"world"6. string的大小写转换使用transform函数可以将字符串中的字母全部转换为大写或小写，例如：string str = "Hello World";transform(str.begin(), str.end(), str.begin(), ::tolower); //将字符串转换为小写transform(str.begin(), str.end(), str.begin(), ::toupper); //将字符串转换为大写以上就是string函数的一些常用用法，掌握这些函数可以让我们更加方便地处理字符串。
关于string类中find函数的讲解
关于string类中find函数的讲解以下所讲的所有的string查找函数，都有唯⼀的返回类型，那就是size_type，即⼀个⽆符号整数（按打印出来的算）。
若查找成功，返回按查找规则找到的第⼀个字符或⼦串的位置；若查找失败，返回npos，即-1（打印出来为4294967295）。
（1）string::find函数#include<iostream>#include<string>using namespace std;int main(){//测试size_type find (charT c, size_type pos = 0) const noexcept;string st1("babbabab");cout << st1.find('a') << endl;//1 由原型知，若省略第2个参数，则默认从位置0（即第1个字符）起开始查找cout << st1.find('a', 0) << endl;//1cout << st1.find('a', 1) << endl;//1cout << st1.find('a', 2) << endl;//4 在st1中，从位置2（b，包括位置2）开始，查找字符a，返回⾸次匹配的位置，若匹配失败，返回nposcout << st1.rfind('a',7) << endl;//6 关于rfind，后⾯讲述cout << st1.find('c', 0) << endl;//4294967295cout << (st1.find('c', 0) == -1) << endl;//1cout << (st1.find('c', 0) == 4294967295) << endl;//1 两句均输出1，原因是计算机中-1和4294967295都表⽰为32个1（⼆进制）cout << st1.find('a', 100) << endl;//4294967295 当查找的起始位置超出字符串长度时，按查找失败处理，返回npos//测试size_type find (const basic_string& str, size_type pos = 0) const noexcept;string st2("aabcbcabcbabcc");string str1("abc");cout << st2.find(str1, 2) << endl;//6 从st2的位置2（b）开始匹配，返回第⼀次成功匹配时匹配的串（abc）的⾸字符在st2中的位置，失败返回npos//测试size_type find (const charT* s, size_type pos = 0) const;cout << st2.find("abc", 2) << endl; //6 同上，只不过参数不是string⽽是char*//测试size_type find (const charT* s, size_type pos, size_type n) const;cout << st2.find("abcdefg", 2, 3) << endl;//6 取abcdefg得前3个字符（abc）参与匹配，相当于st2.find("abc", 2)cout << st2.find("abcbc", 0, 5) << endl;//1 相当于st2.find("abcbc", 0)cout << st2.find("abcbc", 0, 6) << endl;//4294967295 第3个参数超出第1个参数的长度时，返回nposreturn0;}（2）string::rfind()函数rfind()与find()很相似，差别在于查找顺序不⼀样，rfind()是从指定位置起向前查找，直到串⾸。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
标准c++中string类函数介绍注意不是CString之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。
我们可以用= 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。
我们尽可以把它看成是C++的基本数据类型。
好了，进入正题………首先，为了在我们的程序中使用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且长度顶多strlen”的部分作为字符串的初值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_str()返回一个以…/0'结尾的字符数组，而copy()则把字符串的内容复制或写入既有的c_string或字符数组内。
C++字符串并不以'/0'结尾。
我的建议是在程序中能使用C++字符串就使用，除非万不得已不选用c_string。
由于只是简单介绍，详细介绍掠过，谁想进一步了解使用中的注意事项可以给我留言(到我的收件箱)。
我详细解释。
2．2 大小和容量函数一个C++字符串存在三种大小：a)现有的字符数，函数是size()和length()，他们等效。
Empty()用来检查字符串是否为空。
b)max_size() 这个大小是指当前C++字符串最多能包含的字符数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。
我们一般情况下不用关心他，应该大小足够我们用的。
但是不够用的话，会抛出length_error异常c)capacity()重新分配内存之前string所能包含的最大字符数。
这里另一个需要指出的是reserve()函数，这个函数为string重新分配内存。
重新分配的大小由其参数决定，默认参数为0，这时候会对string进行非强制性缩减。
还有必要再重复一下C++字符串和C字符串转换的问题，许多人会遇到这样的问题，自己做的程序要调用别人的函数、类什么的（比如数据库连接函数Connect(char*,char*)），但别人的函数参数用的是char*形式的，而我们知道，c_str()、data()返回的字符数组由该字符串拥有，所以是一种const char*,要想作为上面提及的函数的参数，还必须拷贝到一个char*,而我们的原则是能不使用C字符串就不使用。
那么，这时候我们的处理方式是：如果此函数对参数(也就是char*)的内容不修改的话，我们可以这样Connect((char*)UserID.c_str(), (char*)PassWD.c_str()),但是这时候是存在危险的，因为这样转换后的字符串其实是可以修改的（有兴趣地可以自己试一试），所以我强调除非函数调用的时候不对参数进行修改，否则必须拷贝到一个char*上去。
当然，更稳妥的办法是无论什么情况都拷贝到一个char*上去。
同时我们也祈祷现在仍然使用C字符串进行编程的高手们（说他们是高手一点儿也不为过，也许在我们还穿开裆裤的时候他们就开始编程了，哈哈…）写的函数都比较规范，那样我们就不必进行强制转换了。
2．3元素存取我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。
但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。
而at()会检查，如果使用at()的时候索引无效，会抛出out_of_range异常。
有一个例外不得不说，const string a;的操作符[]对索引值是a.length()仍然有效，其返回值是'/0'。
其他的各种情况，a.length()索引都是无效的。
举例如下：const strin g Cstr(“const string”);string Str(“string”);Str[3]; //okStr.at(3); //okStr[100]; //未定义的行为Str.at(100); //throw out_of_rangeStr[Str.length()] //未定义行为Cstr[Cstr.length()] //返回 0Str.at(Str.length());//throw out_of_rangeCstr.at(Cstr.length()) ////throw out_of_range我不赞成类似于下面的引用或指针赋值：char& r=s[2];char* p= &s[3];因为一旦发生重新分配，r,p立即失效。
避免的方法就是不使用。
2．4比较函数C ++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string的比较(如str<”hello”)。
在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得比较。
字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。
同时，string (“aaaa”) <string(aaaaa)。
另一个功能强大的比较函数是成员函数compare()。
他支持多参数处理，支持用索引值和长度定位子串来进行比较。
他返回一个整数来表示比较结果，返回值意义如下：0-相等〉0-大于<0-小于。
举例如下：string s(“abcd”);pare(“abcd”); //返回0pare(“dcba”); //返回一个小于0的值s.c ompare(“ab”); //返回大于0的值pare(s); //相等pare(0,2,s,2,2); //用”ab”和”cd”进行比较小于零pare(1,2,”bcx”,2); //用”bc”和”bc”比较。
怎么样？功能够全的吧！什么？还不能满足你的胃口？好吧，那等着，后面有更个性化的比较算法。
先给个提示，使用的是STL的比较算法。
什么？对STL一窍不通？靠，你重修吧！2．5 更改内容这在字符串的操作中占了很大一部分。
首先讲赋值，第一个赋值方法当然是使用操作符=，新值可以是string(如：s=ns) 、c_string(如：s=”gaint”)甚至单一字符（如：s='j'）。
还可以使用成员函数assign()，这个成员函数可以使你更灵活的对字符串赋值。
还是举例说明吧：s.assign(str); //不说s.assign(str,1,3);//如果str是”iamangel” 就是把”ama”赋给字符串s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给ss.assign(“gaint”); //不说s.assign(“nico”,5);//把'n' …I' …c' …o' …/0'赋给字符串s.assign(5,'x');//把五个x赋给字符串把字符串清空的方法有三个：s=””;s.clear();s.erase();(我越来越觉得举例比说话让别人容易懂！)。