目录
🍁1. 为什么要学习string类
🍁2. 标准库中的string类
🍁3. string类各种接口
默认成员函数
Iterators迭代器
capacity容量
Element access:元素访问
Modifiers:修改
字符串操作
成员变量
非成员函数
🍁4. 扩展阅读
- 本期主题：c++string类的介绍
- 博客主页：小峰同学
- 分享小编的在Linux中学习到的知识和遇到的问题
小编的能力有限，出现错误希望大家不吝赐做为程序员不会有人还没女朋友吧？
-
🍁1. 为什么要学习string类
C语言中的字符串
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。
两个 oj 题
ll字符串转整形数字
字符串相加
在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
-
🍁2. 标准库中的string类
字符串是表示字符序列的类
string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)
string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(关于更多的模板信息请参考basic_string)。
注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。还有 一些别的编码类型的字符串类，比如支持utf-16的u16string，支持utf-32的u32string。
总结：
- 1. string是表示字符串的字符串类
- 2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 比特就业课
- 3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char> string;
- 这里的是typedef basic_string<char> string ,而不是 typedef basic_string string，因为basic_string 是模板名不是类型，basic_string<char>才是类型。
- 4. 不能操作多字节或者变长字符的序列。
- 多字节的需要用到 u16string，或者 u32string ，或者 wstring 类型。
- 5.在使用string类时，必须包含#include<string>头文件 以及using namespace std;
-
🍁3. string类各种接口
由于我们主要用的是utf-8 编码的字符串，所以本文章，主要讲解string类。
默认成员函数
(cinstructor)构造
int main()
{
//string();
string s;
cout << s<<endl;//空字符
//string(const string & str);
string s1("zhang");
cout << s1 << endl;//zhang
const char* p = "zhang";
string s2(p);
cout << s2 << endl;//zhang
char arr[] = "zhang";
string s3(arr);
cout << s3 << endl;//zhang
//拷贝构造
//string (const string& str, size_t pos, size_t len = npos);
//npos 是 -1 size_t类型的一个很大的数。
string s4(s2, 2, 2);//从下标为2的位置向后两个字符。
cout << s4 << endl;//an
string s5(s2,2);//从下标为2的位置开始知道最后,npos是一个很大的数。
cout << s5 << endl;//ang
//string (const char* s);
//这里没有加 explicit 支持单参数或者第一个参数无默认值得构造其余均有默认值得构造函数，还具有类型转换的作用。
//string s6("zhang");//一样的
string s6 = "zhang";//这里会先那"zhang"去拷贝构造一个零时对象，然后拷贝构造给s6，（vs这里会优化，直接拿"zhang"去构造S6.
cout<< s6 << endl;//zhang
//string(const char* s, size_t n);
string s7(p, 2);//取出p字符串的前两个。
cout << s7 << endl;//zh
//string(size_t n, char c);
string s8(5, 'z');//5个'z'组成的字符串。
cout << s8 << endl;//zzzzz
//template <class InputIterator>
//string(InputIterator first, InputIterator last);
string::iterator first = s1.begin();//s1 = "zhang"
string::iterator last = s1.end();
string s9(first,last);
cout << s9 << endl;//zhang
return 0;
}
destructor销毁
operator= 赋值重载
int main()
{
string s1("zhang");
string s2;
s2 = s1;
cout << s2 << endl;
string s3;
s3 = "zhang";
cout << s3 << endl;
string s4;
s4 = 'z';
cout << s4 << endl;
return 0;
}三种遍历方式：
- 1.下标
- 2.范围for
- 3.迭代器
int main()
{
string s1("123456");
//下标
for (int i = 0; i < s1.size(); i++)
{
s1[i]++;
//本质生是调用 operator[];
}
cout << s1 << endl;//234567
//范围for
for (auto& i : s1)
{
i++;
}
cout << s1 << endl;//345678
//迭代器
string::iterator first = s1.begin();
while (first != s1.end())
{
(*first)++;
first++;
}
cout << s1 << endl;//456789
return 0;
}Iterators迭代器
- begin迭代器开端，重载了两个分别返回，iterator 和 const_iterator (参数是常量的，返回常量迭代器）
- end()迭代器的结束，重载了两个分别返回，iterator 和 const_iterator (参数是常量的，返回常量迭代器）
int main()
{
string s1("zhang");
string::iterator first = s1.begin();
string::iterator last = s1.end();
while (first != last){
cout << (*first);//这里可读可写
first++;
} cout << endl;
const string s2("zhang");//s2 是const 类型的
//string::iterator rfirst = s2.begin();//这个会报错
//string::iterator rlast = s2.end();//权限提升报错
string::const_iterator cfirst = s2.begin();
string::const_iterator clast = s2.end();
while (cfirst != clast){
cout << (*cfirst);//这里只是可读
cfirst++;
} cout << endl;
return 0;
}
- rbegin迭代器开端，重载了两个分别返回，reverse_iterator 和 const_reverse_iterator (参数是常量的，返回常量迭代器）
- rend()迭代器的结束，重载了两个分别返回，reverse_iterator 和 const_reverse_iterator (参数是常量的，返回常量迭代器）
int main()
{
string s2("123456");
string::reverse_iterator rfirst = s2.rbegin();
string::reverse_iterator rlast = s2.rend();
while (rfirst != rlast){
cout << (*rfirst);//这里可读可写
rfirst++;//注意这里是++ ，不是--
}//654321
cout << endl;
const string s3(s2);
string::const_reverse_iterator crfirst = s3.rbegin();
string::const_reverse_iterator crlast = s3.rend();
while (crfirst != crlast) {
cout << (*crfirst);//这里可读不可写
//(*crfirst)++;不可写
crfirst++;
}//654321
return 0;
}
capacity容量
int main()
{
string s1("123456");
//size()有效字符的长度
cout << s1.size() << endl;
//length()长度
cout << s1.length() << endl;
//max_size()最长长度（无意义）任何string类型都是一样的：4294967294
cout << s1.max_size() << endl;
//capacity() //容量空间的大小
cout << s1.capacity() << endl;
//clear//清空数据，到底清理空间与否，不知道（VS没有清理空间)
s1.clear();
cout << s1.capacity() << endl;
cout << s1.size() << endl;
s1.reserve(200);
//shrink_to_fit() //减小容量，让字符串减小其容量以适合其大小,可能不是和size相同
s1.shrink_to_fit();
cout << s1.capacity() << endl;
cout << s1.size() << endl;
string s("123456");
string s2(s);
//reserve()//提前开辟n个空间。
//提前看开辟空间，减小扩容次数，提高效率。
s2.reserve(100);//不会改变size
cout << s2.capacity() << endl;
cout << s2.size() << endl;
string s3(s);
string s4(s);
string s5(s);
//resize() //把string的长度改变到n
//n<size, 删除数据到n个长度。
//size<n<capacity, 插入数据，没有给定值默认是'\0'。
//n>capacity,插入数据顺便扩容,没有给定值默认是'\0'。
cout << s.capacity() << endl;//15
cout << s.size() << endl;//6
s3.resize(4);
cout << s3.size() << endl;
cout << s3.capacity() << endl;
cout << s3 << endl;
s4.resize(10,'x');
cout << s4.size() << endl;
cout << s4.capacity() << endl;
cout << s4 << endl;
s5.resize(20,'x');
cout << s5.size() << endl;
cout << s5.capacity() << endl;
cout << s5 << endl;
return 0;
}注意：
- 1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一 致，一般情况下基本都是用size()。
- 2. clear()只是将string中有效字符清空，一般不改变底层空间大小。
- 3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字 符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的 元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大 小，如果是将元素个数减少，底层空间总大小不变。
- 4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。
Element access:元素访问
Modifiers:修改
int main()
{
string s1 = "zhang";
string s2 = "xue";
s1 += s2;
cout << s1 << endl;//zhangxue
const char* pc = "feng";
s1 += pc;
cout << s1 << endl;//zhangxuefeng
char p = 'z';
s1 += p;
cout << s1 << endl;//zhangxuefengz
return 0;
}
int main()
{
string s1 = "zhang";
string s2 = "xue";
s1.append(s2);
cout << s1 << endl;//zhangxue
string s3 = "feng";
s1.append(s3, 0,2);
cout << s1 << endl;//zhangxuefe
char p1[] = "ng";
s1.append(p1);
cout << s1 << endl;//zhangxuefeng
char p2[] = "gao";
s1.append(p2,2);
cout << s1 << endl;//zhangxuefengga
s1.append(2, 'z');
cout << s1 << endl;//zhangxuefenggazz
return 0;
}
int main()
{
string s1;
s1.push_back('z');
s1.push_back('h');
s1.push_back('a');
s1.push_back('n');
s1.push_back('g');
cout << s1 << endl;//zhang
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1("gaowenya");
string s2 = "zhangxuefeng";
s1.assign(s2);
cout << s1 << endl;//zhangxuefeng
//s1.clear();
s1.assign("zhangxuefeng");
cout << s1 << endl;//zhangxuefeng
s1.clear();//这里是否手动清理与否都一样，assign会自己清理。
s1.assign(s2,5,3);
cout << s1 << endl;//xue
s1.clear();
s1.assign("zhangxuefeng", 5);
cout << s1 << endl;//zhang
s1.clear();
s1.assign(5, '5');
cout << s1 << endl;//55555
string::const_iterator first = s2.begin();
string::const_iterator back = s2.end();
first++;
back--;
s1.assign(first, back);
cout << s1 << endl;//hangxuefen
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1;
s1 = "0123456789";
const char* s2 = "zhangxuefeng";
string s3 = "gaowenya";
s1.insert(5, s3);
cout << s1<< endl;//01234gaowenya56789
s1 = "0123456789";
s1.insert(5, s3,3,3 );
cout << s1 << endl;//01234wen56789
s1 = "0123456789";
s1.insert(5, s2,5);
cout << s1 << endl;//01234zhang56789
s1 = "0123456789";
s1.insert(5, 5, 'z');
cout << s1 << endl;//01234zzzzz56789
string s5 = "0123456789";
//string::const_iterator p = s5.begin();
string::iterator p = s5.begin();
s5.insert(p+5, 5, 'z');
cout << s5 << endl;//01234zzzzz56789
s5.insert(p+1, 'z');
cout << s5 << endl;//0z1234zzzzz56789
string s4 = "zhangxuefeng";
string::iterator first = s4.begin();
string::iterator last = s4.end();
string s6 = "0123456789";
string::iterator p2 = s6.begin();
s6.insert(p2 + 5, first, last);
cout << s6 << endl;//01234zhangxuefeng56789
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1 = "zhangxuefeng";
s1.erase(5, 3);
cout << s1 << endl;//zhangfeng
string s2 = "zhangxuefeng";
s2.erase(5);
cout << s2 << endl;//zhang
string s3 = "zhangxuefeng";
string::iterator first = s3.begin();
s3.erase(first + 5);
cout << s3 << endl;//zhanguefeng
string s4 = "zhangxuefeng";
string::iterator first4 = s4.begin();
s4.erase(first4 + 5, first4 + 8);
cout << s4 << endl;//zhangfeng
return 0;
}
int main()
{
string s2 = "zhangxuefeng";
s2.replace(5, 3, "zhang");//xue 用 zhang 替换掉
cout << s2 << endl;
return 0;
} 
int main()
{
string s1("zhang");
string s2("gao");
cout << "交换前" << endl;
cout << s1 << endl;
cout << s2 << endl;
s1.swap(s2);
cout << "交换后" << endl;
cout << s1 << endl;
cout << s2 << endl;
return 0;
}注意：
- 1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般 情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
- 3.replace和assign区别：assign是先清理再替换，replace是直接替换不会清理。
字符串操作
#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main()
{
string str("Please split this sentence into tokens");
char* cstr = new char[str.length() + 1];
//strcpy(cstr, str.c_str());
std::strcpy(cstr, str.data());
// cstr now contains a c-string copy of str
char* p = strtok(cstr, " ");
while (p != 0)
{
cout << p << endl;
p = strtok(NULL, " ");
}
//Please
//split
//this
//sentence
//into
//tokens
delete[] cstr;
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
char buffer[20];
string s1("zhang xue feng");
size_t len = s1.copy(buffer, 3, 6);//注意3 6 的意义。
buffer[len] = '\0';
//注意要手动加上'\0'，copy不会自动加'\0'。
cout << buffer << endl;//xue
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str("There are two needles in this haystack with needles.");
string str2("needle");
// different member versions of find in the same order as above:
size_t found = str.find(str2);
if (found != string::npos)
cout << "first 'needle' found at: " << found << '\n';
found = str.find("needles are small", found + 1, 6);//这里不给出6就默认屁匹配别的函数重载
if (found != string::npos)
cout << "second 'needle' found at: " << found << '\n';
found = str.find("haystack");
if (found != string::npos)
cout << "'haystack' also found at: " << found << '\n';
found = str.find('.');
if (found != string::npos)
cout << "Period found at: " << found << '\n';
// let's replace the first needle:
str.replace(str.find(str2), str2.length(), "preposition");//把s2 对象内容换成preposition。
cout << str << '\n';
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1("test.cpp.tar");
size_t len1 = s1.find('.');
size_t len2 = s1.rfind('.');
cout << "find: " << s1.substr(len1) << endl;
cout << "rfind: " << s1.substr(len2) << endl;
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str("Please, replace the vowels in this sentence by asterisks.");
size_t found = str.find_first_of("aeiou");
int i = 5;
while (i--)
{
str[found] = '*';
found = str.find_first_of("aeiou", found + 1);
}
cout << str << '\n';
//Pl**s*, r*pl*c* the vowels in this sentence by asterisks.
return 0;
}#include<iostream>
#include<string>
using namespace std;
int main()
{
string str("Please, replace the vowels in this sentence by asterisks.");
size_t found = str.find_last_of("aeiou");
int i = 5;
while (i--)
{
str[found] = '*';
found = str.find_last_of("aeiou", found + 1);
}
cout << str << '\n';
//Please, replace the vowels in this sent*nc* by *st*r*sks.
return 0;
}
成员变量
非成员函数
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1("zhang");
const char* s2 = "xue";
string s3("feng");
string s4 = s1 + s2 + s3;
cout << s4 << endl;
//zhangxuefeng
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1("zhang");
string s2("gao");
s1.swap(s2);//这个是内置函数
swap(s1, s2);//这个是非成员函数，和全局内置的swap构成函数重载
return 0;
}
int main()
{
string str1;
getline(cin, str1);
//这样写遇见空格不会结束读取，只有遇到回车才会结束读取。
cout << str1 << endl;
string str2;
getline(cin, str2,'.');//只有遇到 '.' 才会结束读取。
//此时'\n'只是一个普通的字符串，用于刷新缓冲区。
cout << str2 << endl;
string str3;
cin >> str3;//遇见空格和回车会结束读取。
cout << str3 << endl;
return 0;
}
🍁4. 扩展阅读
vs和Linuxg++下string类的大小。
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
- vs下string的结构 string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，
- 联合体用来定义string中字 符串的存储空间：
- 当字符串长度小于16时，使用内部固定的字符数组来存放
- 当字符串长度大于等于16时，从堆上开辟空间
- 这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
- 其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
- 最后：还有一个指针做一些其他事情。 故总共占16+4+4+4=28个字节。
注意：下述结构是在64位平台下进行验证，64位平台下指针占8个字节
- G++下，string是通过写时拷贝实现的，string对象总共占8个字节，
- 内部只包含了一个指针，该指 针将来指向一块堆空间，
- 内部包含了如下字段： 空间总大小 字符串有效长度 引用计数
扩展好文
C++面试中STRING类的一种正确写法
stl中string怎么了？
