C++string类-创新互联
在c语言中，我们想要记录字符串需要创建一个字符串的数组，而c++则提供了另一种方式；
也就是这篇博客所说的string类；
目录
string类
string类的成员函数
string的构造函数
string的容量操作函数
size() / length() / capacity() 函数
reserve(size_t n) / resize(size_t n, char c) 函数
string类对象的访问及遍历操作
operator[] (size_t pos)
begin()/end()/rbegin()/rend()
迭代器——iterator
string类对象修改操作
string的其他函数
string类#include
作为字符串数组的升级版，string类自然也有它的独特之处——可变长数组；
c语言中的字符串数组只能在创建的时候定好初始的长度，数据长度不能超过数组长度；
而string类则没有这样的顾虑，虽然string变量都有自己的初始长度，但是它内部的成员函数会在输入数据超过初始长度的时候，会自动开辟空间，因此可以不用考虑数组长度；
此外，c++考虑到需要兼容c语言，也给string类重载了一个类似于c语言创建字符串数组的构造方式
但是这里有一点需要注意的是，虽然string类这里的创建方式和c语言的字符串数组一样；
但是它还是有很多不同的；
首先就是它并不是以 ‘\0’ 作为结束的标志；
我们可以看下它内部：
可以看到 s1 并不是以 '\0’ 作为结束标志的；
好，说了那么多 string类和 c语言数组的不同，那么来讲讲string类特有的功能吧；
string类的成员函数
string类中实现了许多成员函数，并且每种函数根据不同的情况有不同的重载；
这里我们就认识一下用的比较多的函数吧；
string的构造函数
| 函数名称 | 功能 |
| string() | 创造一个空的string对象 |
| string(const char* s) | 用一个字符串创建string对象 |
| string(size_t n,char c) | 用 n 个 c 字符创建string对象 |
| string(const string& s) | 用string对象拷贝构造一个string对象 |
void test3()
{
string s1;
string s2("abcd");
string s3(5, 'c');
string s4(s3);
cout<< "s1 = "<< s1<< endl;
cout<< "s2 = "<< s2<< endl;
cout<< "s3 = "<< s3<< endl;
cout<< "s4 = "<< s4<< endl;
}
我们能够看到，使用不同方式都成功创建了对应的字符串；
string的容量操作函数
| 函数名 | 功能 |
| size() | 返回字符串有效字符长度 |
| length() | 返回字符串有效字符长度 |
| capacity() | 返回空间总大小 |
| empty() | 检测是否为空 |
| clear() | 清空有效字符 |
| reserve(size_t n = 0) | 为字符串开辟空间 |
| resize(size_t n)/(size_t n ,char c) | 更改有效字符为n，多出的用字符c填充 |
c++中对于string的容量操作的函数可不少，我们先来一个一个学习吧；
size() / length() / capacity() 函数
void test4()
{
string s1 = "hello world!";
cout<< s1.size()<< endl;
cout<< s1.length()<< endl;
cout<< s1.capacity()<< endl;
}
首先是string的检查容量大小的函数；
我们发现 size() 函数和 length() 函数的返回值其实是一样的；
这是因为c++中，其他容器中的检查容量大小的函数都是 size() ,因此又引入了 size() 函数；
此外，我们发现 capacity() 函数的返回值和其他两个函数不一样，这是由string类的实现形成的；
string类的实现可以看做是一个char类型的指针（实际上比这更复杂一点，但是为了好理解可以视为是char类型的指针），并且内部除了 char* 指针，还有一个 size 和 capacity 变量；
而它们三者的关系类似下图：
实际上string对象开辟的大小为 capacity 这么大，而内部存储的字符串大小为size大小；
这就是为什么两个函数返回值不同的原因；
而 clear() 函数和empty()函数只在乎size()的大小；
而 size 和 capacity 的大小也是有成员变量可以修改的；
reserve(size_t n) / resize(size_t n, char c) 函数
这两个函数都是针对 capacity 变量和 size 变量而出现的函数；
我们先看看 resize 函数；
void test5()
{
string s1 = "hello world!";
cout<<"s1.size:"<< s1.size()<<' '<<"s1.capacity:"<
我们发现，resize() 更改了有效字符的长度，而 capacity 并未改变；
并且就算我们将 size 改回原来的长度，也无法恢复原来的数据；
而 reserve() 函数则不用多说，自然是修改 capacity 的大小了，但是它改变得比较奇怪；
void test7()
{
string s1 = "hello world!";
cout<< "s1.capacity : "<< s1.capacity()<< ' '<< s1<< endl;
s1.reserve(20);
cout<< "s1.capacity : "<< s1.capacity()<< ' '<< s1<< endl;
s1.reserve(10);
cout<< "s1.capacity : "<< s1.capacity()<< ' '<< s1<< endl;
}
我们发现，命名我们用 reserve 函数将 capacity 更改到20，但是实际上它的大小为31；
而更改到10则没变化；
这是为什么呢？
我们先去官网上看看reserve函数的描述：
大致意思是：
如果 n 比string 的capacity 大，那么编译器就会扩大容器的大小到 n 或者更大，而其他情况下，就根据容器的实现进行优化；
也就是说，reserve 函数并非根据你输入的数据来扩大容量，而是根据编译器内部的实现来进行扩大；
因此这就是为什么我们扩大到20的时候，会扩大到31；
而至于为什么我们想要缩小到10的时候，则没变呢？
虽然官网描述中说自由优化，实际上大部分编译器的实现当 n 小于 capacity 的时候，并不会对capacity 进行修改；
此外，官网的描述中，规定这个函数不会影响字符串的内容，因此当 n 小于 capacity 的时候就不作修改了；
string类对象的访问及遍历操作
| 函数名称 | 功能 |
| operator[] (size_t pos) | 返回 pos 位置的字符 |
| begin()+end() | 迭代器访问 |
| rbegin()+end() | 反向迭代器访问 |
| 范围for | c++支持的新型for循环访问 |
通过之前的实践，我们都知道 string 类对象都可以直接通过 cout 直接输出；
但是c++还提供了其他方法遍历 string 类对象；
operator[] (size_t pos)
首先就是运算符重载的 operator[] 访问了；
void test8()
{
string s1 = "hello world!";
for (int i = 0; i< s1.size(); i++)
{
cout<< s1[i];
}
cout<< endl;
}
这种访问方式就和 c 语言中访问字符数组一样了；
而这样的访问方式实际上是在类内部实现的；
begin()/end()/rbegin()/rend()
c++中有各种各样的容器，由于底层结构不同，所以各种容器的访问方式也不同；
但是c++为了保证容器的统一性，而创造出了迭代器——iterator，来保证容器访问方式的一致性；
迭代器——iterator
每个容器里面都有 iterator ，它是一个类似于指针的东西，用户通过迭代器能够访问容器的内容；
而每一个容器的 begin() 和 end() 函数都是为迭代器服务的；
接下来我们看看迭代器的使用方式吧！
void test9()
{
string s1 = "hello world!";
string::iterator is1 = s1.begin();
while (is1 != s1.end())
{
cout<< *is1;
is1++;
}
cout<< endl;
}
迭代器并非通过下标访问那样，只用比较 i 和 size 之间的大小；
迭代器只能通过和容器内部的 end() 返回值来比较，看是否到达变量的尾部；
并且，迭代器也有 const 类型的迭代器，用于被 const 修饰容器变量；
void test9()
{
const string s1 = "hello world!";
string::const_iterator is1 = s1.begin();
while (is1 != s1.end())
{
cout<< *is1;
is1++;
}
cout<< endl;
}
rbegin() 和 rend()
前面说过，这两个函数属于反向迭代器，而它的用法和普通迭代器一模一样；
void test9()
{
string s1 = "hello world!";
string::reverse_iterator is1 = s1.rbegin();
while (is1 != s1.rend())
{
cout<< *is1;
is1++;
}
cout<
通过反向迭代器，我们能够反向遍历容器内容的内容，其使用方式和普通迭代器是一样的；
范围for
范围for应该算是比较通用的，就不用过多讲解了；
void test9()
{
string s1 = "hello world!";
string::reverse_iterator is1 = s1.rbegin();
for (auto e : s1)
{
cout<< e;
}
cout<
string类对象修改操作
| 函数名 | 功能 |
| push_back(char c) | 在字符串后面添加c |
| append() //有多种重载 | 在字符串后面追加字符串 |
| operator+= | 在字符串后面追加字符串str |
| c_str() | 返回c格式字符串 |
| find()+npos | 在pos位置往后找字符c，并返回所在位置 |
| rfind() | 在pos位置往前找字符c，并返回所在位置 |
| erase() | 删除对应位置的元素，并且返回该元素的下一个位置 |
| substr | 在 str 中从pos位置截取 n 个字符，并返回 |
push_back(char c)
这个函数一次只能在字符串尾端放一个字符；
可以直接放，也能够放char类型的变量；
void test10()
{
string s1 = "hello world!";
char a = 'a';
cout<< s1<< endl;
s1.push_back('!');
s1.push_back('!');
s1.push_back('!');
s1.push_back('!');
s1.push_back(a);
cout<< s1<< endl;
}
这里可以看到成功的在尾端放入了字符；
append(const char * s)
append(const char* s ,size_t n)
append(const string & s)
append(const string& s,size_t subpos,size_t sublen);
append(size_t n ,char c)
template
append(InputIterator first,InputIterator last)
append这个函数有比较多的重载，接下来我们看看这些重载都是怎么用的吧：
void test10()
{
string s1 = "hello world!";
cout<< s1<< endl;
//append(const char * s)
s1.append("!!!");//添加！！！到s1尾部
cout<< s1<< endl;
//append(const char* s ,size_t n)
s1.append("++++++",5);//有6个 + ，但只加了5个上去
s1.append("@", 5);//n为5，但是由于字符串只有一个@，因此只加一个@
cout<< s1<< endl;
string s2 = "how are you?";
//append(const string & s)
s1.append(s2);//将s2添加上去
cout<< s1<< endl;
//append(const string& s,size_t subpos,size_t sublen);
s1.append(s2, 4,3);//在 s2 中从 subpos位置开始添加sublen长度的字符串到s1中
cout<< s1<< endl;
//append(size_t n ,char c)
s1.append(5, '*');//添加n个c到s1中
cout<< s1<< endl;
//template//append(InputIterator first,InputIterator last)
string s3 = "goodbye!";
s1.append(s3.begin(), s3.begin() + 3);//将s3中从begin()位置开始到begin()+3位置的字符添加到s1中
cout<< s1<< endl;
} 
用法如上
operator+=
相比于 append ，+= 的重载就比较少；
它的用法就是单纯的将 += 右边的字符串添加到左边字符串的尾端；
也是比较常用的一种接口；
void test11()
{
string s1 = "hello world!";
s1 += "!!";
cout<< s1<< endl;
string s2 = "how are you?";
s1 += s2;
cout<< s1<< endl;
s1 += '#';
cout<< s1<< endl;
}
const char* c_str() const
c_str()是一个普通的函数，就是返回string对象中的c字符串；
void test11()
{
string s1 = "hello world!";
cout<< s1.c_str()<< endl;
}
find(const string& s,size_t pos = 0)
find(const char* s,size_t pos = 0)
find(const char* s,size_t pos,size_t n)
find(char c,size_t pos = 0)
该函数就是在对象找寻找对应字符的位置，并且返回，若是没找到就会返回-1；
void test11()
{
string s1 = "hello world!";
string s2 = " wo";
//find(const string& s,size_t pos = 0)
int pos = s1.find(s2);//默认从0位置开始找
cout<< pos<< endl;
pos = s1.find(s2, 3);//从3位置开始找
cout<< pos<< endl;
//find(const char* s,size_t pos = 0)
pos = s1.find("llo", 0);//从0位置开始找
cout<< pos<< endl;
//find(const char* s,size_t pos,size_t n)
pos = s1.find("ld!",0,5);//从0位置开始找，只找5个位置
cout<< pos<< endl;
//find(char c,size_t pos = 0)
pos = s1.find('d', 0);//从0位置开始找
cout<< pos<< endl;
}
rfind(const string& s,size_t pos = npos)
rfind(const char* s,size_t pos = npos)
rfind(const char* s,size_t pos,size_t n)
rfind(char c,size_t pos = npos)
rfind 和 find 的使用方式一样，只不过是向前寻找，就不做多解释了；
而上面的 npos 实际上就是表示 string 字符串的尾部，因为 rfind 是向前寻找，因此缺省值给的尾部值；
erase(iterator p)
该函数会删除p位置的元素，然后将后面的元素一个一个往前移，然后返回p元素的下一个元素的位置；
void test1()
{
string s1 = "abcd";
string::iterator is1 = s1.begin();
is1 = s1.erase(is1);
cout<< *is1<< endl;
}
当使用erase函数的时候，若是在erase函数前面容器扩容了，就会导致迭代器失效
因此需要更新迭代器位置；
substr(size_t pos = 0,size_t len = npos)
void test12()
{
string s1 = "hello world!";
cout<
这个函数就是在字符串中从 pos 位置截取 len 长度的字符并返回；
不过原字符串不会消失；
string的其他函数
| 函数名 | 功能 |
| operator+ | 将两个string或者字符串加起来并返回 |
| operator>> | 整体输入string类 |
| operator<< | 整体输出string类 |
| getline() | 以行接收string类 |
| relational_operators | 比较大小 |
operator+
void test13()
{
string s1 = "hello world!";
cout<< s1<< endl;
s1 = s1 + "!!!";
cout<< s1<< endl;
}
这是一个运算符重载，返回一个 + 左边的字符串在前，右边的字符串在后组合而成的字符串；
当然，它也可以多个字符串相加；
void test13()
{
string s1 = "hello world!";
cout<< s1<< endl;
s1 = s1 + "!!!";
cout<< s1<< endl;
s1 = "!!!" + s1 + "!!!";
cout<< s1<< endl;
}
operator>>/ operator<<
这两个其实在前面就已经用过多次了：
void test13()
{
string s1;
cin >>s1;
cout<< s1;
}
其中的 operator>>和普通的输入一样，遇见空格或者换行就会中断，如上图；
getline(istream& in,string& s,char delim)
getline(istream& in,string& s)
为了能够按行输入string，c++有 getline 函数；
一种形式是遇到和 delim 相同的字符就停止
void test13()
{
string s1;
//getline(istream& in,string& s,char delim)
getline(cin, s1,'o');//按行接收字符串，遇到delim就结束,这里遇到o就不接收
cout<< s1<< endl;
}
一种解释单纯的按行接收
void test13()
{
string s1;
//getline(istream& in,string& s)
getline(cin, s1);//按行接收字符串
cout<< s1<< endl;
}
以上就是string类常用的几种函数。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
当前题目：C++string类-创新互联
链接分享：http://6mz.cn/article/igids.html