【玩转c++】c++ ：string类讲解（万字详解）
目录
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
string; - 这里的是typedef basic_string
string ,而不是 typedef basic_string string，因为basic_string 是模板名不是类型，basic_string 才是类型。 - 4. 不能操作多字节或者变长字符的序列。
- 多字节的需要用到 u16string，或者 u32string ，或者 wstring 类型。
- 5.在使用string类时，必须包含#include
头文件 以及using namespace std;
-
3. string类各种接口
由于我们主要用的是utf-8 编码的字符串，所以本文章，主要讲解string类。
默认成员函数
(cinstructor)构造
int main()
{
//string();
string s;
cout << s<
//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
//ncapacity,插入数据顺便扩容,没有给定值默认是'\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
#include
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
#include
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
#include
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
#include
#include
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
#include
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
#include
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
#include
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
#include
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
#include
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
#include
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
#include
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怎么了？