CPPstring类常用函数

合集下载

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类的常用方法1、string类的构造函数string() // 构造空串string(const char* s) // 把null结尾的字符串s拷贝到字符串中string(const string& str) // 拷贝构造函数，复制str到此串string(char c, int n) // 用n个字符c构造串string(const char* s, int n) // 拷贝字符数组中前n个字符2、string类的成员函数2.1 长度控制函数int size() const; // 返回字符串的长度int length() const; // 返回字符串的长度，等价于size()void resize(int n, char c); // 改变字符串长度，如果n 大于原来的长度，用字符c来填充2.2 内容操作函数string& operator=(const char* s); // 赋值，把s的内容复制到字符串中string& assign(const char* s); // 赋值，把s的内容复制到字符串中string& append(const char* s); // 把字符串s添加到串尾string& append(const char* s, int n); // 把s前n个字符添加到串尾string& insert(int p0, const char* s); // 在p0位置上插入字符串sstring& erase(int p0, int n); // 删除p0开始，n个字符int find(const char* s, int pos=0); // 在pos之后查找子串s，返回子串s在原串中的起始位置int find(char c, int pos=0); // 从pos开始查找字符c，返回字符c在原串中的位置int rfind(const char* substr,int pos=npos); // 从pos开始向前查找子串substr，返回子串substr在原串中的起始位置int rfind(char c, int pos=npos); // 从pos开始向前查找字符c，返回字符c在原串中的位置string substr(int pos, int n); // 返回串pos 位置开始，长度为n的子串2.3 字符串比较函数int compare(const char* s); // 比较原串和sint compare(int p0, int n, const char* s); // 比较串中p0开始，n个字符的子串和s2.4 数据访问函数char& operator[](int i); // 返回串中第i个字符的引用const char& operator[](int i) const; // 返回串中第i个字符的引用const char* c_str() const; // 返回字符串以null结尾的字符串2.5 输入输出函数ostream& operator<<(ostream& os, const string& str); // 输出字符串istream& operator>>(istream& is, string& str); // 输入字符串。

CPPstring类常用函数

C++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个字符的位置，但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++相关的string函数（memcpy、memove、strtok、strchr、st。。。

C++相关的string函数（memcpy、memove、strtok、strchr、st。

⼀、memcpy和memovevoid* memove(void*destin , void* source, size_t count) {//进⾏这样的判断是为了解决拷贝重叠的情况if (destin > source) {//这⾥拷贝的时候还可以提⾼效率//因为CPU单次可以拷贝的最⼤字节是8个//所以完全可以⽤long* 替代 char*(前提是count>8)char* a = (char*)destin;char* b = (char*)source;while (count--) {*b++ = *a++;}}else{char* a = (char*)destin + count;char* b = (char*)source + count;while (count--) {*b-- = *a--;}}return destin;}memove⼆、strtok参考博客三、strchr描述C 库函数 char *strchr(const char *str, int c) 在参数 str 所指向的字符串中搜索第⼀次出现字符 c（⼀个⽆符号字符）的位置。

声明下⾯是 strchr() 函数的声明。

char *strchr(const char *str, int c)参数str -- 要被检索的 C 字符串。

c -- 在 str 中要搜索的字符。

返回值该函数返回在字符串 str 中第⼀次出现字符 c 的位置，如果未找到该字符则返回 NULL。

实例四、strlcpy 原型： size_t strlcpy(char *dst, const char *src, size_t size); 功能：C语⾔标准库函数strlcpy，是更加安全版本的strcpy函数，在已知⽬的地址空间⼤⼩的情况下，把从src地址开始且含有'\0'结束符的字符串复制到以dest开始的地址空间, 并不会造成缓冲区溢出。

c语言string函数

c语言string函数
标准 C 语言的string.h头文件中定义了一组有用的函数，被称为字符串处理函数。

字符串就是由字母，数字和符号组成的一行字符序列，通常以字符串结尾显示。

它是一种数据抽象，是用来存储，分析，表示和处理应用程序中的文本数据的一种常见方式。

1.strlen()函数：该函数用来计算字符串的长度，不包括字符串结尾的null字符
'\0'。

该函数所返回的字符数不包括null字符，而只代表字符串中实际的字符数。

2.strcat()函数：该函数的作用是将字符串s2拼接到字符串s1的末尾。

这意味着s1的末尾会出现字符串s2的第一个字符，直到结束符'\0'。

4.strcmp()函数：该函数用于比较两个字符串s1和s2，如果s1>s2，函数会返回正值；如果s1=s2，函数会返回0；如果s1
5.strchr()函数：该函数用于在字符串s1中查找给定字符c。

如果成功，函数会返回指向找到字符的指针；否则，函数会返回NULL。

7.strtok()函数：该函数用于将字符串分割成一系列子字符串，每个子字符串以一个或多个指定的分隔符分隔。

以上就是标准C语言的string.h头文件中的一些常用的字符串处理函数，这些函数主要用于对字符串的操作，如切割，拼接，比较等。

由于 C 语言的数据结构比较简单，因此这个头文件函数的功能也是非常强大的，可以满足各种字符串处理的需求。

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. append() - 在字符串末尾添加另一个字符串或字符。

2. substr() - 返回指定位置和长度的子字符串。

3. replace() - 替换字符串中的字符或子字符串。

4. find() - 查找特定字符或子字符串在字符串中的位置。

5. erase() - 删除指定位置和长度的子字符串。

6. size() - 获取字符串的长度。

7. at() - 获取指定位置的字符。

9. c_str() - 将字符串转换为C风格字符串。

10. empty() - 检查字符串是否为空。

11. resize() - 调整字符串的大小。

12. substr() - 获取指定位置之后的所有字符。

13. reverse() - 反转字符串中的字符顺序。

14. push_back() - 在字符串末尾添加一个字符。

15. front() - 获取字符串的第一个字符。

16. back() - 获取字符串的最后一个字符。

17. insert() - 在指定位置插入字符或子字符串。

18. find_first_of() - 查找字符串中第一次出现的特定字符。

19. find_last_of() - 查找字符串中最后一次出现的特定字符。

20. substr() - 获取指定位置和长度的子字符串。

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的各种函数（系统学习）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的连接，返回连接的结果。

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): 根据给定的分隔符分割字符串。

c语言string类的常用方法

c语言string类的常用方法在C语言中，字符串通常表示为字符数组，而不是像C++中的`std::string`类。

但我们可以使用一些函数来处理字符串，这些函数在``库中定义。

以下是C语言中处理字符串的一些常用方法：1. `strlen()`: 返回字符串的长度，不包括终止字符'\0'。

```csize_t len = strlen("Hello"); // len 为 5```2. `strcpy()`: 将一个字符串复制到另一个字符串。

```cchar src[] = "Hello";char dest[10];strcpy(dest, src); // dest 现在是 "Hello"```3. `strcat()`: 将一个字符串连接到另一个字符串的末尾。

```cchar src1[] = "Hello";char src2[] = ", World!";strcat(src1, src2); // src1 现在为 "Hello, World!" ```4. `strcmp()`: 比较两个字符串。

```cchar str1[] = "Hello";char str2[] = "World";if (strcmp(str1, str2) < 0) {printf("str1 is less than str2\n");} else if (strcmp(str1, str2) > 0) {printf("str1 is greater than str2\n");} else {printf("str1 is equal to str2\n");}```5. `strstr()`: 在字符串中查找子字符串。

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()；此成员函数有参数，参数是下标。

c中string函数库常用函数

c中string函数库常用函数1.strcpy：将字符串从源头复制到目标地址，即复制字符串。

2.strncpy：复制字符串的限定长度，可以指定字符串的长度。

3.strcat：将一个字符串连接到另一个字符串的尾部，即将一个字符串附加到另一个字符串之后，并返回组合后新字符串的起始地址。

4.strncat：将一个字符串连接到另一个字符串的尾部，但可以指定字符串的连接长度。

5.strcmp：比较两个字符串是否相等，如果相等返回闅0，如果不等返回一个值< 0或 > 0。

6.strncmp：比较两个字符串是否相等，但可以指定比较的长度。

7.strlen：计算字符串的长度。

8.strstr：查找一个字符串在另一个字符串中第一次出现的位置，如果没有找到则返回NULL。

9.strspn：获得“字符串1”中符合“字符串2”中所包含字符的最长子字符串长度。

10.strcspn：获得“字符串1”中不符合“字符串2”中所包含字符的最长子字符串长度。

11.strpbrk：在s1所指的字符串中查找第一次出现在s2所指的字符串中字符的位置，如果没有找到则返回NULL。

12.strchr：在字符串中查找指定字符的第一次出现的位置，如果没有找到则返回NULL。

13.strrchr：在字符串中查找指定字符的最后一次出现的位置，如果没有找到则返回NULL。

14.strtok：使用指定的分隔符将字符串划分称片段，并返回已划分出的第一片段，如果没有找到则返回NULL。

15.strupr：将字符串转换成全部大写字母。

16.strlwr：将字符串转换成全部小写字母。

17.memcpy：将内存块从源头复制到目标地址，即复制内存块。

18.memmove：将内存块从源头移动到目标地址，即移动内存块。

19.memcmp：比较两个内存块是否相等，如果相等返回0，如果不等返回一个值< 0或 > 0。

20.memchr：在内存块中查找指定字符的第一次出现的位置，如果没有找到则返回NULL。

cstring常用方法

cstring常用方法
cstring常用方法是C++中对字符串进行操作的函数集合，包括字符串长度、字符串复制、字符串连接、字符串比较等常用操作。

下面列举一些常用的cstring方法：
1. strlen：用于获取字符串的长度，返回字符串中字符的个数。

2. strcpy：用于将一个字符串复制到另一个字符串中，返回复制后的字符串。

3. strcat：用于将两个字符串连接成为一个新的字符串，返回连接后的字符串。

4. strcmp：用于比较两个字符串的大小，返回值为0表示相等，大于0表示第一个字符串大于第二个字符串，小于0表示第一个字符串小于第二个字符串。

5. strstr：用于在一个字符串中查找另一个字符串，返回值为第一个字符串中第一个匹配到的子串的起始位置。

6. strchr：用于在一个字符串中查找一个字符，返回值为第一个匹配到的字符的位置。

7. strtok：用于将一个字符串分割成若干个子串，返回分割后的第一个子串。

除了上述的常用方法外，cstring还包括了许多其他方法，如strncpy、strnlen、strncat等等。

在实际编程中，cstring的方法可以大大简化字符串操作的代码量，提高程序的效率和可读性。

- 1 -。

c++ string的构造函数

c++ string的构造函数C++中的string类提供了多种构造函数，用于创建字符串对象并进行初始化。

这些构造函数可以接受不同的参数类型，以便根据需要创建字符串。

1. 默认构造函数：string类的默认构造函数创建一个空字符串对象，没有任何字符。

示例：```cppstring s; // 创建一个空字符串对象```2. 字符串字面值构造函数：string类还提供了从C风格字符串（字符串字面值）创建字符串对象的构造函数。

这个构造函数将字符串字面值作为参数，并将其复制到新创建的字符串对象中。

示例：```cppstring s('Hello World'); // 从字符串字面值创建字符串对象 ```3. 重复字符构造函数：这个构造函数接受一个字符和一个整数作为参数，用于创建一个由指定数量的重复字符组成的字符串对象。

示例：```cppstring s(5, 'a'); // 创建一个由5个重复的字符'a'组成的字符串对象```4. 拷贝构造函数：拷贝构造函数用于创建一个新的字符串对象，并将另一个字符串对象的内容复制到新对象中。

示例：```cppstring s1('Hello');string s2(s1); // 使用拷贝构造函数创建一个新的字符串对象，并将s1的内容复制到s2中```这些是string类的一些常用构造函数，它们可以根据不同的需求创建字符串对象并进行初始化。

除了这些构造函数之外，string类还提供了其他一些构造函数，如从字符指针、迭代器范围等创建字符串对象的构造函数。

通过选择适当的构造函数，我们可以方便地创建并初始化字符串对象。

c++ string类型的各种函数

c++ string类型的各种函数C++中的string类型是标准库提供的一个字符串类，它有许多实用的函数和方法。

以下是一些常用的string类型函数：1.构造函数和析构函数：○默认构造函数：string()，创建一个空字符串。

○拷贝构造函数：string(const string &str)，创建一个与str 相同的字符串。

○字符串字面值构造函数：string("string_literal")，创建一个字符串字面值的副本。

○初始化列表构造函数：string(char c, int n)，创建一个包含n个字符c的字符串。

2.字符串操作函数：○+：字符串连接操作，string s1 + s2。

○+=：字符串连接赋值操作，s1 += s2。

○[]：字符串切片操作，string s[begin, end)。

○at：字符串切片操作，string s.at(n)。

○find：查找子字符串在字符串中的位置，size_t find(const string &substr)。

○rfind：从字符串末尾开始查找子字符串的位置，size_t rfind(const string &substr)。

○substr：提取字符串的一部分，string substr(size_t pos, size_t len)。

○insert：在指定位置插入字符或子字符串，void insert(size_t pos, char c)或void insert(size_t pos, const string &substr)。

○erase：删除字符串中的字符或子字符串，void erase(size_t pos, size_t len)。

○replace：替换字符串中的子字符串，void replace(size_t pos, size_t len, const string &substr)。

c++ string的函数

c++ string的函数C++中的字符串(string)是一个非常重要的数据类型，也是一个非常强大的工具。

它提供了一组用于管理字符串的函数和操作符。

本文将会介绍C++中常用的一些字符串函数，详细说明它们的使用方法。

1. length()功能：获取字符串的长度说明：这个函数的返回值就是字符串的长度。

2. substr()功能：从字符串中提取一个子串语法：string.substr(pos, len)说明：pos表示要提取的子串的起始位置，len表示要提取的子串的长度。

如果省略len参数，则将一直提取到字符串的末尾。

3. append()功能：将字符串加到另一个字符串的末尾说明：这个函数将把string2加到string1的末尾。

也可以使用 += 运算符，如string1 += string2。

4. find()函数名称：find()说明：这个函数从字符串的start_position位置开始查找子串substring。

如果查找到，返回子串的位置。

如果没有查找到，返回string::npos。

函数名称：replace()说明：start表示要替换的子串的起始位置，length表示要替换的子串的长度，string表示用来替换的新字符串。

6. erase()说明：如果string1等于string2，则返回0；如果string1大于string2，则返回一个正数；如果string1小于string2，则返回一个负数。

功能：从输入流中读取一行说明：从标准输入流中读取一行，并存储在string中。

9. to_string()功能：将数字转换为字符串说明：number表示要转换的数字。

这个函数将把数字转换为字符串并返回。

说明：string表示要转换的字符串，index表示转换后的字符串中第一个非数字字符的位置，base表示数字的基数(可选的，默认为10)。

返回一个整数值。

总结这些函数并不是C++中所有涉及字符串的函数，但是它们是其中最常用的，也最有用的一些函数。

c++的string的find函数

c++的string的find函数摘要：1.C++中的string 类2.string 类的find 函数3.find 函数的基本用法4.find 函数的示例5.find 函数的返回值6.结论正文：C++是一种广泛使用的编程语言，它具有丰富的库函数，使得程序设计更加简洁和高效。

在C++中，字符串是一种非常重要的数据类型，它被广泛应用于各种程序设计中。

C++中的string 类是处理字符串的一种常用方法，它提供了许多实用的成员函数，如find 函数。

string 类的find 函数是一种用于查找给定子串或字符在字符串中首次出现的位置的函数。

它的基本用法如下：```cppsize_t find(const string& str, const string& pattern);```其中，str 是要查找的字符串，pattern 是要查找的子串或字符。

该函数返回找到的子串或字符在字符串中的位置，如果未找到，则返回string::npos。

下面是一个find 函数的示例：```cpp#include <iostream>#include <string>using namespace std;int main() {string str = "hello, world!";string pattern = "world";size_t pos = str.find(pattern);if (pos!= string::npos) {cout << "找到子串"" << pattern << ""，位置为：" << pos << endl;} else {cout << "未找到子串"" << pattern << """ << endl;}return 0;}```输出结果为：```找到子串"world"，位置为：6```从示例中可以看出，find 函数可以方便地查找字符串中首次出现的子串或字符。

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

函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。

string的赋值：string &operator=(const string &s);//把字符串s赋给当前字符串string &assign(const char *s);//用c类型字符串s赋值string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值string &assign(const string &s);//把字符串s赋给当前字符串string &assign(int n,char c);//用n个字符c赋值给当前字符串string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串string的连接：string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾string &append(const char *s); //把c类型字符串s连接到当前字符串结尾string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾string &append(const string &s); //同operator+=()string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾string &append(int n,char c); //在当前字符串结尾添加n个字符cstring &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾string的比较：bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等运算符">","<",">=","<=","!="均被重载用于字符串的比较；int compare(const string &s) const;//比较当前字符串和s的大小int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小int compare(const char *s) const;int compare(int pos, int n,const char *s) const;int compare(int pos, int n,const char *s, int pos2) const;compare函数在>时返回1，<时返回-1，==时返回0string的子串：string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串string的交换：void swap(string &s2); //交换当前字符串与s2的值string类的查找函数：int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置//查找成功时返回所在位置，失败返回string::npos的值int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置int rfind(const char *s, int pos = npos) const;int rfind(const char *s, int pos, int n = npos) const;int rfind(const string &s,int pos = npos) const;//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置int find_first_of(const char *s, int pos = 0) const;int find_first_of(const char *s, int pos, int n) const;int find_first_of(const string &s,int pos = 0) const;//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。

查找失败返回string::nposint find_first_not_of(char c, int pos = 0) const;int find_first_not_of(const char *s, int pos = 0) const;int find_first_not_of(const char *s, int pos,int n) const;int find_first_not_of(const string &s,int pos = 0) const;//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::nposint find_last_of(char c, int pos = npos) const;int find_last_of(const char *s, int pos = npos) const;int find_last_of(const char *s, int pos, int n = npos) const;int find_last_of(const string &s,int pos = npos) const;int find_last_not_of(char c, int pos = npos) const;int find_last_not_of(const char *s, int pos = npos) const;int find_last_not_of(const char *s, int pos, int n) const;int find_last_not_of(const string &s,int pos = npos) const;//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找string类的替换函数：string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符cstring &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串sstring &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串sstring &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符cstring &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串string类的插入函数：string &insert(int p0, const char *s);string &insert(int p0, const char *s, int n);string &insert(int p0,const string &s);string &insert(int p0,const string &s, int pos, int n);//前4个函数在p0位置插入字符串s中pos开始的前n个字符string &insert(int p0, int n, char c);//此函数在p0处插入n个字符citerator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符void insert(iterator it, int n, char c);//在it处插入n个字符cstring类的删除函数iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串string类的迭代器处理：string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。