C++ Primer 总结索引 | 第三章：字符串、向量和数组

1、string：可变长度的字符串；vector：可变长度的集合

2、内置类型是由C++语言直接定义的。这些类型（如数字和字符）体现了计算机硬件本身具备的能力。标准库定义了另外一组具有更高级性质的类型，未直接实现到计算机硬件中

1、命名空间的using声明

1、是一种访问库中名字的简单方法

2、库函数基本上属于命名空间std
如：std::cin表示从标准输入中读取内容。作用域操作符::表示编译器应该从操作符左侧名字所示的作用域中寻找右侧那个名字。因此，std::cin的意思是要使用命名空间std中的名字 cin

3、可以直接访问命名空间中的名字：using namespace::name

4、每个名字都需要独立的using声明，每个using声明引入命名空间中的一个成员

5、在main函数外直接cin / cout / endl 不可用

#include <iostream>
// 通过下列using声明，可以使用标准库中的名字
using std::cin;
using std::cout; using std::endl;
int main()
{
   
	cout << "Enter two numbers: " << endl;
	int v1, v2;
	cin >> v1 >> v2;
	cout << "The sum of " << v1 << "and" << v2 << " is " << v1 + v2 << endl;
	return 0;
}

既可以一行只放一条using声明语句，也可以一行放多条
用到的每个名字都必须有自己的声明语句，而且每句话都以分号结束

5、头文件不应该包含using声明，头文件的内容会拷贝到所有引用它的文件里。如果头文件里有某个using声明，那么使用了该头文件的文件都会有这个声明，可能会产生名字冲突

2、标准库类型string

标准库类型string表示可变长的字符序列

2.1 定义和初始化string对象

1、如果提供了一个字符串字面值，则该字面值中除了最后那个空字符外其他所有字符都被拷贝到新创建的string对象中（string最后会添加空字符，但是不算在size里面）

2、初始化string对象的方式：

string s1  默认初始化，s1是个空串
string s2(s1)  s2是s1的副本
string s2 = s1  等价于s2(s1)，s2是s1的副本
string s3("value")  s3是字面值"value"的副本，除了字面值最后的 那个空字符外
string s3 = "value"  等价于s3("value")，s3是字面值"value"的副本
string s4(n, 'c')  把s4初始化为 由连续n个字符c组成的字符串

3、直接初始化和拷贝初始化：使用等号初始化一个变量，实际上执行的是拷贝初始化，编译器把等号右侧的初始值拷贝到新创建的对象中。如果不使用等号，则执行的是直接初始化
初始值只有一个时，直接初始化和拷贝初始化都行。像s4那样初始化要用到的值有多个，只能使用直接初始化，非要用拷贝初始化，需要显式地创建一个（临时）对象用于拷贝：string s8 = string(10, 'c'); 实际上，用10和c参数创建出来 string对象，把这个 string对象拷贝给了s8

2.2 string对象上的操作

语句	操作
os << s	将s写到输出流os中，返回os
is >> s	从is中读取字符串赋给s，字符串以空白分隔，返回is
getline(is, s)	从is中读取一行赋给s，返回is
s.empty()	s为空返回true，否则返回false
s.size()	返回s中字符的个数
s[n]	返回s中第n个字符的引用，位置n从0计起
s1 + s2	返回s1和s2连接后的结果
s1 = s2	用s2的副本代替s1中原来的字符
s1 == s2 / s1 != s2	如果s1和s2所含的字符完全一样，则相等；string对象的相等性判断对字母的大小写敏感
<，<=，>，>=	利用字符在字典中的顺序比较，且对字母的大小写敏感

1、IO操作符读写string对象：string对象会自动忽略开头的空白（即空格符、换行符、制表符等）从第一个真正的字符开始读起，直到遇见下一处空白为止（跟int “>>“输入一样）
如：输入是”(/t) Hello World! (\t)” （开头和结尾空格），则输出将是"Hello"，输出中没有空格

2、和内置类型的输入输出操作一样，string对象的此类操作返回运算符左侧的运算对象作为其结果，因此多个输入输出可以连写在一起（按1所述的原则分开）：

string s1, s2;
cin >> s1 >> s2; // 把第一个输入读入到s1中，第二个输入读入到s2中
cout << s1 << s2 << endl;

输入是"(/t) Hello World (/t)“，输出将是"HelloWorld”

3、读取未知数量的string对象

while (cin >> word) // 反复读取，直至到达文件结尾
	cout << word << endl;

4、希望最终得到的字符串保留输入时的空白符，使用 getline函数代替原来的>>运算符，来读取一整行。getline函数的参数是一个输入流和一个string对象，函数从给定的输入流中读入内容，直到遇到换行符为止（注意换行符也被读进来了），然后把所读的内容存入到那个string对象中去（注意不存换行符，触发getline函数返回的那个换行符被丢弃掉了）
getline只要一遇到换行符就结束读取操作并返回结果，如果输入一开始就是换行符，那么所得的结果是个空string

5、和输入运算符一样，getline也会返回它的流参数，所以也能用getline的结果作为条件
例：让每次读入一行，输出一行

string line;
while (getline(cin, line))
	cout << line << endl;

使用endl结束当前行并刷新显示缓冲区

6、string的empty操作：empty函数根据string对象是否为空返回一个对应的布尔值，empty是string的一个成员函数，使用点操作符指明是哪个对象执行了empty函数
例：让5中的程序只输出非空行

// 遇到空行直接 跳过
string line;
while (getline(cin, line))
	if (!line.empty())
		cout << line << endl;

其中的逻辑非运算符！返回与其运算对象相反的结果

7、string的size操作：size函数返回 string对象的长度（即string对象中字符的个数）line.size()

8、string::size_type类型：size函数返回的是一种新的类型：size_type
string类及其他大多数标准库类型都定义了几种配套类型，这些配套类型体现了标准库类型与机器无关的特性，size_type就是其中的一种，通过作用域操作符来表明名字size_type 是在类string中定义的
size_type类型是一个无符号类型的值，且足够放得下任何string对象的大小。所有用于存放string类的size函数返回值的变量，都应该是 string::size_type类型的

9、C++11允许编译器通过auto或者decltype 来推断变量的类型：auto len = line.size(); // len的类型是string::size_type

10、由于size函数返回的是一个无符号整型数，因此表达式中不能混用带符号数和无符号数
如：如果n是一个负值int，则表达式s.size() < n的判断结果几乎肯定是true，因为负值n 会自动地转换为一个比较大的无符号值
已经有了size()函数就不要再使用 int了，可以避免混用int和unsigned可能带来的问题

11、比较string对象：比较字符串的运算符包括：==，!=，<，<=，>，>=，这些比较运算符逐一比较string对象中的字符，并且对大小写敏感

12、string对象相等意味着它们的长度相同并且所包含的字符也完全相同
比较运算符都按照大小写敏感的字典顺序：
（1）如果两个string对象的长度不同，并且较短string对象的每个字符都与较长string对象对应位置上的字符相同，就说较短string对象小于较长string对象
（2）如果两个string对象在某些对应的位置上不一致，则string对象比较的结果其实是string对象中第一对相异字符比较的结果

string str = "Hello";
string phrase = "Hello World";
string slang = "Hiya";

根据（1），对象str 小于对象phrase
根据（2），对象slang 既大于str 也大于phrase （i（9）> e（5））

13、两个string对象相加：把左侧的运算对象与右侧的运算对象串联而成

string s1 = "hello, ", s2 = "world\n";
string s3 = s1 + s2; // s3的内容是"hello, world\n"

14、字面值和 string对象相加：标准库允许把字符串字面值和字符字面值转换为string对象
注意：把string对象和字符字面值及字符串字面值混在一条语句中使用时，必须确保每个（注意）加法运算符（+）的两侧的运算对象至少有一个是string
如：string s7 = "hello" + ", " + s2; // 错误：不能把字面值直接相加
其实其工作机理和连续输入连续输出是一样的，可以按以下形式分组：
string s7 = ("hello" + ", ") + s2; 跟(cin >> s1) >> s2; 一样

15、string类的输入运算符和getline函数分别是如何处理空白字符：输入运算符碰到空格、回车和制表符，忽略前面空白；getline碰到回车，不忽略空白

16、比较输入的两个字符串是否等长，如果不等长，输出长度较大的那个字符串

#include <iostream>
#include <string>
using std::cin;
using std::cout;
using std::endl;
int main()
{
   
    std::string str_in1, str_in2;

    cin >> str_in1 >> str_in2;
    if (str_in1 != str_in2)
    {
   
        if (str_in1 > str_in2)
        {
   
            cout << str_in1 << endl;
        }
        else
        {
   
            cout << str_in2 << endl;
        }
    }
    /*
    * 输入：guyujian gumin（遇到空格/tab/回车就结束）
    * 输出：guyujian
    */
    return 0;
}

2.3 处理string对象中的字符

1、能改变某个字符的特性：在cctype头文件中定义了一组标准库函数处理

函数	作用
`isalnum(c)`	当c是字母或数字时为真
`isalpha(c)`	当c是字母时为真
`iscntrl(c)`	当c是控制字符时为真
`isdigit(c)`	当c是数字时为真
`isgraph(c)`	当c不是空格但可打印时为真
`islower(c)`	当c是小写字母时为真
`isprint(c)`	当c是可打印字符时为真（即c是空格或 c具有可视形式）
`ispunct(c)`	当c是标点符号时为真（即c不是控制字符、数字、字母、可打印空白中的一种）
`isspace(c)`	当c是空白时为真（即c是空格、横向制表符（\t）、纵向制表符（\v）、回车符、换行符、进纸符中的一种）
`isupper(c)`	当c是大写字母时为真
`isxdigit(c)`	当c是十六进制数字时为真
`tolower(c)`	如果c是大写字母，输出对应的小写字母；否则原样输出c
`toupper(c)`	如果c是小写字母，输出对应的大写字母；否则原样输出c

2、横向制表符（\t）与纵向制表符（\v）
横向制表符：每8个字符可以看作一个水平制表符，如果遇到\t之前未满8个字符，则\t就补空格直到满8个
纵向制表符：让"\v"后面的字符从下一行、"\v"前一个字符所在列的后一列开始输出
如：输入：“01\v2345”
输出：

01
  2345

3、使用c++版本的c标准库头文件：C++标准库中除了定义C++语言特有功能外，也兼容了C语言的标准库
C++将C语言标准库去掉了.h后缀，而在文件名name之前添加了字母c，表示这是一个属于C语言标准库的头文件

cctype头文件和 ctype.h头文件的内容是一样的，从命名规范上更符合C++语言的要求。在名为cname的头文件中定义的名字从属于命名空间std，而定义在名为.h的头文件中的则不然

使用cname头文件标准库中的名字总能在命名空间std中找到，如果使用.h形式的头文件，就要时刻牢记哪些是从C语言继承来的，哪些C++语言所独有的

4、处理每个字符：使用基于范围的for语句，遍历给定序列中的每个元素并对序列中的每个值执行某个操作

for (declaration : expression)
	statement

expression部分是一个对象，表示一个序列。declaration部分负责定义一个变量，该变量将被用于访问序列中的基础元素
每次迭代，declaration部分的变量都会被初始化为expression部分的下一个元素值

string str("some string");
// 每行输出str中的一个字符
for (auto c : str) // 对于str中的每个字符执行操作
	cout << c << endl;

c的类型是char，每次迭代，str的下一个字符被拷贝给c
例：使用范围for语句和 ispunct函数来统计string对象中标点符号的个数

string s("Hello World!!!");
// 使punct_cnt的类型 和 s.size()的返回类型一样，string::size_type
decltype(s.size()) punct_cnt = 0;
for (auto c : s) {
    // 对于s中的每个字符
	if (ispunct(c)) // 如果该字符是标点符号
		++punct_cnt;
cout << punct_cnt << " punctuation characters in " << s << endl;

5、使用范围for语句改变字符串的字符：想要改变，必须把循环变量定义成引用类型，所谓引用只是给定对象的一个别名
例：把字符串改为大写字母的形式，可以使用标准库函数toupper，该函数接受一个字符，然后输出其对应的大写形式（空格保留）

string s("Hello World!!!");
for (auto &c : s) // 对于s中的每个字符（注意c是引用）
	c = toupper(c); // c是一个 引用，因此赋值语句将 改变s中的字符的值
cout << s << endl;

6、只处理一部分字符：只是访问一个字符，或者访问多个字符但遇到某个条件就要停下来
想要访问string对象中的单个字符有两种方式：一种是使用下标，另外一种是使用迭代器

7、下标运算符（[ ]）：接受的输入参数是 string::size_type 类型的值，这个参数表示要访问的字符的位置；返回值是该位置上字符的引用。string对象下标必须大于等于0 小于s.size()，不能越界

8、下标的值：被称作下标或索引，任何表达式只要它的值是一个整型值就能作为索引。如果某个索引是带符号类型的值会自动转换为由string::size_type表达的无符号类型
如：

if (!s.empty())
	cout << s[0] << endl; // 输出s的第一个字符

只要对string对象使用了下标，就要确认那个位置上确实有值；只要字符串不是常量，就能为下标运算符返回的字符赋新值
如：将字符串的首字符改成大写形式

string s("some string");
if (!s.empty())
	s[0] = toupper(s[0]); // 为s是第一个字符 赋一个新值

9、使用下标执行迭代：把s的第一个词改写成大写形式：

// 依次处理s中的字符 直至处理完全部字符 或者 遇到一个空白
for (decltype(s.size()) index = 0; index != s.size() && !isspace(s[index]); ++index)
	s[index] = toupper(s[index]);

输出结果：“SOME string”
使用逻辑与（&&）运算符时，只有左侧运算对象为真才会检查右侧运算符情况
保证了只有当下标取值在合理范围之内时才会使用该下标去访问字符串，只有index在s.size()之前才会执行s[index]

注意使用下标时必须确保在合理范围之内：设下标类型为string::size_type，此类型为无符号数，可以确保下标不会小于0，代码只需要保证下标小于size()的值就行（c++标准不要求标准库检查下标是否合法，一旦超出范围结果不可预知）

10、使用下标执行随机访问：通过计算得到下标值，直接获取对应位置的字符
例：把一串 0-15 之间的十进制数转换成对应的16进制形式，只需要初始化一个字符串令其存放16个十六进制数字

const string hexdigits = "0123456789ABCDEF"; // 可能的十六进制数字，常量，不变了
string res; // 保存结果十六进制字符串
string::size_type n; // 保存输入流读取的数
while (cin >> n)
	if (n < hexdigits.size()) // 忽略无效输入
		result += hexdigits[n]; // 得到对应的十六进制数字
cout << result << endl;

输入：12 0 5
输出：C05

11、编写一段程序，使用范围for语句将字符串内所有字符用X代替

#include <iostream>
#include <string>

using std::cout;
using std::cin;
using std::endl;
using std::string;

int main() {
   
	string str = "a 34"; // 读入看见空格断开 不代表字符串不能有空格
	for (auto &c : str) {
    // 注意使用引用
		c = 'x';
	}
	cout << str << endl;
	return 0;
}

如果将循环控制的变量从auto改为char 将发生什么
改为char后，在范围for循环中，改变的str中字符c的副本，因此，str 并不会改变

用while循环重写程序

#include <iostream>
#include <string>

using std::cout;
using std::cin;
using std::endl;
using std::string;

int main() {
   
	string s = "a 34";
	decltype(s.size()) n = 0; // 利用下标循环的递增
	while (s[n] != '\0') {
    // 字符串结尾\0
		s[n] = 'x';
		n++;
	}
	cout << s << endl;
	return 0;
}

12、下面语句合法吗？

const string s = "Keep out!";
for(auto &c : s){
    /* ... */ }

合法，对const char的引用，但是不能改变c
不是说常量不能引用，引用必须绑定到 const对象上

3、标准库类型vector

1、标准库类型vector表示对象的集合，所有对象的类型相同。集合中每个对象都有一个与之相对的索引，索引用于访问对象

2、vector容纳着其他对象，所以被称为容器

3、使用vector，包含适当的头文件

#include <vector>
using std::vector;

4、c++既有类模板又有函数模板，vector是一个类模板

模板本身不是类或函数，可以将模板看作为编译器生成类或函数编写的一份说明。编译器根据模板创建类或函数的过程称为实例化，当使用模板时，需要指出编译器应该把类或函数实例化成何种类型

对于类模板来说，通过提供一些额外信息来指定模板到底实例化成什么样的类，需要提供哪些信息由模板来决定
提供信息的方式：模板名字后面跟尖括号，在括号内放上信息
例：vector，提供的额外信息是 vector内所存放对象的类型：

vector<int> ivec; // ivec保存int类型的对象
vector<Sales_item> Sales_vec; // 保存Sales_item类型的对象
vector<vector<string>> file; // 该向量的元素是vector对象

编译器根据模板vector 生成了三种不同的类型：vector<int>、vector<Sales_item>、vector<vector<string>>
vector是模板而非类型，由vector生成的类型必须包含vector中元素的类型，例如：vector<int>

引用不是对象，不存在包含引用的vector，其他大多数（非引用）内置类型和类类型都可以构成vector对象，甚至组成vector的元素也可以是vector

3.1 定义和初始化vector对象

1、和任何一种类型一样，vector模板控制着定义和初始化向量的办法
初始化vector对象的方法：

代码	作用
`vector<T> v1`	v1是一个空vector，它潜在的元素是T类型，执行默认初始化
`vector<T> v2(v1)`	v2中包含有v1所有元素的副本
`vector<T> v2 = v1`	等价于v2(v1)，v2中包含有v1所有元素的副本
`vector<T> v3(n, val)`	v3包含了n个重复的元素，每个元素的值都是val
`vector<T> v4(n)`	v4包含了n个重复执行了值初始化的对象
`vector<T> v5{a, b, c...}`	v5包含了初始值个数的元素，每个元素被赋予相应的初始值
`vector<T> v5 = {a, b, c...}`	等价于v5{a, b, c…}

最常见的方法是定义一个空vector，然后运行时获取到元素的值后再逐一添加
允许把一个vector对象的元素拷贝给另一个vector对象，新vector对象的元素就是原vector对象对应的副本元素，两个vector对象的类型必须相同：vector<int> ivec; vector<int> ivec2(ivec); // 正确，把元素拷贝 vector<string> svec(ivec2); // 错误：svec的元素是string对象，不是int

2、列表初始化vector对象（c++11）：用花括号括起来的 0个或多个初始元素值被赋给vector对象

vector<string> articles = {
   "a", "an", "the"};

3、大多数情况下上述初始化方法可以互相等价使用，除了：
（1）使用拷贝初始化时（即使用=时）只能提供一个初始化值
（2）对于类内初始值，只能使用拷贝初始化或使用花括号的形式初始化
（3）对于初始化元素的列表，则只能把初始值都放在花括号里进行列表初始化，而不能放在圆括号里

vector<string> v1{
   "a", "an", "the"}; // 列表初始化
vector<string> v2("a", "an", "the"); // 错误

4、创建指定数量的元素：用vector对象容纳的元素数量和所有元素的统一初始值来初始化vector对象

vector<string> svec(10, "hi"); // 10个string类型的元素，每个都被初始化为"hi"

5、值初始化：只提供vector对象容纳元素的数量而不用略去初始值。库会创建一个值初始化的元素初值，把它赋给容器中的所有元素，初值由vector对象中的元素类型决定

vector<int> ivec(10); // 10个元素，每个都初始化为0
vector<string> svec(10); // 10个元素，每个都是空的string对象

注意：1、有些类要求必须明确提供初始值 2、如果只提供元素的数量而没有设定初始值，只能使用直接初始化，不能用拷贝初始化：vector<int> vi = 10; // 错误

6、列表初始值还是元素数量：初始化的真实含义依赖于传递初始值时用的是花括号还是圆括号
如果用的是圆括号，提供的值用来构造vector对象；如果是花括号，尽可能当成元素初始值的列表，无法执行才考虑其他初始化方式（用这样的值构造vector对象）

vector<string> v5("hi"); // 列表初始化：v5有一个元素
vector<string> v6("hi"); // 错误，不能用 字符串字面值 构建vector对象

vector<string> v7{
   10}; // v7有10个默认初始化元素
vector<string> v8{
   10, "hi"}; // v8有10个值为"hi"的元素
vector<string> v9{
   10}; // 包含10个元素，空字符串

只有v5是列表初始化，要想列表初始化 vector对象，花括号里的值必须与元素类型相同
确认无法执行列表初始化后，编译器会尝试用默认值初始化vector对象

3.2 向vector对象中添加元素

1、对vector来说，直接初始化适用于三种情况：1、初始值已知且数量较少 2、初始值是另一个vector对象的副本 3、所有元素的初始值都一样

2、更好的初始化方法：先创建一个空vector，然后在运行时利用vector的成员函数push_back向其中添加元素。push_back负责把一个值当成vector对象的尾元素 “压到” vector对象的 “尾端”

在运行时才知道vector对象中元素的个数，也应该使用上述方法创建vector对象并为其赋值

// 从标准输入中 读取单词，将其作为vector对象的元素 存储
string word; 
vector<string> text; // 空vector对象
while (cin >> word) {
   
	text.push_back(word); // 把word添加到text后面
}

3、vector对象能高效增长，所以在定义vector对象的时候设定其大小也就没什么必要了，这么做可能性能更差，除非所有元素的值都一样
一旦元素的值有所不同，更有效的方法是先定义一个空的vector对象，再在运行时向其中添加具体值

4、范围for语句体内不应该改变其所遍历序列的大小

3.3 其他vector操作

1、vector提供的操作大多数跟 string相关操作类似

代码	操作
v.empty()	如果v不含有任何元素，返回真；否则返回假
v.size()	返回v中元素的个数
v.push_back(t)	向v的尾部添加一个值为t 的元素
v[n]	返回v中的第n个位置上元素的引用
v1 = v2	用v2中元素的拷贝替换v1中的元素
v1 = {a, b, c…}	用列表中元素的拷贝替换v1中的元素
v1 == v2	v1和v2相等当且仅当它们的元素数量相同且对应位置的元素都相同
v1 != v2	不相等
<, <=, >, >=	以字典顺序进行比较

2、访问vector对象中元素的方法和访问string对象中字符的方法差不多，通过元素在vector对象中的位置。利用范围for处理vector对象中的所有元素：

vector<int> v{
   1, 2, 3, 4, 5, 6, 7, 8, 9};
for (auto &i : v) // 对于v中的每个元素，注意i是个引用
	i *= i; 
for (auto i : v)
	cout << i << " "; 
cout << endl;

3、size()返回vector对象中元素的个数，返回值的类型是由vector定义的size_type类型

要使用size_type，首先指定它是由哪种类型定义的。vector对象的类型总是包含着元素的类型

vector<int>::size_type // 正确
vector::size_type // 错误

4、各个相等性运算符和关系运算符也与string的相应运算符功能一致。关系运算符按照字典序比较，相同位置上元素一致的情况下，元素较少的小于元素较多的；若元素值有区别，vector对象的大小关系是由第一对相异的元素值的大小关系决定

只有当元素值可比较时，vector对象才能被比较

5、计算vector内对象的索引：只要vector对象不是一个常量，就能向下标运算符返回的元素赋值
例：分数分段统计个数：
计算得到了分数段索引（score / 10），就能把它作为 vector对象的下标，进而获取该分数段的计数值并加1：

// 以10分为一个分数段 统计成绩的数量：0~9，10~19，...，90~99，100
vector<unsigned> scores(11, 0); // 11个分数段，全部初始化为0
unsigned grade;
while (cin >> grade) {
    // 读取成绩
	if (grade <= 100) // 只处理有效成绩
		++scores[grade / 10]; // 将对应分数段的计数值加1，下标范围一定是合法的
}

6、不能用下标形式添加元素：vector对象（以及string对象）的下标运算符可用于访问已存在的元素，而不能用于添加元素

vector<int> ivec;
for (decltype(ivec.size()) ix = 0; ix != 10; ix++)
	ivec[ix] = ix; // 严重错误：ivec不包含任何元素

正确的方法是使用push_back

7、用下标形式去访问一个不存在的元素将引发错误，不过这种错误不会被编译器发现，而是在运行时产生一个不可预知的值

缓冲区溢出：通过下标访问不存在的元素
例：下面的程序合法吗？如果不合法，你准备如何修改？

vector<int> ivec;
ivec[0] = 42;

不合法，第2行改为：ivec.push_back(42);

8、从cin读入一组词并把它们存入一个vector对象，然后设法把所有词都改为大写形式。输出改变后的结果，每个词占一行

#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
   
	vector<string> vec;
	string str;
	while (cin >> str) {
   
		vec.push_back(str);
	}
	for (auto &s : vec) {
   
		for (auto& c : s) {
    
	// 两轮for循环，外层vector中的string，内层string中的char，注意都要带引用
			c = toupper(c);
		}
		cout << s << endl;
	}
	return 0;
}

4、迭代器

1、迭代器：除使用下标运算符访问string对象的字符或 vector对象的元素之外，实现同样的目的更通用的机制是迭代器

除了vector之外，标准库还定义了其他几种容器。所有标准库容器都可以使用迭代器，但只有少数几种才同时支持下标运算符。string对象不属于容器类型，但是string支持很多与容器类型类似的操作。vector支持下标运算符，这点跟string一样；string 和 vector也同时支持迭代器

2、类似于指针类型，迭代器也提供了对对象的间接访问。其对象是容器中的元素或者 string对象中的字符。使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另一个元素

3、迭代器有有效和无效之分，这一点和指针差不多。有效的迭代器或者指向某个元素，或者指向容器中尾元素的下一个位置；其他情况都属于无效

4.1 使用迭代器

1、和指针不一样的是，获取迭代器不是使用取地址符，有迭代器的类型（v）同时拥有返回迭代器的成员（v.begin()）。比如：这些类型都拥有名为begin 和 end的成员，其中begin成员负责返回指向第一个元素（或第一个字符）的迭代器

// b表示v的第一个元素，e表示v尾元素的下一个位置
auto b = v.begin(), e = v.end(); // b和e的类型相同

end成员负责返回指向容器（或string对象）尾元素的下一个位置，该迭代器指示的是容器的一个本不存在的 “尾后”元素
这样的迭代器没什么实际含义，仅是一个标记，表示已经处理完了容器中的所有元素。end成员返回的迭代器称为尾后迭代器或者简称为尾迭代器。特殊情况下如果容器为空，则begin 和 end 返回的是同一个迭代器

一般来说不在意 / 清楚迭代器的准确类型

2、如果容器为空，则begin和end返回的是同一个迭代器，都是尾后迭代器

3、迭代器运算符：如果两个迭代器指向的元素相同或都是同一个容器的尾后迭代器，则他们相等；和指针相似，通过解引用迭代器来获取它所指示的元素

代码	作用
*iter	返回迭代器iter所指元素的引用
iter->mem	解引用iter并获得该元素名为mem的成员，等价于(*iter).mem
++iter	令iter指示容器中的下一个元素
–iter	令iter指示容器中的上一个元素
iter1 == iter2	判断两个迭代器是否相等
iter1 != iter2	不相等

4、利用下标运算符把string对象的第一个字母改写为大写形式

string s("some thing");
if (s.begin() != s.end()) {
    // 要先检查：确保s非空
	auto it = s.begin();
	*it = toupper(*it); // 使用当前所指元素的 引用，把当前字符改成 大写形式
}

在if内部，声明了一个迭代器变量it并把begin返回的结果赋给它，这样就得到了指示s中第一个字符的迭代器接下来通过解引用运算符将第一个字符更改为大写形式

5、将迭代器从一个元素移动到另外一个元素：迭代器使用递增运算符来从一个元素移动到另一个元素，迭代器的递增就是将迭代器“向前移动一个位置”

end返回的迭代器并不实际指向某个实际元素，不能对其进行递增或解引用操作
例：利用迭代器及其自增运算符将string对象中第一个单词改写为大写形式

// 依次处理s的字符 直至 处理完全字符 或者遇到空白
for (auto it = s.begin(); it != s.end() && !isspace(*it); it++)
	*it = toupper(*it); // 将当前字符 改成 大写形式

6、泛型编程：C++习惯性使用 !=，更愿意使用迭代器而非下标是因为：这种编程风格在标准库提供的所有容器上都有效
所有标准库容器的迭代器都定义了 == 和 !=，但是它们中的大多数没有定义<运算符。养成迭代器和!=的习惯，就不用在意用的到底是哪种容器类型

7、迭代器类型：就像不知道string和vector的size_type成员到底是什么类型一样，也不知道迭代器的精确类型。那些拥有迭代器的标准库类型使用 iterator 和 const_iterator 来表示迭代器的类型

vector<int>::iterator it; // it能读写vector<int>的元素
string::iterator it2; // it2能读写string对象中的字符

vector<int>::const_iterator it3; // it3 只能读元素，不能写元素
string::const_iterator it4; // it4 只能读字符，不能写字符

const_iterator和常量指针差不多，能读取但不能修改它的元素值

8、begin 和 end运算符：begin和end返回的具体类型是由对象是否是常量决定，如果对象是常量，begin和end返回const_iterator；如果对象不是常量，返回iterator

vector<int> v;
const vector<int> cv; 
auto it1 = v.begin(); // it1的类型是vector<int>::iterator
auto it2 = cv.begin(); // it2的类型是vector<int>::const_iterator

为了专门得到const_iterator类型的返回值，C++11引入了两个新函数，分别是cbegin，cend：

auto it3 = v.cbegin(); // it3的类型是vector<int>::const_iterator

类似于begin和end，上述两个新函数也分别返回指示容器第一个元素或最后一个元素下一个位置的迭代器。有所不同的是，不论 vector对象或 string对象本身是否是常量，返回值都是const_iterator

9、结合解引用和成员访问操作：解引用迭代器可获得迭代器所指对象，如果该对象的类型恰好是类，就可以进一步访问它的成员
例：检查是否为空，令it是该 vector对象的迭代器：(*it).empty()
注意，*it外面的圆括号不能丢，如果不加圆括号，点运算符将由it来执行
先对it解引用，然后解引用的结果再执行点运算符

10、为了简化 9例中的运算符，定义了箭头运算符（->）：把解引用和成员访问两个操作结合在一起，it->mem和(*it).mem等价
例：利用迭代器遍历text，直到遇到空字符串或结尾为止

for (auto it = text.cbegin(); it != text.cend() && !it->empty(); ++it)
	cout << *it << endl;

11、某些对vector对象的操作会使迭代器失效：虽然vector对象可以动态的增长
（1）不能在范围for中向vector对象添加元素
（2）任何一种可能改变vector对象容器的操作，比如push_back，都会使该vector对象的迭代器失效
但凡使用了迭代器的循环体，都不要向迭代器所属的容器添加元素

12、迭代器运算：迭代器的递增运算令迭代器每次移动一个元素，所有的标准库容器都有支持递增运算的迭代器，也能用==和!=对任意标准库类型的两个有效迭代器

string和vector的迭代器提供了更多额外的运算符，一方面可以使得迭代器的每次移动跨过多个元素，另外也支持迭代器进行关系运算，这些运算被称作迭代器运算

vector和string迭代器支持的运算：

代码	作用
iter + n	迭代器加上一个整数仍得一个迭代器，迭代器指示的新位置与原来比向前移动了若干元素结果迭代器或指示容器内的一个元素，或指示容器尾元素的下一个位置
iter - n	减去，向后移动
iter1 += n	复合赋值语句，将iter1加n的结果赋给iter1
iter1 -= n	减
iter1 - iter2	两个迭代器相减的结果是他们之间的距离，将运算符右侧的迭代器向前移动差值个元素将得到左侧的迭代器，参与运算的两个迭代器必须指向的是同一个容器中的元素或者尾元素的下一个位置
>、>=、<、<=	迭代器的关系运算符，如果某迭代器指向的容器位置在另一个迭代器所指的位置之前，则说前者小于后者。参与运算的两个迭代器必须指的是同一个元素中的元素或者尾元素的下一个位置

例：
相加相减：auto mid = vi.begin() + vi.size() / 2;
如果vi有20个元素，mid等于vi.begin() + 10，已知下标从0开始，迭代器所指元素是vi[10]

iter1 - iter2所得结果是两个迭代器的距离，其类型是名为difference_type的带符号整数，string和vector都定义了difference_type

13、使用迭代器运算的例子
（1）利用迭代器完成二分搜索

// beg和end表示搜索范围，前闭后开
auto beg = text.begin(), end = text.end();
auto mid = text.begin() + (end - beg) / 2; // 中间点
// 当还有元素尚未检查 并且 还没找到sought时执行循环
while (mid != end && *mid != sought) {
   
	if (sought < *mid)
		end = mid;
	else 
		beg = mid + 1;
	mid = beg + (end - beg) / 2;
}

为什么用的是 mid = beg + (end - beg) / 2, 而非 mid = (beg + end) / 2
迭代器相加不成立，指针加指针无意义

(2)用迭代器重新实现划分分数段程序

#include <iostream>
#include <vector>

using std::cout; using std::cin; using std::endl;
using std::vector;

int main()
{
   
	vector<int> vec;
	int tmp;
	while (cin >> tmp) {
   
		vec.push_back(tmp);
	}
	vector<int> res(11, 0);
	for (auto iter = vec.begin(); iter != vec.end(); iter++) {
   
		(*(res.begin() + (*iter / 10)))++; // 最外面那个括号不能少，不然会先执行++再执行*
	}
	for (auto iter = res.begin(); iter != res.end(); iter++) {
   
		cout << *iter << " ";
	}
	return 0;
}

5、数组

1、数组是一种类似于标准库类型vector 的数据结构

与vector 相似的地方是：数组也是存放类型相同的对象的容器，这些对象本身没有名字，需要通过其所在位置访问

与vector 不同的地方是：数组的大小确定不变，不能随意向数组中添加元素。因为数组的大小固定，因此对特殊的应用来说程序运行时性能较好，损失灵活性

5.1 定义和初始化内置数组

1、数组的声明：a[d] 其中a是数组的名字，d是数组的维度
之前初始化的时候类型总是在变量名的左边，数组元素的类型在左边，大小在方括号内放在变量名的右边的

维度说明了数组中元素的个数，必须大于0，数组中元素个数是数组类型的一部分，编译时维度应该是已知的，维度必须是一个常量表达式

unsigned cnt = 42; // 不是常量表达式
string bad[cnt]; // 错误

constexpr unsigned sz = 42; // 常量表达式
int arr[10]; // 正确
int *parr[10]; // 含有42个整型指针的数组

string strs[get_size()]; // 当get_size是constexpr时正确；否则错误

2、和内置类型变量一样（string, vector<int>就不是内置类型变量，所以不会），在函数内部定义了某种内置类型的数组，默认初始化会令数组含有未定义的值

3、定义数组的时候必须指定数组的类型，不允许用 auto关键字由初始列表推断类型

4、和vector一样，数组的元素应该为对象，不存在引用的数组

5、显式初始化数组：
1）对数组进行列表初始化，允许忽略数组的维度，如果声明时没有指明，编译器根据初始值的数量推测
2）如果指明了维度，初始值总数量不应该超出指定的大小。如果维度比提供的初始值数量大，用提供的初始值初始化靠前的元素，剩下的元素初始化为默认值（string是空字符，int是0）

const unsigned sz = 3;
int ial[sz] = {
   0, 1, 2}; // 3个元素，值为0，1，2

int a2[] = {
   0, 1, 2}; // 维度是3的数组
int a3[5] = {
   0, 1, 2}; // 等价于a3[] = {0, 1, 2, 0, 0}
string a4[3] = {
   "hi", "bye"}; // 等价于a4[] = {"hi", "bye", ""}

int a5[2] = {
   0, 1, 2}; // 错误

数组初始化默认值：
1）当数组在全局变量区定义时，默认初值为0。
2）当数组在局部变量区定义时，如果不写“ {} ”，则默认的初值为乱码
3）当数组在局部变量区定义时，如果写“ {} ”或给某几位赋值时，则其他未赋值的数默认初值为0

6、字符数组的特殊性：字符数组除列表初始化外有特殊的初始化形式，用字符串字面值初始化，且自动添加表示字符串结束的空字符（字符串字面值自带的结尾处的空字符也会像字符串的其他字符一样被拷贝到字符数组中）而列表初始化不会

char a1[] = {
   'C', '+', '+'}; // 列表初始化，没有空字符
char a2[] = {
   'C', '+', '+', '\0'}; // 列表初始化，有显式的空字符

char a3[] = "C++"; // 自动添加表示字符串结束的空字符
const char a4[6] = "Daniel"; // 错误：没有空间可存放空字符，6个字符，数组的大小 至少为7

7、不允许拷贝和赋值：不能将数组的内容拷贝给其他数组作为其初始值，也不能用数组为其他数组赋值

int a[] = {
   0, 1, 2}; 
int a2[] = a; // 错误：不允许使用一个数组 初始化 另一个数组
a2 = a; // 错误：不能把一个数组 直接赋值给 另一个数组

8、复杂的数组声明（引用，指针与括号）
定义存放指针的数组比较直接，定义数组的指针和引用要用括号

int *ptrs[10]; // ptrs是含有10个整数指针的数组
int &refs[10] = /* */; // 错误：不存在引用的数组
int (*Parray)[10] = &arr; // Parray指向一个含有10个整数的数组
int (&arrRef)[10] = arr; // arrRef引用一个含有10个整数的数组

int (*Parray)[10]：圆括号括起来的部分，*Parray意味着Parray是个指针，右边可知Parray是个指向大小为10的数组的指针，左边可知数组中的元素是int

9、对修饰符的数量没有限制

int *(&array)[10] = ptrs; // arry是数组的引用，该数组含有十个指针

理解数组声明的含义：由内而外读语句，括号内array是个引用，右边知道array引用的对象是一个大小为10的数组，左边知道数组的元素类型是指向int的指针

10、下列数组中元素的值

string sa[10];
int ia[10];
int main() {
   
    string sa2[10];
    int ia2[10];
}

sa：空字符串；
ia：0；

sa2：空字符串；
ia2：不确定值

5.2 访问数组元素

1、使用数组下标时，定义为size_t类型
size_t：是一种机器相关的类型，被设计的足够大以便能表示内存中任意对象的大小，在cstddef头文件中定义了size_t类型

2、记录各分数段成绩的个数

// 以10分为一个分数段统计成绩的数量
unsigned scores[11] = {
   }; //全部初始化为0
unsigned grade; 
while (cin >> grade) {
   
	if (grade <= 100)
		++scores[grade / 10]; // 当前分数段的计数值+1
}

与vector实现不同：scores的声明；这里使用的下标运算符由C++直接定义的，这个运算符能用在数组对象上，vector里的下标运算符是库模板vector定义的，只能用于vector类的运算对象

3、范围for语句的使用：与vector / string一样，需要遍历数组所有元素时使用

for (auto i : scores)
	cout << i << " ";

4、定义一个含有10个int的数组，令每个元素的值就是其下标值：for(size_t i = 0;i<10;i++) ia[i] = i;
刚刚创建的数组拷贝给另一数组：不能整体直接拷贝，只能一个个元素拷贝：

int ia2[10];
for(size_t i = 0;i<10;++i) 
	ia2[i] = ia[i];

5.3 指针和数组

1、一些情况下数组的操作实际上是指针的操作
1）使用数组名字的地方编译器一般会把它替换为一个指向数组首元素的指针：string *p = nums;
对数组的元素使用取地址符就能得到指向该元素的指针：string *p = &nums[0]; // 跟上面的代码等价

2）

int ia[] = {
   0, 1, 2 ,3, 4};
auto ia2(ia); // ia2是一个整型指针，指向ia的第一个元素

使用ia作初始值时，编译器实际执行的初始化过程类似于：auto ia2(&ia[0]); // 显然ia2的类型时int*
当使用decltype关键字时上述转换不会发生，decltype(ia)返回的类型是由4个整数构成的数组：decltye(ia) ia3 = {0, 1, 2, 3};

2、指针也是迭代器：指向数组元素的指针有更多功能。vector和string的迭代器支持的运算，数组的指针全都支持
例：允许使用递增运算符将指向数组元素的指针向前移动到下一个位置上

int arr[] = {
   0, 1, 2, 3};
int *p = arr; // p指向arr的第一个元素
++p; // p指向arr[1]

像使用迭代器遍历vector对象中的元素一样，使用指针也能遍历数组中的元素。前提是先获得指向数组第一个元素的指针和指向数组尾元素的下一位置的指针
可以获取数组元素之后那个不存在的元素地址：使用下标运算索引一个不存在的元素

int *e = &arr[4]; // 指向arr尾元素的下一个位置的指针

就像尾后迭代器一样，尾后指针也不指向具体的元素，不能对尾后指针执行解引用或递增的操作
利用上面的尾后指针写循环，输出所有arr元素

for (int *b = arr; b != e; b++)
	cout << *b << endl;

3、标准库函数begin 和 end：C++11引入，跟容器中的两个同名成员函数功能一致。使用形式是将数组（不是指向数组第一个元素的指针）作为它们的参数，这两个函数定义在iterator头文件中

int ia[] = {
   0,1,2,3};
int *beg = begin(ia); // 指向ia首元素的指针
int *last = end(ia); // 指向arr尾数组的下一位置的指针

使用begin和end两个函数易于写出一个循环处理数组中的元素

int *pbeg = begin(arr), *pend = end(arr);
while (pbeg != pend && *pbeg >= 0) // pbeg != pend确保可以安全地对pbeg解引用
	++pbeg;

4、指针运算：指向数组元素的指针可以执行所有之前提过的迭代器运算，包括解引用、递增、比较、与整数相加、两个指针相减等，用在指针和用在迭代器上意义完全一致

给一个指针加上 / 减去某整数值，结果仍是指针。给指针加上一个整数，得到的新指针仍需指向同一数组的其他元素或者同一数组尾元素的下一个位置

和迭代器一样，两个指针相减的结果是它们之间的距离auto n = end(arr) - begin(arr); 结果的类型是 ptrdiff_t 标准库类型，和 size_t 一样，ptrdiff_t 也是一种定义在 cstddef 头文件中的机器相关的类型。因为差值可能为负，所以 ptrdiff_t 是一种带符号类型

两个指针指向同一个数组的元素，或者指向该数组的尾元素的下一个位置，就能利用关系运算符对其进行比较；两个指针分别指向不相关的对象，则不能比较它们
指针的比较运算也适用于空指针和所指对象不是数组的指针。如果p是空指针，允许给p加上或减去一个值为 0 的整型常量表达式，两个空指针也可以相减，结果当然是0；对于所指对象不是数组的指针，两个指针必须指向同一个对象或该对象的下一个位置

5、解引用和指针运算的交互

int ia[] = {
   0, 2, 4, 6, 8};
int last = *(ia + 4); // 正确，把last初始化成ia[4]的值

表达式含有解引用运算符和点运算符，最好在必要的地方加上圆括号

last = *ia + 4; // 正确，last = ia[0] + 4

6、下标与指针：对数组执行下标运算其实是对指向元素的指针执行下标运算

int i = ia[2];  // ia换成指向数组首元素的指针，ia[2]得到（ia + 2）所指的元素

int *p = ia; // p指向ia的元素
i = *(p + 2); // 等价于i = ia[2]

只要指针指向的是数组中的元素（或者数组中尾元素的下一个位置），都可以执行下标运算

int *p = &ia[2]; // p指向索引为2的元素
int j = p[1]; // p[1]等价于*(p + 1)，就是ia[3]表示的那个元素
int k = p[-2]; // p[-2]是ia[0]表示的那个元素

标准库类型与内置类型下标运算的区别：标准库类型如string和vector限定使用的下标必须是无符号类型，而内置的下标运算可以为负值

7、p1 += p2 - p1; == p1 += (p2 - p1)

8、利用指针将数组中的元素置为0

#include <iostream>
#include <iterator>

using std::endl;
using std::cout;
using std::end;

int main() {
   
	int a[5] = {
   };
	for (size_t i = 0; i < 5; i++) a[i] = i;
	for (int aa : a) {
   
		cout << aa << " ";
	}
	cout << endl;
	for (int *p = a; p != end(a); p++) {
    
	// 注意end()定义在iterator头文件中，使用时别忘了using std::end;在标准空间中
		*p = 1;
	}
	for (int aa : a) {
   
		cout << aa << " ";
	}
	return 0;
}

9、编写一段程序，比较两个数组是否相等。再写一段程序，比较两个vector对象是否相等（vector直接有运算符== 比较）
begin / end函数的参数是数组，如果直接作为参数传入就是指针了，而且进行引用进行值传递时别忘了数组的类型包含数组的大小，数组的大小是必须要包含的

begin / end作为形参要传入有两种方法
1）迂回传指针

#include <iostream>
#include <vector>
#include <iterator>

using std::cout;
using std::endl;
using std::vector;
using std::end;
using std::begin;

bool compare_int(int *ia1_begin,int *ia1_end,int *ia2_begin,int *ia2_end)
{
   
    cout << ia1_end - ia1_begin << " " << ia2_end - ia2_begin <<endl;
    if((ia1_end - ia1_begin) == (ia2_end - ia2_begin))
    {
   
        for(int *i = ia1_begin,*j = ia2_begin;i != ia1_end,j != ia2_end;++i,++j)
        {
   
            if(*i != *j)
            {
   
                return false;
            }
        }
        return true;
    }else
    {
   
        return false;
    }
}

int main()
{
   

    int ia1[10] = {
   1,2,3};
    int ia2[9] = {
   1,2,3};

    if(compare_int(begin(ia1),end(ia1),begin(ia2),end(ia2)))
    {
   
        cout << "equal" << endl;
    }else
    {
   
        cout << "not equal" << endl;

    }

    vector<int> iv1{
   1,2,3,4};
    vector<int> iv2{
   1,2,3};
    if(iv1 == iv2)
    {
   
        cout << "equal" << endl;
    }else
    {
   
        cout << "not equal" << endl;
    }

    return 0;
}

2）传数组的引用

// https://zhuanlan.zhihu.com/p/438555365
#include <iostream>
#include <vector>
#include <iterator>

using std::cout;
using std::endl;
using std::vector;
using std::end;
using std::begin;

bool compare_int(int(&ia1)[10], int(&ia2)[9]) // 数组类型不光带元素类型，还要带元素个数
{
   
    if (end(ia1) - begin(ia1) == end(ia2) - begin(ia2)) // end / begin的参数就是单纯 数组，不自动转化为指向数组第一个元素的指针
    {
   
        for (int* i = begin(ia1), *j = begin(ia2); i != end(ia1), j != end(ia2); ++i, ++j)
        {
   
            if (*i != *j)
            {
   
                return false;
            }
        }
        return true;
    }
    else
    {
   
        return false;
    }
}

int main()
{
   

    int ia1[10] = {
    1,2,3 };
    int ia2[9] = {
    1,2,3 };

    if (compare_int(ia1, ia2))
    {
   
        cout << "equal" << endl;
    }
    else
    {
   
        cout << "not equal" << endl;

    }
}

5.4 C风格字符串

1、尽管C++支持 C风格字符串，但在C++程序中最好不要使用

2、字符串字面值是一种通用结构的实例，这种结构是C++由C继承而来的C风格字符串。C风格字符串不是一种类型，而是为了表达和使用字符串而形成的约定俗成的写法。按照这个习惯书写的字符串存放在字符串数组中并以空字符结束，即在字符串最后一个字符后面跟着一个空字符（‘\0’）

3、C标准库String函数（C风格字符串的函数）：定义在cstring头文件（C语言头文件string.h的C++版本）中

代码	作用
strlen§	返回p的长度，空字符不计算在内
strcmp(p1, p2)	比较p1和p2的相等性。如果p1==p2，返回0；如果p1>p2，返回正值；如果p1<p2，返回负值
strcat(p1, p2)	将p1附加到p2之后（p1最后的空格去了），返回p1
strcpy(p1, p2)	将p2拷贝给p1，返回p1

传入此类函数的指针必须指向以空字符作为结束的数组

char ca[] = {
   'C', '+', '+'}; // 不以空字符结束
cout << strlen(ca) << endl; // 严重错误：ca没有以空字符结束

strlen函数将有可能沿着ca在内存中的位置不断向前寻找，直到遇到空字符才停下来

4、C风格字符串与标准库string对象操作区别
4.1、C风格字符串与标准库string对象操作区别：比较函数
比较标准库string对象的时候，用的是普通的关系运算符和相等性运算符

string s1 = "A string";
string s2 = "A different";
if (s1 < s2) // false, d < s

这些运算符用在两个C风格字符串上，实际上比较的是指针而非字符串本身

const char ca1[] = "A string";
const char ca2[] = "A different"; 
if (ca1 < ca2) // 未定义的；试图比较两个无关地址

当使用数组名字的时候其实真正使用的是指向数组首元素的指针，上面的if条件实际上比较的是两个const char*的值
想要比较两个C风格字符串需要调用strcmp函数

4.2、C风格字符串与标准库string对象操作区别：连接或拷贝字符串
两个string对象的连接：string largeStr = s1 + "," + s2;
同样的操作放到两个C风格字符串：cal1 cal2 这两个数组就产生错误，cal1 + cal2试图将两个指针相加，是非法的

为什么两个指针相加没有意义：指针相加实际为地址相加

正确的方法是使用 strcat函数和 strcpy函数，还必须提供一个用于存放结果字符串的数组，该数组必须足够大以便容纳下结果字符串及末尾的空字符

// largeStr大小不够 引发严重错误，largeStr内容 一旦改变，必须 重新检查其空间是否足够
strcpy(largeStr, ca1);
strcpy(largeStr, ",");
strcpy(largeStr, ca2);

5、程序的输出结果是什么

const char ca[] = {
    'h', 'e', 'l', 'l', 'o' };
const char *cp = ca;
while (*cp) {
   
    cout << *cp << endl;
    ++cp;
}

没有’\0’，循环可能不会停止，将会打印出垃圾信息（存在风险）

6、编写一段程序，比较两个string对象。再编写一段程序，比较两个C风格字符串的内容
char aa[] = { 'a','z', '\0'}; // 要自己加，不然一直aa大（一路读下去了） char bb[] = "az"; // 自带终止符

#include <iostream>
#include <string>
#include <cstring>

using std::endl;
using std::cout;
using std::string;

int main()
{
   
	string a = "abb";
	string b = "az";
	if (a == b) {
   
		cout << "a is equal to b" << endl;
	}
	else if (a > b){
   
		cout << "a is bigger than b" << endl;
	}
	else {
   
		cout << "a is smaller than b" << endl;
	}

	char aa[] = {
    'a','z', '\0'}; // 要自己加，不然一直aa大（一路读下去了）
	char bb[] = "az"; // 自带终止符
	if (strcmp(aa, bb) == 0) {
   
		cout << "aa is equal to bb" << endl;
	}
	else if (strcmp(aa, bb) > 0) {
   
		cout << "aa is bigger than bb" << endl;
	}
	else {
   
		cout << "aa is smaller than bb" << endl;
	}
	return 0;
}

7、定义两个字符数组并用字符串字面值初始化它们；接着再定义一个字符数组存放前面两个数组连接后的结果。使用 strcpy 和 strcat 把前两个数组的内容拷贝到第三个数组当中

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <cstring>


using std::cout;
using std::endl;
using std::string;

int main()
{
   
    char ca1[] = "aaa";
    char ca2[] = "abc";
    char ca3[7]; // 刚刚好7个

    strcpy(ca3, ca1);
    strcat(ca3, ca2);

    cout << ca3 << endl;

    return 0;
}

3.5 与旧代码接口

1、混用string对象和 C风格字符串
之前介绍过可以使用字符串字面值来初始化string对象 string s("Hello World");

更一般的情况：任何出现字符串字面值的地方都可以用以空字符结束的字符数组来替代
1）允许使用以空字符结束的字符数组来初始化string对象或为string对象赋值
2）在string对象的加法运算中允许使用以空字符结束的字符数组作为其中的一个运算对象（不能两个运算对象都是）；在string对象的复合赋值运算中允许使用以空字符结束的字符数组作为右侧的运算对象

以上性质反过来不成立：如果程序某处需要C风格字符串，无法直接使用string对象代替它。例如：不能用string对象直接初始化指向字符的指针 char *str = s; // 错误

为了用string对象初始化指向字符的指针，使用c_str函数：const char *str = s.c_str();
c_str函数的返回值是一个C风格的字符串，即函数的返回结果是一个指针，该指针指向一个以空字符结束的字符数组，该指针的类型是 const char*（避免更改字符数组的内容），而这个被指向的数组所存数据恰好与 string对象一样

无法保证c_str 函数返回的数组一直有效，如果后续的操作改变了s的值就可能让之前返回的数组失去效用
所以执行完c_str()函数后程序想一直都能使用其返回的数组，最好将该数组重新拷贝一份

2、使用数组初始化vector对象：
不允许使用一个数组为另一个内置类型的数组赋初值
不允许使用vector对象初始化数组

允许使用数组初始化 vector对象
只要指明要拷贝区域的首元素地址和尾后地址

int int_arr[] = {
   0, 1, 2, 3, 4, 5};
vector<int> ivec(begin(int_arr), end(int_arr));

用于创建ivec的两个指针实际上指明了用来初始化的值在int_arr中的位置
用于初始化vector对象的值也可能仅是数组的一部分

// 拷贝三个元素：int_arr[1]、int_arr[2]、int_arr[3]
vector<int> subVec(int_arr + 1, int_arr + 4);

尽量使用标准库类型而非数组

3、汇总
用整型数组初始化一个vector对象

int ia[] = {
   1,2,3};
vector<int> iv(begin(ia),end(ia));

将含有整数元素的vector对象拷贝给一个整型数组

vector<int> iv(3,2);
int ia[3];
for(int i = 0;i < 3;++i) ia[i] = iv[i];

3.6 多维数组

1、C++没有多维数组，多维数组其实是数组的数组
当一个数组的元素仍是数组时，使用两个维度定义：一个维度表示数组本身大小，另一个维度表示其元素（也是数组）的大小。对于二维数组来说，第一个维度称为行，第二个维度称为列

2、多维数组的初始化：使用花括号括起来的一组值初始化多维数组

int ia[3][4] = {
    // 三个元素，每个元素都是大小为4的数组
	{
   0, 1, 2, 3}, // 第一行的初始值
	{
   4, 5, 6, 7}, // 第二行的初始值
	{
   8, 9, 10, 11} // 第三行的初始值
};

内层嵌套着的花括号非必须，等价语句：int ia[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

跟一维数组一样，初始化时不需要把所有元素都包含在初始化列表之内，其他未列出的元素执行相同的默认值初始化，这种情况下就不能省略内层的花括号

// 显式的初始化 每行的首元素
int ia[3][4] = {
   {
   0}, {
   4}, {
   8}};
// 显式的初始化第一行，其他元素执行默认初始化，其他元素被初始化为0
int ix[3][4] = {
   0, 3, 6, 9};

3、多维数组的下标引用：数组的每个维度对应一个下标运算符。表达式含有的下标运算符数量比数组的维度小，则表达式的结果将是一个给定索引处的内层数组

// 用arr的首元素 为ia最后一行的最后一个元素 赋值
ia[2][3] = arr[0][0][0];
// 把row绑定到 ia的第二个4元素数组上
int (&row)[4] = ia[1];

ia[2][3]：ia[2]得到数组ia的最后一行，此时返回的是表示ia最后一行的那个一维数组；对这个一维数组再取下标，得到编号为3的元素

使用两层嵌套for循环处理多维数组的元素，将元素索引作为它的值

constexpr size_t rowCnt = 3, colCnt = 4;
int ia[rowCnt][colCnt]; // 12个未初始化的元素
// 每一行
for (size_t i = 0; i != rowCnt; i++) {
   
	// 对于行内的每一列
	for (size_t j = 0; j != colCnt; j++) {
   
		ia[i][j] = i * colCnt + j;
	}
}

4、范围for语句处理多维数组：C++11新增范围for语句
同上面的两层嵌套for循环，也是将元素索引作为它的值

size_t cnt = 0;
for (auto &row : ia) // 对于外层数组的每一个元素
	for (auto &col : row) {
    // 对于内层数组的每一个元素
		col = cnt; // 将下一个值赋给该元素
		++cnt;
	}

跟上面两层嵌套for循环不同的是：把管理数组索引的任务交给了系统来完成。要改变元素的值，就需要把控制变量row和col声明成引用类型。第一个for循环遍历ia的所有元素，所以 row的类型是含有4个整数的数组的引用。第二个for循环遍历那些4元素数组中的某一个，所以 col的类型是整数的引用

还有一个深层次的原因促使这么做：

for (const auto &row : ia) // 对于外层循环的 每一个元素
	for (auto col : row) // 对于内层循环的 每一个元素
		cout << col << endl;

循环中没有任何写操作，还是必须把外层循环的控制变量声明成了引用类型，这是为了避免数组被自动转成指针
假设不用引用类型

for (auto row : ia)
	for (auto col : row)

程序无法通过编译
第一个循环遍历ia所有元素，这些元素为大小为4的数组。因为row不是引用类型，所以编译器初始化row时会自动将这些数组形式的元素（和其他类型的数组一样）转换成指向该数组内首元素的指针
这样得到的 row 类型就是 int*，内层循环就不合法了，编译器将试图在一个int*内遍历

要使用范围for语句处理多维数组，除了最内层的循环外，其他所有循环的控制变量都应该是引用类型

5、指针和多维数组：程序使用多维数组的名字时，自动将其转换成指向数组首元素的指针
因为多维数组实际上是数组的数组，由多维数组名转换得来的指针实际上是指向第一个内层数组的指针

int ia[3][4]; // 大小为3的数组，每个元素含有 4个整数的数组
int (*p)[4] = ia; // p指向含有4个整数的数组 的指针
p = &ia[2]; // p指向ia的尾元素

通过使用auto 或 decltype就能尽可能避免在数组前面加上一个指针类型
注意p，q 都是指针，但指向不同

// 输出ia中 每个元素的值
// p指向 含有4个整数的数组
for (auto p = ia; p != ia + 3; p++)
	// q指向 4个整数数组内的元素，即q指向 一个整数
	for (auto q = *p; q != *p + 4; q++)
		cout << *q << ' ';

当然也可以通过标准库函数begin 和 end实现，p和q指向的东西一致，但内层for循环里面的*p含义不一样，上面代码是指向数组内元素的指针，而下面代码就是解引用数组

// p指向 含有4个整数的数组
for (auto p = begin(ia); p != end(ia); p++)
	// q指向 4个整数数组内的元素，即q指向 一个整数
	for (auto q = begin(*p); q != end(*p); q++)
		cout << *q << ' ';

6、类型别名简化多维数组的指针：将4个整数组成的数组命名为 int_array

using int_array = int[4]; // 新标准下类型别名的声明
typedef int int_array[4]; // 直观理解就是typedef int[4] int_array，与上面的一句等价

for (int_array *p = ia; p != ia + 3; p++) {
   
	for (int *q = *p; q != *p + 4; q++) 
		cout << *q << ' ';
	cout << endl;
}

7、编写3个不同版本的程序，令其均能输出ia的元素。版本1 使用范围for语句管理迭代过程；版本2 和版本3 都使用普通for语句，其中版本2要求使用下标运算符，版本3要求使用指针

#include <iostream>
#include <iterator>

using std::cout;
using std::cin;
using std::endl;
using std::end;
using std::begin;

int main()
{
   
	int ia[3][4] = {
   
		{
   0,1,2,3},
		{
   4,5,6,7},
		{
   8,9,10,11}
	};

	for (int(&i)[4] : ia) {
    // 注意类型是int &[4] 不是[3]
		for (int j : i) {
   
			cout << j << " ";
		}
		cout << endl;
	}

	for (size_t i = 0; i < 3; i++) {
   
		for (size_t j = 0; j < 4; j++) {
   
			cout << ia[i][j] << " ";
		}
		cout << endl;
	}

	for (int(*i)[4] = begin(ia); i != end(ia); i++) {
    
		// begin / end的参数就是单纯一个数组，数组名不转化为指向第一个元素的指针
		for (int *j = begin(*i); j != end(*i); j++) {
   
			cout << *j << " ";
		}
		cout << endl;
	}
	return 0;
}