C++ string的根本概念

1. 什么是string？

   在相识什么是string之前，我们起首必要知道字符串是什么。在C语言中，字符串是指以’\0’末了的一些聚集。同时为了操纵方便，C语言也提供了一些库函数用来操纵这些字符串。
但是，这些函数与字符串是分离开的，不符合OOP的头脑------（面向对象编程（Object Oriented Programming，OOP，面向对象步伐计划）是一种盘算机编程架构。OOP 的一条根本原则是盘算机步伐是由单个可以大概起到子步伐作用的单位或对象组合而成。）。同时必要用户自己管理底层空间，稍不注意就会出现越界访问。
以是为了替换C语言原来令人诟病的字符串体系，就有了string的诞生。因此，可以以为string是C++的字符串控制体系。
  2. auto和范围for的使用

2. 1 auto

    在C++11之后，尺度委员会赋予auto全新的意义：auto不再是一个存储范例指示符，而是作为一个新的范例指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
auto作为语法糖，实际上是为了方便步伐员举行更方便的操纵。下面的代码就是全部的使用。

1. ////C++20开始支持
2. //void Func1(auto x)
3. //{
4. //
5. //}
7. //auto做函数返回值，以函数实际 return 返回的值的类型为类型
8. //不建议使用auto做函数的返回值。因为函数返回值使用auto的话，确认函数返回值的类型就会变得麻烦
9. auto Func(int x)
10. {
11.         auto y = x;
12.         return y;
13. }
15. //auto和范围for的使用
16. int main()
17. {
18.         //auto的使用
19.         auto x1 = 1;//auto根据实际对象（1）来自动推断类型
20.         auto x2 = 1.1;
21.         auto x3 = "hello world";
23.         int x4 = 1;
24.         int& x5 = x4;
25.         auto x6 = x5;//auto无法判断类型是否是引用，只能根据引用的对象来判断类型，也就是引用对象的类型就是auto的类型
27.         //然而 auto 诞生的主要目的不是代替这些类型。而是代替一些过长的类型
28.         //例如
29.         list<int> It;//定义一个list对象It
30.         It.push_back(1);
31.         It.push_back(2);
32.         It.push_back(3);
33.         It.push_back(4);//往对象里面尾插1 2 3 4
34.         list<int>::iterator it1 = It.begin();//定义一个list的迭代器it1，it1指向list对象It的第一个位置，list<int>::iterator是类型
35.         auto it2 = It.begin();//定义一个list的迭代器it2，it2指向list对象It的第一个位置，auto自动推导类型，因此省去了写前面的一长串
36.         while (it2 != It.end())
37.         {
38.                 it2++;
39.         }
41.         //另一个例子
42.         std::map<std::string, std::string> dict;
43.         std::map<std::string, std::string>::iterator dit1 = dict.begin();
44.         auto dit2 = dict.begin();//auto代替的就是 std::map<std::string, std::string>::iterator 这一迭代器的类型
46.         //因此auto可以减轻程序员的编写负担。要是经常需要写那么长一串的类型的话，本来就没剩几根的头发也是岌岌可危了
48.         //函数的形参为auto，C++20之后才开始支持
49.         //Func1();
50.         //函数返回类型为auto，参数为int，函数返回值为int
51.         Func(1);
52.        
53.         return 0;

复制代码

2. 2 范围for

   范围for的出现和auto划一，均是为了方便步伐员而推出的语法糖。

1. int main()
2. {
3.         // 范围for的使用
4.     // 适用于容器遍历和数组遍历
5.     // 原理：范围for底层是迭代器
6.         string s1("hello world");
8.         //范围for会把右边的参数自动赋值给左边的变量，左边的变量自动++，直到为空
9.         //自动取容器的数据赋值给左边的对象
10.         //自动++，自动判断结束
11.         for (auto ch : s1)
12.         {
13.                 //s1的值自动赋值给ch，ch自动++
14.                 cout << ch << " ";
15.         }
16.         cout << endl;
18.         //由于范围for是把右边的值赋值给左边的变量，再对左边的变量进行操作，因此就会出现
19.         for (auto ch : s1)
20.         {
21.                 ch++;
22.                 cout << ch << " ";//这里s1的值成功++，并且打印出来
23.         }
24.         cout << endl;
26.         for (auto ch : s1)
27.         {
28.                 cout << ch << " ";//这里s1的值不变。说明上面的++是将s1拷贝给ch，再在ch中操作，没有对s1本身做出改变
29.         }
30.         cout << endl;
32.         //如果想要在范围for里面改变s1，就需要使用引用
33.         for (auto& ch : s1)//引用，传址操作
34.         {
35.                 ch++;
36.         }
38.         for (auto ch : s1)
39.         {
40.                 cout << ch << " ";
41.         }
42.         cout << endl;
44.         //还有另一种情况需要使用引用。当赋值的本体过大，因此拷贝的代价过大，就需要使用引用
45.         //那么，使用引用之后不想要对本体做出改变怎么办？使用const
46.         for (const auto& ch : s1)
47.         {
48.                 //ch++;//编译器报错
49.         }
51.         //范围for的使用对象除了容器，还有数组
52.         int a[] = { 1,2,3,4,5,6,7,8 };
53.         //正常使用for循环去打印
54.         for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
55.         {
56.                 cout << a[i] << " ";
57.         }
58.         cout << endl;
60.         //使用范围for去打印
61.         for (auto ch : a)
62.         {
63.                 cout << ch << " ";
64.         }
65.         cout << endl;
67.         return 0;
68. }

复制代码

3. 迭代器的概念、const string的概念

3. 1 迭代器的概念

    在相识string是怎么使用之前,我们起首必要知道迭代器的存在。
迭代器（iterator），可以明确为一种像指针、能完成指针全部操纵的对象。其界说为：提供一种方法，使之可以大概依次寻访某个容器所包罗的全部元素，而又无需袒露该容器底层的布局。
由于迭代器自己是抽象的概念，以是会共同下面的代码举行阐明。

1. //迭代器的概念
2. int main()
3. {
4.         string s1("Hello world!");
6.         //在C++中，我们想要访问string中的字符串，有两种方式
7.        
8.         //1.下标
9.         //这里之所以能使用下标，是因为在string这个容器中，有关于[]运算符的重载，所以能直接使用[]
10.         //下标的使用的是有前提的。就是对象的存储空间必须是线性的。如果是链表或者树，那么下标的性能就会大幅下降
11.         cout << "下标：";
12.         for (size_t i = 0; i < s1.size(); i++)
13.         {
14.                 cout << s1[i] << " ";
15.         }
16.         cout << endl;
18.         //2.迭代器
19.         cout << "迭代器：";
20.         //string::iterator 说明这是容器 string 的迭代器。it1是实例化的迭代器，可以理解成像s1的指针。但是绝对不是指针，迭代器是全新的概念
21.         string::iterator it1 = s1.begin();//it1指向的是s1的开头
22.         while (it1 != s1.end())//这里的end指向的不是world的d，而是d的下一位，通常是"\0"
23.         {
24.                 cout << *(it1++) << " ";
25.         }
26.         cout << endl;
28.         //迭代器也有反向的
29.         cout << "反向编译器：";
30.         string::reverse_iterator rit = s1.rbegin();//这里rit指向的是world中的d
31.         while (rit != s1.rend())//这里的rend指向的也不是hello中的h，而是h的前一位
32.         {
33.                 cout << *(rit)++ << " ";//这里的++意味着，反向迭代器不仅仅是定义的反向，运算符重载的方向也是反向的
34.         }
36.     return 0;

复制代码

3. 2 const string的概念

1. //const string 对象
2. int main()
3. {
4.         string s1("Hello world!");
5.         //const string对象必须使用const修饰的迭代器
6.         const string s2(s1);
7.        
8.         //const_iterator 和 const iterator的区别：前者限定的是迭代器指向的内容，后者限定的是迭代器本身
9.         //限定迭代器本身的话，就会因为迭代器无法改变，而没办法让 it1++ 访问后面的内容
10.        
11.         //string::const_iterator it1 = s2.begin();
12.         auto it1 = s2.begin();
13.         while (it1 != s2.end())
14.         {
15.                 //*it1 += 1;//const 修饰的对象，无法改变大小
16.                 cout << *it1++ << " ";//但是可以改变迭代器的大小，从而改变指向的位置
17.         }
18.         cout << endl;
20.         //const反向迭代器
21.         string::const_reverse_iterator rit1 = s2.rbegin();
22.         while (rit1 != s2.rend())
23.         {
24.                 cout << *rit1++ << " ";
25.         }
26.         cout << endl;
28.         return 0;
29. }

复制代码