C++ string 成员函数汇总

合集下载

C语言string.h库中的常用函数

C语⾔string.h库中的常⽤函数strcat、strncat、strcmp、strncmp、strcpy、strncpy、strdup 》strcatchar strcat(char * str1,char * str2);函数功能: 把字符串str2接到str1后⾯,str1最后的'\0'被取消函数返回: str1参数说明:所属⽂件: <string.h>#include <stdio.h>#include <string.h>int main(){char buffer[80];strcpy(buffer,"Hello ");strcat(buffer,"world");printf("%s\n",buffer);return 0;}》strncatchar strncat(char *dest, const char *src, size_t maxlen)函数功能: 将字符串src中前maxlen个字符连接到dest中函数返回:参数说明:所属⽂件: <string.h>#include <stdio.h>#include <string.h>char buffer[80];int main(){strcpy(buffer,"Hello ");strncat(buffer,"world",8);printf("%s\n",buffer);strncat(buffer,"*************",4);printf("%s\n",buffer);return 0;}》strcmpint strcmp(char * str1,char * str2);函数功能: ⽐较两个字符串str1,str2.函数返回: str1<str2,返回负数;str1=str2,返回 0;str1>str2,返回正数.参数说明:所属⽂件: <string.h>#include <string.h>#include <stdio.h>int main(){char *buf1="aaa", *buf2="bbb",*buf3="ccc";int ptr;ptr=strcmp(buf2, buf1);if(ptr>0)printf("buffer 2 is greater thanbuffer 1\n");elseprintf("buffer 2 is less thanbuffer 1\n");ptr=strcmp(buf2, buf3);if(ptr>0)printf("buffer 2 is greater thanbuffer 3\n");elseprintf("buffer 2 is less thanbuffer 3\n");return 0;}》strncmpint strncmp(char *str1,char *str2,int count)函数功能: 对str1和str2中的前count个字符按字典顺序⽐较函数返回: ⼩于0：str1<str2，等于0：str1=str2，⼤于0：str1>str2参数说明: str1,str2-待⽐较的字符串，count-⽐较的长度所属⽂件: <string.h>#include<string.h>#include<stdio.h>int main(){char str1[] ="aabbc";//char str2[] = "abbcd";////为使测试程序更简练，此处假定了strncmp只返回-1,0,1三个数char res_info[] = {'<','=','>'};int res;//前1个字符⽐较res = strncmp(str1, str2, 1);printf("1：str1%c str2\n", res_info[res+1]);//前3个字符⽐较res = strncmp(str1, str2, 3);printf("3：str1%c str2\n", res_info[res+1]);}》strcpychar strcpy(char* str1,char* str2)函数功能: 把str2指向的字符串拷贝到str1中去函数返回: 返回str1,即指向str1的指针参数说明:所属⽂件: <string.h>#include <stdio.h>#include <string.h>int main(){char string[10];char *str1="abcdefghi";strcpy(string,str1);printf("the string is:%s\n",string);return 0;}》strncpychar *strncpy(char *dest, const char *src，intcount)函数功能: 将字符串src中的count个字符拷贝到字符串dest中去函数返回: 指向dest的指针参数说明: dest-⽬的字符串，src-源字符串，count-拷贝的字符个数所属⽂件: <string.h>#include<stdio.h>#include<string.h>int main(){char*src = "bbbbbbbbbbbbbbbbbbbb";//20 'b'schar dest[50] ="aaaaaaaaaaaaaaaaaaaa";//20 'a'sputs(dest);strncpy(dest, src, 10);puts(dest);return0;}》strdupchar strdup(const char *s)函数功能: 字符串拷贝，⽬的空间由该函数分配函数返回: 指向拷贝后的字符串指针参数说明: src-待拷贝的源字符串所属⽂件: <string.h>#include <stdio.h>#include <string.h>#include <alloc.h>int main(){char *dup_str, *string="abcde"; dup_str=strdup(string);printf("%s", dup_str);free(dup_str);return 0;}。

C中string的成员函数

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类的常用方法

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); // 输入字符串。

c++ string操作函数

c++ string操作函数1. 引言1.1 概述C++是一种功能强大的编程语言，为程序员提供了许多方便的字符串处理功能。

在C++中，string类是一种特殊的数据类型，用于处理字符串。

string 操作函数可以帮助我们实现对字符串的各种操作，如连接、截取、查找、替换等。

1.2 文章结构本文主要介绍C++中常用的string操作函数。

文章分为五个部分，分别是引言、C++中的string操作函数、string的遍历和查找函数、字符串转换和格式化函数以及结论。

每个部分包含了若干子章节，以便读者更好地理解和使用这些函数。

1.3 目的本文旨在向读者介绍C++中常用的string操作函数，并通过清晰明了的示例代码展示它们的具体用法。

通过学习这些函数，读者将能够更加高效地处理字符串，并且扩展自己在C++中字符串处理方面的知识和能力。

同时，本文还将提供一些进一步学习资源或实践方法，帮助读者深入掌握这些内容并且迈向更高级别的应用。

（注意：由于markdown格式无法直接转换为普通文本格式答案，请将以上普通文本复制到你的长文中）2. C++中的string操作函数2.1 string类简介在C++中，string是一个非常有用的类，它提供了许多功能强大且易于使用的字符串操作函数。

使用string类可以方便地进行字符串的创建、赋值、拼接和修改等操作。

2.2 基本字符串操作函数在C++中，string类提供了一些基本的字符串操作函数，如下所示：- `length()`：返回当前字符串的长度。

- `size()`：与`length()`功能相同，返回当前字符串的长度。

- `empty()`：检查当前字符串是否为空。

- `clear()`：清空当前字符串内容。

- `append(str)`：将指定的str添加到当前字符串末尾。

- `insert(pos, str)`：在指定位置pos插入str。

2.3 字符串连接和截取函数当需要对两个或多个字符串进行连接时，可以使用以下函数：- `+`运算符：使用`+`运算符可以直接将两个字符串连接起来。

c语言string函数详解

c语言string函数详解linux kernel code : kernel/lib/string.cstrsep，strtok，strchr ,strstr ......PS：本文包含了大部分strings函数的说明，并附带举例说明。

本来想自己整理一下的，发现已经有前辈整理过了，就转了过来。

@函数原型: char *strdup(const char *s)函数功能: 字符串拷贝，目的空间由该函数分配函数返回: 指向拷贝后的字符串指针参数说明: src-待拷贝的源字符串所属文件: <string.h>[cpp] view plain copy1.#include <stdio.h>2.#include <string.h>3.#include <alloc.h>4.int main()5.{6.char *dup_str, *string="abcde";7.dup_str=strdup(string);8.printf("%s", dup_str);9.free(dup_str);10.return 0;11.}@函数名称: strcpy函数原型: char* strcpy(char* str1,char* str2);函数功能: 把str2指向的字符串拷贝到str1中去函数返回: 返回str1,即指向str1的指针参数说明:所属文件: <string.h>[cpp] view plain copy1.#include <stdio.h>2.#include <string.h>3.int main()4.{5.char string[10];6.char *str1="abcdefghi";7.strcpy(string,str1);8.printf("the string is:%s\n",string);9.return 0;10.}@函数名称: strncpy函数原型: char *strncpy(char *dest, const char *src，intcount)函数功能: 将字符串src中的count个字符拷贝到字符串dest中去函数返回: 指向dest的指针参数说明: dest-目的字符串，src-源字符串，count-拷贝的字符个数所属文件: <string.h>[cpp] view plain copy1.#include<stdio.h>2.#include<string.h>3.int main()4.{5.char*src = "bbbbbbbbbbbbbbbbbbbb";//20 'b's6.char dest[50] ="aaaaaaaaaaaaaaaaaaaa";//20 'a's7.8.puts(dest);9.strncpy(dest, src, 10);10.11.puts(dest);12.return0;13.}输出：[cpp] view plain copy1./*******************************************2.aaaaaaaaaaaaaaaaaaaa3.bbbbbbbbbbaaaaaaaaaa4.*******************************************/注意：strncpy只复制指定长度的字符，不会自动在末尾加'\0'。

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常⽤函数⽤法总结标准c++中string类函数介绍之所以抛弃char*的字符串⽽选⽤C++标准程序库中的string类，是因为他和前者⽐较起来，不必担⼼内存是否⾜够、字符串长度等等，⽽且作为⼀个类出现，他集成的操作函数⾜以完成我们⼤多数情况下(甚⾄是100%)的需要。

我们可以⽤ = 进⾏赋值操作，== 进⾏⽐较，+ 做串联（是不是很简单?）。

我们尽可以把它看成是C++的基本数据类型。

好了，进⼊正题………⾸先，为了在我们的程序中使⽤string类型，我们必须包含头⽂件 <string>。

如下：#include <string> //注意这⾥不是string.h string.h是C字符串头⽂件#include <string>using namespace std;声明⼀个字符串变量很简单：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() //销毁所有字符，释放内存都很简单，我就不解释了。

string的常用库函数（主要摘自谭浩强版C语言教材）

string的常⽤库函数（主要摘⾃谭浩强版C语⾔教材）这⾥对C程序设计第五版（谭浩强）的⼀些string常⽤库函数在此总结以下，以便记忆同时注意提醒⾃⼰以下，字符串通常是⽤双引号，⽽单⼀的⼀个字符⽤单引号1.puts函数常⽤形式：puts(字符数组) ——————输出字符数组/字符串puts(str);2.gets函数常⽤形式：gets(字符数组)——————输⼊字符串，通常⽤于输⼊字符数组gets(str);3.strcat函数常⽤形式：strcat(字符数组1，字符数组2)——————把两个字符数组中的字符串连接起来，把字符数组1和字符数组2中的字符串连接之后，放在字符数组1中，调⽤之后的结果是字符数组1的地址。

也就是新得到的字符数组1中的字符串是原字符数组1和字符数组2中字符串的结合。

strcat(str1,str2);4.strcpy和strncpy函数常⽤形式：strcpy(字符数组1,字符数组2)——————将字符串2复制到字符数组1中去，在调⽤之后得到新的字符数组1，其字符串为字符数组2的字符串。

strcpy(str1,str1); strcpy(str1,"i love china")strncpy(字符数组1，字符数组2，位数）——————将字符数组2中的前n位字符复制到数组1中strncpy(str1,str2,2)//将字符数组2的前两个字符复制到字符数组1中5.strcmp函数常⽤形式：strcmp(字符串1，字符串2)——————⽐较字符串1和字符串2的⼤⼩strcmp(str1,str2);strcmp("china"，"korea");strcmp("china",str1);注意返回值:如果字符串1与字符串2相同，返回值0如果字符串1⼤于字符串2，返回值为⼀个正整数如果字符串1⼩于字符串2，返回值为⼀个负整数6.strlen函数常⽤形式：strlen(字符数组)——————测量字符串长度n=strlen(str1);n的值即为字符串的长度。

c++ string 和 c string 常用函数

C++ string 的常用函数1、string类的构造函数：string(const char *s); //用c字符串s初始化string(int n,char c); //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。

当构造的string太长而无法表达时会抛出length_error异常2、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为起始位置的字符数组中，返回实际拷贝的数目3、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填充不足的部分4、string类的输入输出操作:string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。

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类的常用函数

C++string类常用函数string类的构造函数：string(const char *s); //用c字符串s初始化string(int n,char c); //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；strings2="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<<用于输出操作。

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语言常用的字符串函数总结

C语⾔常⽤的字符串函数总结⼀、strlen1、原型：size_t strlen(char const* string);2、功能：返回字符串 string 的长度（不包含字符串终⽌符NUL）3、注意：size_t是⼀个⽆符号整数类型4、举例：1 #include <stdio.h>2 #include <stdlib.h>3 #include <string.h>45int main()6 {7char* y = "abcdef";8char* x = "abcd";910if (strlen(x) >= strlen(y)) {11 printf("1: strlen(x) >= strlen(y)\n");12 } else {13 printf("1: strlen(x) < strlen(y)\n");14 }1516/* 由于strlen(x)返回的是⼀个size_t，所以strlen(x) - strlen(y) >= 0恒成⽴，17 * 导致出现错误的结论18*/19if (strlen(x) - strlen(y) >= 0) {20 printf("2: strlen(x) - strlen(y) >= 0\n");21 } else {22 printf("2: strlen(x) - strlen(y) < 0\n");23 }2425// 将size_t转换为int类型后，可以返回正确的值26if ((int)(strlen(x)) - (int)(strlen(y)) >= 0) {27 printf("3: (int)strlen(x) - strlen(y) >= 0\n");28 } else {29 printf("3: (int)strlen(x) - strlen(y) < 0\n");30 }3132return0;33 }View Code运⾏结果：⼆、strcpy1、原型：char *strcpy(char *dst, char const *src);2、功能：将参数src字符串复制到dst参数中。

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

CString类型常用函数（mfcc++）

CString类一、常用成员函数1．int GetLength（）const;说明：获取CString类对象包含字符串的长度（字符数）。

2．BOOL IsEmpty（）const;说明：测试CString类对象包含的字符串是否为空。

3．void Empty（）;说明：使CString类对象包含的字符串为空字符串。

4．TCHAR GetAt（int nIndex ）const;说明：获得字符串指定位置处的字符。

5．TCHAR operator []（int nIndex ）const;说明：获得字符串指定位置处的字符，作用和GetAt（）一样。

6．void SetAt（int nIndex, TCHAR ch ）;说明：设定字符串指定位置处的字符。

7．operator LPCTSTR （）const;说明：返回指向储存在CString类对象内的字符串指针。

8．MidMid函数有两个重载函数：CString Mid（int nFirst ）const; throw（CMemoryException ）;获取从nFirst位置开始的子串。

CString Mid（int nFirst, int nCount ）const; throw（CMemoryException ）;获取从nFirst位置开始包含nCount个字符的子串。

9.CString Left（int nCount ）const;throw（CMemoryException ）;说明：获取字符串左边nCount长度的字符串。

10．CString Right（int nCount ）const; throw（CMemoryException ）;说明：获取字符串右边nCount长度的字符串。

11．CString SpanIncluding（LPCTSTR lpszCharSet ）const;throw （CMemoryException ）;说明：从字符串中提取包含在指定字符集lpszCharSet中的字符的子串。

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。

C++string常用函数总结

C++string常⽤函数总结头⽂件：#include<string>[注]：⽂中关于个数的参数⽂档中为 size_type 型，更本质是 size_t 型，因为typedef size_t size_type，⽽ size_t 在不同系统内实现不同，⼤概为 unsigned int 型，为简便起见，本⽂均写为 int 型。

另外，string 的许多函数都有各种重载，本⽂所写的只是较常⽤的。

赋值string 类型的变量可以直接赋值：string str = "hello world"; //可以直接赋值cout << str << endl; //string 不⽀持 C 语⾔，因此输出只能使⽤ cout 不能使⽤ printf输出：hello world使⽤ string 的构造函数来实现拷贝的效果：string substr = string(string str, int start, int num);由此得到的 substr 是截取字符串 str 从 start 起 num 个字符。

关于⼦串还有函数 substr(int start, int num) ，其效果同上。

举例如下：//返回⼦字符串 substrstring str = "012345678";string substr = str.substr(1,3);cout << substr << endl;substr = string(str, 2, 5);cout << substr << endl;输出：12323456长度函数 string.size() 和 string.length() 均可返回本字符串长度，返回值类型为 int(size_t) 。

运算符字符串连接 +举例如下：string str1 = "abc", str2 = "def";str = str1 + str2;cout << str << endl;输出：abcdef字典序⽐较：> < >= <= != ==遍历/访问使⽤下标 [] 访问同字符数组。

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)。

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

C++ string 成员函数汇总原址：/shazi129/blog/item/c3ad059b636db8b6c9eaf490.htmlstring类的构造函数：string(const char *s); //用c字符串s初始化string(int n,char c); //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。

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<<用于输出操作。

函数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::npos int 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个字符c string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s string &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）之间的部分替换为串s string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c string &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，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。