string类部分（C++）

1. string类

1.1 auto和范围for

auto关键词：

范围for：

1.2 string类的常用接口说明

a）string类对象的常见构造

b） string类对象的容量操作

size与length：

capacity:

empty:

clear:

reserve:

1.reserve（n）中n<>

2.reserve（n）中n>size并且n<>

3.reserve（n）中n>capacity时

resize:

1.resize(n),n：<>

2.resize(n),n>size并且n：<>

3.resize(n),n>capacity:

1.3 string类对象的访问及遍历操作

operator[]：

begin+end:

rbegin+rend：

1.4. string类对象的修改操作

push_back:

append：

string& append(const string&str)和string& append(const char*s):

string& append(const string&str,size_t subpos,size_t sublen)

operator+=：

c_str：

find+nops：

size_t find(char c, size_t pos=0) const：

rfind：

size_t rfind(char c, size_t pos=0) const：

substr：

1.5 string类非成员函数

operator>>和operator<<:

getline:

1. string类

在使用string类时，必须包含#include头文件以及using namespace std;

1.1 auto和范围for

auto关键词：

a）在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

b）用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

c）当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

d）auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

e）auto不能直接用来声明数组

举例b）：

int x = 10;auto y = &x;
auto* z = &x;auto& m = x;cout << typeid(x).name() << endl;
cout << typeid(y).name() << endl;
cout << typeid(z).name() << endl;
cout << typeid(m).name() << endl;

结果：

这里auto y=&x；和auto* z=&x；是达到相同的效果，但是要注意如果是auto*就右边必须是取地址否则就会报错，不能写成auto* y=x，但第二种auto y=&x，就会自动将其识别为int*类型。

举例c）：

auto aa = 1, bb = 2;
// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
auto cc = 3, dd = 4.0;

第二种定义就会报错，当cc=3事，编译器就会认为这是int类型，但后面dd不匹配，就会报错。

举例d）：

// 不能做参数
//error C3533: 参数不能为包含“auto”的类型
void func2(auto a)
{
}

当函数中的形参用auto类型就会直接报错。

举例e）：

// 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型
auto array[] = { 4, 5, 6 };

这里数组前面定义为auto类型，也会直接报错。

范围for：

a）对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此 C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

b）范围for可以作用到数组和容器对象上进行遍历。

c）范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

举例：

int main()
{int array[] = { 1, 2, 3, 4, 5 };// C++98的遍历for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i){array[i] *= 2;}for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i){cout << array[i] <<" ";}cout << endl;// C++11的遍历for (auto& e : array)e *= 2;for (auto e : array)cout << e << " ";cout<<endl;return 0;
}

结果：

1.2 string类的常用接口说明

a）string类对象的常见构造

举例：

int main()
{string s1;                // 构造空的string类对象s1string s2("hello world");   // 用C格式字符串构造string类对象s2string s3(s2);            // 拷贝构造s3string s4(4, 'c');			//构造n个ccout << s1 << endl;cout << s2 << endl;cout << s3 << endl;cout << s4 << endl;
}

结果：

b） string类对象的容量操作

函数名称	功能说明
size	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty	检测字符串释放为空串，是返回true，否则返回false
clear	清空有效字符
reserve	为字符串预留空间
resize	将有效字符的个数该成n个，多出的空间用字符c填充

size与length：

举例：

int main()
{string s1("hello world");cout << s1.size() << endl;cout << s1.length() << endl;
}

结果：

注意：size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。

capacity:

举例：

void test1()
{string s1("hello world");cout << s1.capacity() << endl;
}

结果：

这里还要看一下一次开多大的空间，如何开空间的（通过下面代码观察一下每次开多大）：

int mian()
{string s;size_t old = s.capacity();cout << "capacity changed: " << old << '\n';cout << "making s grow:\n";for (int i = 0; i < 1000; ++i){//s.push_back('c');s += 'c';if (old != s.capacity()){old = s.capacity();cout << "capacity changed: " << old << '\n';}}
}

结果：

在vs2022编译器下，第一次开辟十六个空间（这是15是表示有效存储空间，因为这里还要放“\0”）,第一次为2倍，后面都是前面的1.5倍。

还要注意调试时，观察当字符小于16，当字符大于16。

void test4()
{string s1("11111");string s2("2222222222222222222222222222");
}

这里发现在vs2022下成员变量中有一个_Buf,就是说当字符数小于16时，就直接存放在_Buf中，避免去频繁调用开辟空间，当大于16时，再在_Ptr调用开辟空间,将字符存放在_Ptr中。

empty:

举例：

int main()
{string s1("hello world");string s2;cout << s1.empty() << endl;cout << s2.empty() << endl;
}

结果：

为空时，返回1，否则，返回0。

clear:

举例：

void test2()
{string s1("hello world");s1.clear();cout << s1.size() << endl;cout << s1.capacity() << endl;
}

结果：

clear()只是将string中有效字符清空，不改变底层空间大小。

reserve:

举例：reserve分为三种情况：

这里先补充一个函数shrink_to_fit()缩容的作用

1.reserve（n）中n<size

void test5()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.reserve(5);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

可以看当n<size时，在vs2022编译器下面reserve并没有缩容减小空间而是保持不变。

2.reserve（n）中n>size并且n<capacity


void test5()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.reserve(13);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

可以看到这里很前面的结果一样，在vs2022下只要n是小于capacity时，就不进行缩容，不操作，保持原来的不变。

3.reserve（n）中n>capacity时

void test5()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.reserve(20);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

这里发现当n>capacity时，在vs2022编译器下，会开辟空间，遵循上面的开辟规则，当所需开辟的空间不足上面的那一个档位时，（例如：我要开辟20个，但根据上面的规则，会直接开辟31个，如果要开辟32，这个31不够，就会直接开辟47个）也会直接开辟那个档位所需的空间。

这里补充一个函数shrink_to_fit:
void test5()
{string s("1111111111");s.reserve(1000);cout << s.size() << endl;cout << s.capacity() << endl;s.shrink_to_fit();cout << s.size() << endl;cout << s.capacity() << endl;
}
结果：

这个函数是用来缩容的，但是注意，这个函数是异地缩容，即是重新开辟一块缩容大小之后的空间。（不建议使用）

resize:

这里同reserve一样分为三种情况：

1.resize(n),n<size：

void test6()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.resize(5);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

可以看到当n<size时，会直接多余的（大于n的）删除数据，并将size大小改为n。

2.resize(n),n>size并且n<capacity：

void test6()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.resize(13);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

可以观察到，这里会将不到n部分的size放置为0，之前原有的数据不变，并将size大小改为n。

3.resize(n),n>capacity:

void test6()
{string s("1111111111");cout << s.size() << endl;cout << s.capacity() << endl;s.resize(20);cout << s.size() << endl;cout << s.capacity() << endl;
}

结果：

这里可以观察到，当n>capacity时，就会开辟新的空间，然后和第二种情况一样，将不到n的部分，补为'\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不会改变容量大小。

1.3 string类对象的访问及遍历操作

函数名称	功能说明
operator[]	返回pos位置的字符，const string类对象调用
begin+end	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
rbegin+rend	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围for	C++11支持更简洁的范围for的新遍历方式

operator[]：

void test7()
{string s("abcdef");for(int i=0;i<s.size();i++)cout << s[i] << " ";
}

结果：

这里和C语言的下标访问是一样的，只是这里进行了函数重载，将其封装了一下。

begin+end:

void test7()
{string s("abcdef");string::iterator i = s.begin();while (i != s.end()){cout << *i << " ";i++;}
}

结果：

这里的迭代器中的begin(),相当于是指针的用法，但这里不是指针。

rbegin+rend：

string s("abcdef");
string::reverse_iterator i1 = s.rbegin();
while (i1 != s.rend())
{cout << *i1 << " ";i1++;
}

结果：

这里就是从最后一个字符开始遍历直到第一个字符，和begin(),end()逻辑是一样的。

1.4. string类对象的修改操作

函数名称	功能说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符串
operator+=	在字符串后追加字符串str
c_str	返回C格式字符串
find+npos	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

push_back:

void test8()
{string s("abcdef");for (int i = 0; i < 5; i++){s.push_back('a');}cout << s << endl;
}

结果：

直接在字符串末尾加字符c 。

append：

这里append在类中有六个接口，这里讲几个较常用的：

string& append(const string&str)和string& append(const char*s):

void test8()
{string s1("abcdef");string s2("hijklm");s1.append(s2);s2.append("abcdef");cout << s1 << endl;cout << s2 << endl;
}

结果：

这里传参可以是一个string类，也可以是常量字符串，都是直接在后面插入。

string& append(const string&str,size_t subpos,size_t sublen)

void test8()
{string s1("abcdef");string s2("hijklm");s1.append(s2, 2, 3);cout << s1 << endl;
}

结果：

这里第一个参数是要插入的string类，第二个参数是从s2下标第几个位置开始插入，第三个参数是要插入的个数。

operator+=：

void test9()
{string s1("hello ");string s2("world");const char* s = "hhhhh";s1 += s2;cout << s1 << endl;s2 += s;cout << s2 << endl;s1 += 'a';cout << s1 << endl;
}

结果：

这里和append非常相似，都是直接在后面追加字符，字符串，和string类，这种增加的方式用的较多，且代码可读性较高。

c_str：

void test9()
{string s1("hello ");cout << s1.c_str() << endl;
}

结果：

这里就是返回类里面的字符串，这里因为是c语言格式，所以字符最后有“\0”。

find+nops：

这里讲常用的函数接口：

size_t find(char c, size_t pos=0) const：

void test10()
{string s("hello world");size_t pos = s.find(' ',0);cout << pos << endl;
}

结果：

这里是从pos位置，寻找第一次出现字符c的位置，并返回该位置的下标。

rfind：

这里讲常用的函数接口：

size_t rfind(char c, size_t pos=0) const：

void test10()
{string s("hello world hello");size_t pos = s.rfind(' ');cout << pos << endl;
}

结果：

这里是从pos位置向前寻找，默认pos参数是npos，相当于是从最后开始向前找字符c，并返回该位置下标。

substr：

void test10()
{string s1("hello ");string s2=s1.substr(1, 3);cout << s2 << endl;
}

结果：

这里函数是将s1从pos=1，位置开始，拷贝3个字符到s2上。

总结： 1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

1.5 string类非成员函数

函数	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>	输入运算符重载
operator<<	输出运算符重载
getline	获取一行字符串
relational_operator	大小比较

这里operator+，就是和operator+=差不多，都在后面增加字符，不建议用是因为这是传值返回，深拷贝效率太低了。

operator>>和operator<<:

这里和小编之前实现的Date日期类的用法一样，可以去之前的文章“赋值运算符重载”翻阅。

getline:

void test11()
{string s;getline(cin, s);cout << s << endl;
}

结果：

这里getline函数是流提取，但这里是读取一行的字符直到换行符，不会像cin或scanf到空格就停止了。

void test11()
{string s;getline(cin, s,'&');cout << s << endl;
}

结果：

这里可以再传一个参数，表示当遇到字符c才停止，甚至换行都不行。