《C++ Primer 5th》笔记（3 / 19）：字符串、向量、迭代器和数组

港控/mmm° 2023-01-17 08:23 208阅读 0赞

### 文章目录 ###

*   *  命名空间的using声明
     *  标准库类型string
     *   *  定义和初始化string对象
         *   *  直接初始化和拷贝初始化
         *  string对象上的操作
         *   *  读写string对象
             *  读取未知数量的string对象
             *  使用getline读取一整行
             *  string的empty和size操作
             *  string::size\_type类型
             *  比较string对象
             *  为string对象赋值
             *  两个string对象相加
             *  字面值和string对象相加
         *  处理string对象中的字符
         *   *  建议:使用C++版本的C标准库头文件
             *  处理每个字符，就使用基于范围的for语句
             *  使用范围for语句改变字符串中的字符
             *  只处理一部分字符
             *  使用下标执行迭代
             *  提示：注意检查下标的合法性
             *  使用下标执行随机访问
     *  标准库类型vector
     *   *  定义和初始化vector对象
         *   *  列表初始化vector对象
             *  创建指定数量的元素
             *  值初始化
             *  列表初始值还是元素数量
         *  向vector对象中添加元素
         *   *  关键概念：vector对象能高效增长
             *  向vector对象添加元素蕴含的编程假定
         *  其他vector操作
         *   *  计算vector内对象的索引
             *  不能用下标形式添加元素
             *  提示:只能对确知已存在的元素执行下标操作!
     *  迭代器介绍
     *   *  使用迭代器
         *   *  迭代器运算符
             *  将迭代器从一个元素移动到另外一个元素
             *  关键概念：泛型编程
             *  迭代器类型
             *  术语:迭代器和迭代器类型
             *  begin和end运算符
             *  结合解引用和成员访问操作
             *  某些对vector对象的操作会使迭代器失效
         *  迭代器运算
         *   *  迭代器的算术运算
             *  使用迭代器运算
     *  数组
     *   *  定义和初始化内置数组
         *   *  显式初始化数组元素
             *  字符数组的特殊性
             *  不允许拷贝和赋值
             *  理解复杂的数组声明
         *  访问数组元素
         *   *  检查下标的值
         *  指针和数组
         *   *  指针也是迭代器
             *  标准库函数begin和end
             *  指针运算
             *  解引用和指针运算的交互
             *  下标和指针
         *  C风格字符串
         *   *  C标准库String函数
             *  比较字符串
             *  目标字符串的大小由调用者指定
         *  与旧代码的接口
         *   *  混用string对象和C风格字符串
             *  使用数组初始化vector对象
             *  建议:尽量使用标准库类型而非数组
     *  多维数组
     *   *  多维数组的初始化
         *  多维数组的下标引用
         *  使用范围for语句处理多维数组
         *  指针和多维数组
         *  类别别名简化多维数组的指针
     *  一些术语

## 命名空间的using声明 ##

目前为止，我们用到的库函数基本上都属于命名空间std，而程序也显式地将这一点标示了出来。

例如，std::cin表示从标准输入中读取内容。此处使用作用域操作符(::)的含义是：**编译器应从操作符左侧名字所示的作用域中寻找右侧那个名字**。因此，std::cin 的意思就是要使用命名空间std中的名字cin。

上面的方法显得比较烦琐，然而幸运的是，通过更简单的途径也能使用到命名空间中的成员，也就是使用using声明（using declaration），还会有其他途径，敬请期待。

有了using声明就无须专门的前缀（形如命名空间::）也能使用所需的名字了。using声明具有如下的形式：

using namespace::name;

一旦声明了上述语句，就可以直接访问命名空间中的名字：

#include <iostream>
    // using declaration; when we use the name cin, we get the one from the namespace std
    using std::cin;
    int main()
    { 
        int i;
        cin >> i; // ok: cin is a synonym for std::cin
        cout << i; // error: no using declaration; we must use the full name
        std::cout << i; // ok: explicitly use cout from namepsace std
        return 0;
    }

**每个名字都需要独立的using声明**

#include <iostream>
    // using declarations for names from the standard library
    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 声明**

位于头文件的代码一般来说不应该使用using声明。这是因为头文件的内容会拷贝到所有引用它的文件中去，如果头文件里有某个using声明，那么每个使用了该头文件的文件就都会有这个声明。对于某些程序来说，由于不经意间包含了一些名字，反而可能产生始料未及的名字冲突。

**一点注意事项**

之后的所有例子将假设，但凡用到的标准库中的名字都已经使用using语句声明过了。例如，我们将在代码中直接使用cin，而不再使用std::cin。

为了让书中的代码尽量简洁，今后将不会再把所有using声明和\#include指令一一标出。

## 标准库类型string ##

标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。接下来的示例都假定已包含了下述代码：

#include <string>
    using std::string;

本节描述最常用的string操作，将来还将介绍另外一些。

C++标准一方面对库类型所提供的操作做了详细规定，另一方面也对库的实现者做出一些性能上的需求。因此，标准库类型对于一般应用场合来说有足够的效率。（也就是说，你放心用标准库类型吧！）

### 定义和初始化string对象 ###

> 副本的本义是指同一书抄出的复本。[link][]

string s1; // default initialization; s1 is the empty string
    string s2 = s1; // s2 is a copy of s1
    string s3 = "hiya"; // s3 is a copy of the string literal
    string s4(10, 'c'); // s4 is cccccccccc

**初始化string对象的方式**

<table> 
 <thead> 
  <tr> 
   <th align="center">.</th> 
   <th align="center">.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">string s1</td> 
   <td align="center">默认初始化，s1是一个空串</td> 
  </tr> 
  <tr> 
   <td align="center">string s2(s1)</td> 
   <td align="center">s2是s1的副本</td> 
  </tr> 
  <tr> 
   <td align="center">string s2 = s1</td> 
   <td align="center">等价于s2(s1)，s2是s1的副本</td> 
  </tr> 
  <tr> 
   <td align="center">string s3(“value”)</td> 
   <td align="center">s3是字面值"value"的副本，除了字面值最后的那个空字符外</td> 
  </tr> 
  <tr> 
   <td align="center">string s3 = “value”</td> 
   <td align="center">等价于s3(“value”)，s3是字面值"value"的副本</td> 
  </tr> 
  <tr> 
   <td align="center">string s4(n, ‘c’)</td> 
   <td align="center">把s4初始化为由连续n个字符c组成的串</td> 
  </tr> 
 </tbody> 
</table>

#### 直接初始化和拷贝初始化 ####

C++语言有几种不同的初始化方式，通过string我们可以清楚地看到在这些初始化方式之间到底有什么区别和联系。

*  如果使用等号（=）初始化一个变量，实际上执行的是**拷贝初始化（copy initialization）**，编译器把等号右侧的初始值拷贝到新创建的对象中去。
 *  与之相反，如果不使用等号，则执行的是**直接初始化（direct initialization）**。

当初始值只有一个时，使用直接初始化或拷贝初始化都行：

string s5 = "hiya"; // copy initialization
    string s6("hiya"); // direct initialization
    string s7(10, 'c'); // direct initialization; s7 is cccccccccc

对于用多个值进行初始化的情况，非要用拷贝初始化的方式来处理也不是不可以，不过需要显式地创建一个（临时)对象用于拷贝：

string s8 = string(10, 'c');//拷贝初始化，s8的内容是cccccccccc

相当于

string temp(10, 'c'); // temp is cccccccccc
    string s8 = temp; // copy temp into s8

其实我们可以看到，尽管初始化s8的语句合法，但和初始化s7的方式比较起来可读性较差，也没有任何补偿优势。（没什么卵用）

### string对象上的操作 ###

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

#### 读写string对象 ####

// Note: #include and using declarations must be added to compile this code
    int main()
    { 
    	string s; // empty string
    	cin >> s; // read a whitespace-separated string into s
    	cout << s << endl; // write s to the output
    	return 0;
    }

string对象会自动忽略开头的空白（即空格符、换行符、制表符等）并从第一个真正的字符开始读起，直到遇见下一处空白为止。

如上所述，如果程序的输入是“ Hello World! ”（注意开头和结尾处的空格），则输出将是“Hello”，输出结果中没有任何空格。

和内置类型的输入输出操作一样，string对象的此类操作也是返回运算符左侧的运算对象作为其结果。因此，多个输入或者多个输出可以连写在一起：

string s1, s2;
    cin >> s1 >> s2; // read first input into s1, second into s2
    cout << s1 << s2 << endl; // write both strings

假设给上面这段程序输入与之前一样的内容“ Hello World! ”，输出将是“HelloWorld!”。

#### 读取未知数量的string对象 ####

int main() { 
        string word;
        while (cin >> word) // read until end-of-file (Ctrl + Z)
            cout << word << endl; // write each word followed by a new line
        return 0;
    }

#### 使用getline读取一整行 ####

有时我们希望能在最终得到的字符串中保留输入时的空白符，这时应该用getline函数代替原来的>>运算符。getline函数的参数是一个输入流和一个string对象，函数从给定的输入流中读入内容，直到遇到换行符为止（注意换行符也被读进来了），然后把所读的内容存入到那个string对象中去（注意不存换行符）。

getline只要一遇到换行符就结束读取操作并返回流参数，哪怕输入的一开始就是换行符也是如此。如果输入真的一开始就是换行符，那么所得的结果是个空string。

int main()
    { 
        string line;
        // read input a line at a time until end-of-file
        while (getline(cin, line))
    	    cout << line << endl;
        return 0;
    }

因为line中不包含换行符，所以我们手动地加上换行操作符。和往常一样，使用endl结束当前行并刷新显示缓冲区。

触发getline函数返回的那个换行符实际上被丢弃掉了，得到的string对象中并不包含该换行符。

#### string的empty和size操作 ####

empty函数根据string对象是否为空返回一个对应的布尔值。

// read input a line at a time and discard blank lines
    while (getline(cin, line))
        if (!line.empty())
            cout << line << endl;

size函数返回string对象的长度（即string对象中字符的个数），可以使用size函数只输出长度超过80个字符的行：

string line;
    // read input a line at a time and print lines that are longer than 80 characters
    while (getline(cin, line))
        if (line.size() > 80)
            cout << line << endl;

#### string::size\_type类型 ####

对于size函数来说，返回一个int或者一个unsigned似乎都是合情合理的。但其实 size函数返回的是一个string::size\_type类型的值。

string类及其他大多数标准库类型都定义了几种配套的类型。**这些配套类型体现了标准库类型与机器无关的特性**，类型size\_type即是其中的一种。在具体使用的时候，通过作用域操作符来表明名字size\_type是在类string中定义的。

尽管我们不太清楚string::size\_type类型的细节，但有一点是肯定的：它是一个**无符号类型的值**而且能足够存放下任何string对象的大小。所有用于存放string类的size函数返回值的变量，都应该是string::size\_type类型的。

过去，string::size\_type这种类型有点儿神秘，不太容易理解和使用。在C++11新标准中，允许编译器通过auto或者decltype来推断变量的类型：

auto len = line.size (); //len的类型是string::size_type

由于size函数返回的是一个**无符号整型数**，因此**切记**，如果在表达式中混用了带符号数和无符号数将可能产生意想不到的结果。例如，假设n 是一个具有负值的int，则表达式s.size()<n的判断结果几乎肯定是true。

这是因为**负值n会自动地转换成一个比较大的无符号值**。

**如果一条表达式中已经有了size()函数就不要再使用int了,这样可以避免混用int和unsigned可能带来的问题。**

#### 比较string对象 ####

string类定义了几种用于比较字符串的运算符。这些比较运算符逐一比较string对象中的字符，并且对大小写敏感，也就是说，在比较时同一个字母的大写形式和小写形式是不同的。

相等性运算符（==和!=）分别检验两个string对象相等或不相等，string对象相等意味着它们的长度相同而且所包含的字符也全都相同。关系运算符<、<=、>、>=分别检验一个string对象是否小于、小于等于、大于、大于等于另外一个string对象。上述这些运算符都依照（大小写敏感的）字典顺序：

1.  如果两个string对象的长度不同，而且较短string对象的每个字符都与较长string对象对应位置上的字符相同，就说较短string对象小于较长 string对象。
2.  如果两个string对象在某些对应的位置上不一致，则string对象比较的结果其实是string对象中第一对相异字符比较的结果。

string s1 = "Hello";
    string s2 = "Hello World";
    string s3 = "Hiya";

根据规则1可判断，对象s1小于对象s2；根据规则2可判断，对象s3既大于s1也大于s2。

#### 为string对象赋值 ####

一般来说，在设计标准库类型时都力求在易用性上向内置类型看齐，因此大多数库类型都支持赋值操作。对于string类而言，允许把一个对象的值赋给另外一个对象：

string st1(10, 'c'), st2; // st1 is cccccccccc; st2 is an empty string
    st1 = st2; // assignment: replace contents of st1 with a copy of st2
    // both st1 and st2 are now the empty string

#### 两个string对象相加 ####

两个string对象相加得到一个**新的string对象**，其内容是把左侧的运算对象与右侧的运算对象串接而成。

也就是说，对string对象使用加法运算符（+）的结果是一个新的string对象，它所包含的字符由两部分组成:前半部分是加号左侧string对象所含的字符、后半部分是加号右侧string对象所含的字符。

另外，复合赋值运算符（+=）负责把右侧string对象的内容追加到左侧string对象的后面：

string s1 = "hello, ", s2 = "world\n";
    string s3 = s1 + s2; // s3 is hello, world\n
    s1 += s2; // equivalent to s1 = s1 + s2

#### 字面值和string对象相加 ####

上一章节说过所讲的，即使一种类型并非所需，我们也可以使用它，不过前提是该种类型可以自动转换成所需的类型。因为标准库允许把**字符字面值**和**字符串字面值**转换成string对象，所以在需要string对象的地方就可以使用这两种字面值来替代。利用这一点将之前的程序改写为如下形式：

string s1 = "hello", s2 = "world"; // no punctuation in s1 or s2
    string s3 = s1 + ", " + s2 + '\n';

当把string对象和字符字面值及字符串字面值混在一条语句中使用时，必须确保每个加法运算符（+）的两侧的运算对象至少有一个是string：

string s4 = s1 + ", "; // ok: adding a string and a literal
    string s5 = "hello" + ", "; // error: no string operand
    string s6 = s1 + ", " + "world"; // ok: each + has a string operand//字符串字面值不能直接相加
    string s7 = "hello" + ", " + s2; // error: can't add string literals

s4和s5初始化时只用到了一个加法运算符，因此很容易判断是否合法。s6的初始化形式之前没有出现过，但其实它的工作机理和连续输入连续输出是一样的，可以用如下的形式分组：

string s6 = (s1 + ", ") + "world";

其中子表达式sl +", "的结果是一个string对象，它同时作为第二个加法运算符的左侧运算对象，因此上述语句和下面的两个语句是等价的：

string tmp = s1 + ", "; // ok: + has a string operand
    s6 = tmp + "world"; // ok: + has a string operand

另一方面，s7的初始化是非法的，根据其语义加上括号后就成了下面的形式：

string s7 = ("hello" + ", ") + s2; // error: can't add string literals

很容易看到，括号内的子表达式试图把两个字符串字面值加在一起，而编译器根本没法做到这一点，所以这条语句是错误的。

因为某些历史原因，也为了与C兼容，所以C++语言中的字符串字面值并不是标准库类型string的对象。**切记，C++中字符串字面值与string是不同的类型。**

### 处理string对象中的字符 ###

cctype头文件中的函数

<table> 
 <thead> 
  <tr> 
   <th align="center">.</th> 
   <th align="center">.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">isalnum©</td> 
   <td align="center">当c是字母或数字时为真</td> 
  </tr> 
  <tr> 
   <td align="center">isalpha©</td> 
   <td align="center">当c是字母时为真</td> 
  </tr> 
  <tr> 
   <td align="center">iscntrl©</td> 
   <td align="center">当c是控制字符时为真</td> 
  </tr> 
  <tr> 
   <td align="center">isdigit©</td> 
   <td align="center">当c是数字时为真</td> 
  </tr> 
  <tr> 
   <td align="center">isgraph©</td> 
   <td align="center">当c不是空格但可打印时为真</td> 
  </tr> 
  <tr> 
   <td align="center">islower©</td> 
   <td align="center">当c是小写字母时为真</td> 
  </tr> 
  <tr> 
   <td align="center">isprint©</td> 
   <td align="center">当c是可打印字符时为真（即c是空格或c具有可视形式）</td> 
  </tr> 
  <tr> 
   <td align="center">ispunct©</td> 
   <td align="center">当c是标点符号时为真（即c不是控制字符、数字、字母、可打印空白中的一种）</td> 
  </tr> 
  <tr> 
   <td align="center">isspace©</td> 
   <td align="center">当c是空白时为真（即c是空格、横向制表符、纵向制表符、回车符、换行符、进纸符中的一种）</td> 
  </tr> 
  <tr> 
   <td align="center">isupper©</td> 
   <td align="center">当c是大写字母时为真</td> 
  </tr> 
  <tr> 
   <td align="center">isxdigit©</td> 
   <td align="center">当c是十六进制数字时为真</td> 
  </tr> 
  <tr> 
   <td align="center">tolower©</td> 
   <td align="center">如果c是大写字母，输出对应的小写字母；否则原样输出c</td> 
  </tr> 
  <tr> 
   <td align="center">toupper©</td> 
   <td align="center">如果c是小写字母，输出对应的大写字母；否则原样输出c</td> 
  </tr> 
 </tbody> 
</table>

#### 建议:使用C++版本的C标准库头文件 ####

C++标准库中除了定义C++语言特有的功能外，也兼容了C语言的标准库。C语言的头文件形如 name.h,C++则将这些文件命名为cname。也就是去掉了.h后缀，而在文件名name之前添加了字母c，这里的c表示这是一个属于C语言标准库的头文件。

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

一般来说，C++程序应该使用名为cname的头文件而不使用name.h的形式，标准库中的名字总能在命名空间std中找到。如果使用.h形式的头文件，程序员就不得不时刻牢记哪些是从C语言那儿继承过来的，哪些又是C++语言所独有的。

#### 处理每个字符，就使用基于范围的for语句 ####

C++11新标准：

**范围for** (range for）语句。这种语句遍历给定序列中的每个元素并对序列中的每个值执行某种操作，其语法形式是：

for (declaration : expression)
    	statement

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

（Note：与Java的forEach循环类似）

一个string对象表示一个字符的序列，因此 string对象可以作为范围for语句中的expression部分。

举一个简单的例子，我们可以使用范围for语句把string对象中的字符每行一个输出出来：

string str("some string");
    // print the characters in str one character to a line
    for (auto c : str) // for every char in str
    	cout << c << endl; // print the current character followed by a newline

再举一点的例子，使用范围for语句和 ispunct函数来统计string对象中标点符号的个数：

string s("Hello World!!!");
    // punct_cnt has the same type that s.size returns;//decltype具体查看上一章
    decltype(s.size()) punct_cnt = 0;
    // count the number of punctuation characters in s
    for (auto c : s) // for every char in s
    	if (ispunct(c)) // if the character is punctuation
    		++punct_cnt; // increment the punctuation counter
    cout << punct_cnt
    		<< " punctuation characters in " << s << endl;

输出结果：

3 punctuation characters in Hello wor1d!!!

#### 使用范围for语句改变字符串中的字符 ####

如果想要改变string对象中字符的值，**必须把循环变量定义成引用类型**。

记住，所谓**引用只是给定对象的一个别名**，因此当使用引用作为循环控制变量时，这个变量实际上被依次绑定到了序列的每个元素上。使用这个引用，我们就能改变它绑定的字符。

举一个简单的例子，假设我们想要把字符串改写为大写字母的形式。

string s("Hello World!!!");
    // convert s to uppercase
    for (auto &c : s) // for every char in s (note: c is a reference)
    	c = toupper(c); // c is a reference, so the assignment changes the char in s
    cout << s << endl;

输出结果：

HELLO WORLD!!!

#### 只处理一部分字符 ####

如果要处理string对象中的每一个字符，使用范围for语句是个好主意。然而，有时我们需要访问的只是其中一个字符，或者访问多个字符但遇到某个条件就要停下来。例如，同样是将字符改为大写形式，不过新的要求不再是对整个字符串都这样做，而仅仅把string对象中的第一个字母或第一个单词大写化。

要想访问string对象中的单个字符有两种方式：

1.  使用下标，
2.  使用迭代器

先介绍下标运算符（The subscript operator） （\[\]）接收的输入参数是string::size\_type类型的值，这个参数表示要访问的字符的位置；返回值是该位置上字符的引用。

string对象的下标从0计起。如果string对象s至少包含两个字符，则s\[0\]是第1个字符、s\[1\]是第2个字符、s\[s.size()-1\]是最后一个字符。

string对象的下标必须大于等于0而小于s.size()。

**使用超出此范围的下标将引发不可预知的结果，以此推断,使用下标访问空string也会引发不可预知的结果。**

下标的值称作“下标（a subscript）”或“索引（an index ）”，任何表达式只要它的值是一个整型值就能作为索引。不过，如果某个索引是带符号类型的值将自动转换成由string::size\_type表达的无符号类型。

举一个例子，使用下标运算符输出string对象中的第一个字符：

if (!s.empty()) // make sure there's a character to print
    	cout << s[0] << endl; // print the first character in s

再举一个例子，将字符串首字母变为大写：（只要字符串不是常量，就能为下标运算符返回的字符赋新值。）

string s("some string");
    if (!s.empty()) // make sure there's a character in s[0]
    	s[0] = toupper(s[0]); // assign a new value to the first character in s

输出s：

Some string

#### 使用下标执行迭代 ####

另一个例子是把s的第一个词改成大写形式：

// process characters in s until we run out of characters or we hit a whitespace
    for (decltype(s.size()) index = 0;
    	index != s.size() && !isspace(s[index]); ++index)
    		s[index] = toupper(s[index]); // capitalize the current character

输出s：

SOME string

#### 提示：注意检查下标的合法性 ####

使用下标时必须确保其在合理范围之内，也就是说，下标必须大于等于0而小于字符串的size()的值。一种简便易行的方法是，总是设下标的类型为string::size\_type，因为此类型是无符号数，可以确保下标不会小于0。此时，代码只需保证下标小于size()的值就可以了。

C++标准并不要求标准库检测下标是否合法。**一旦使用了一个超出范围的下标,就会产生不可预知的结果。**

#### 使用下标执行随机访问 ####

在之前的示例中，我们让字符串的下标每次加1从而按顺序把所有字符改写成了大写形式。**其实也能通过计算得到某个下标值，然后直接获取对应位置的字符**，并不是每次都得从前往后依次访问。

例如，想要编写一个程序把0到15之间的十进制数转换成对应的十六进制形式，只需初始化一个字符串令其存放16个十六进制“数字”：

const string hexdigits = "0123456789ABCDEF"; // possible hex digits
    cout << "Enter a series of numbers between 0 and 15"
        << " separated by spaces. Hit ENTER when finished: "
        << endl;
    string result; // will hold the resulting hexify'd string
    string::size_type n; // hold numbers from the input
    while (cin >> n)
    	if (n < hexdigits.size()) // ignore invalid input
    		result += hexdigits[n]; // fetch the indicated hex digit
    cout << "Your hex number is: " << result << endl;

假设输入的内容如下：

12 0 5 15 8 15

程序的输出结果将是：

Your hex number is: C05F8F

## 标准库类型vector ##

> vector  
> 英 \[ˈvektə®\] 美 \[ˈvektər\]  
> n. 矢量; 向量; (传染疾病的)介体，载体; (航空器的)航线

标准库类型**vector**表示对象的集合，其中所有对象的类型都相同。集合中的每个对象都有一个与之对应的索引，索引用于访问对象。因为vector“容纳着”其他对象，所以它也常被称作**容器**（container）。

要想使用vector，必须包含适当的头文件。在后续的例子中，都将假定做了如下using声明:

#include <vector>
    using std::vector;

C++语言既有**类模板**（class template)，也有函数模板，其中**vector是一个类模板**。只有对C++有了相当深入的理解才能写出模板，事实上，我们直到最后阶段的章节才会学习如何自定义模板。幸运的是，即使还不会创建模板，我们也可以先试着用用它。

**模板**本身不是类或函数，相反可以将模板看作**为编译器生成类或函数编写的指令**。（Templates are not themselves functions or classes. Instead, they can be thought of as **instructions to the compiler for generating classes or functions**. ）编译器根据模板创建类或函数的过程称为**实例化（ instantiation）**，当使用模板时，需要指出编译器应把类或函数实例化成何种类型。

对于类模板来说，我们通过提供一些额外信息来**指定模板到底实例化成什么样的类**，需要提供哪些信息由模板决定。提供信息的方式总是这样:即在模板名字后面跟一对尖括号，在括号内放上信息。

以vector为例，提供的额外信息是vector内所存放对象的类型：

vector<int> ivec; // ivec holds objects of type int
    vector<Sales_item> Sales_vec; // holds Sales_items
    vector<vector<string>> file; // vector whose elements are vectors

在上面的例子中，编译器根据模板vector生成了三种不同的类型：

*  vector<int>
 *  vector<Sales\_item>
 *  vector<vector<string>>

**vector是模板而非类型，由vector生成的类型必须包含vector中元素的类型，例如vector<int>。**

vector能容纳绝大多数类型的对象作为其元素，但是因为引用不是对象，所以不存在包含引用的vector。除此之外，其他大多数（非引用）内置类型和类类型都可以构成vector对象，甚至组成vector的元素也可以是vector。

（与Java中的List类似）

**关于旧版本的vector**

需要指出的是，在早期版本的C++标准中如果vector的元素还是vector（或者其他模板类型），则其定义的形式与现在的C++11新标准略有不同。过去,必须在外层vector对象的右尖括号和其元素类型之间添加一个空格，如应该写成vector<vector<int> >而非vector<vector<int>>。

某些编译器可能仍需以老式的声明语句来处理元素为 vector的vector对象，如 vector<vector<int> >。

### 定义和初始化vector对象 ###

初始化vector对象的方法：

<table> 
 <thead> 
  <tr> 
   <th align="center">.</th> 
   <th align="center">.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">vector&lt;T&gt; v1</td> 
   <td align="center">v1是一个空vector，它潜在的元素是T类型的，执行默认初始化</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v2(v1)</td> 
   <td align="center">v2中包含有v1所有元素的副本</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v2 = v1</td> 
   <td align="center">等价于v2(v1)，v2中包含有v1所有元素的副本</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v3 (n, val)</td> 
   <td align="center">v3包含了n个重复的元素，每个元素的值都是val</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v4 (n)</td> 
   <td align="center">v4包含了n个重复地执行了值初始化的对象</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v5{a, b, c…}</td> 
   <td align="center">v5包含了初始值个数的元素，每个元素被赋予相应的初始值</td> 
  </tr> 
  <tr> 
   <td align="center">vector&lt;T&gt; v5={a, b, c…}</td> 
   <td align="center">等价于v5{a,b,c…}</td> 
  </tr> 
 </tbody> 
</table>

可以默认初始化 vector对象，从而创建一个指定类型的空vector：

vector<string> svec; //默认初始化，svec不含任何元素

看起来空vector好像没什么用，但是很快我们就会知道程序在运行时可以很高效地往vector对象中添加元素。事实上，最常见的方式就是先定义一个空vector，然后当运行时获取到元素的值后再逐一添加。

当然也可以在定义vector对象时指定元素的初始值。

例如，允许把一个vector对象的元素拷贝给另外一个vector对象。此时，新vector对象的元素就是原vector对象对应元素的副本。注意两个vector对象的类型必须相同：

vector<int> ivec; // initially empty
    // give ivec some values
    vector<int> ivec2(ivec); // copy elements of ivec into ivec2
    vector<int> ivec3 = ivec; // copy elements of ivec into ivec3
    vector<string> svec(ivec2); // error: svec holds strings, not ints

#### 列表初始化vector对象 ####

C++11新标准还提供了另外一种为vector对象的元素赋初值的方法,即列表初始化。此时，用花括号括起来的0个或多个初始元素值被赋给vector对象：

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

之前已经讲过，C++语言提供了几种不同的初始化方式。在大多数情况下这些初始化方式可以相互等价地使用，不过也并非一直如此。目前已经介绍过的两种例外情况是：

1.  使用拷贝初始化时(即使用=时)，只能提供一个初始值;
2.  如果提供的是一个类内初始值，则只能使用拷贝初始化或使用花括号的形式初始化。

第三种特殊的要求是，如果提供的是初始元素值的**列表**，则只能把初始值都放在**花括号**里进行列表初始化，而不能放在圆括号里：

vector<string> v1{ "a", "an", "the"}; // list initialization
    vector<string> v2("a", "an", "the"); // error

#### 创建指定数量的元素 ####

还可以用vector对象容纳的元素数量和所有元素的统一初始值来初始化vector对象：

vector<int> ivec(10, -1); // ten int elements, each initialized to -1
    vector<string> svec(10, "hi!"); // ten strings; each element is "hi!"

#### 值初始化 ####

通常情况下，可以只提供vector对象容纳的元素数量而不用略去初始值。此时库会创建一个**值初始化的**（value-initialized）元素初值，并把它赋给容器中的所有元素。这个初值由vector对象中元素的类型决定。

如果vector对象的元素是内置类型，比如 int，则元素初始值自动设为0。如果元素是某种类类型，比如 string，则元素由类默认初始化：

vector<int> ivec(10); // ten elements, each initialized to 0
    vector<string> svec(10); // ten elements, each an empty string

对这种初始化的方式有两个特殊限制：其一，有些类要求必须明确地提供初始值，如果vector对象中元素的类型不支持默认初始化，我们就必须提供初始的元素值。对这种类型的对象来说,只提供元素的数量而不设定初始值无法完成初始化工作。

其二，如果只提供了元素的数量而没有设定初始值，只能使用直接初始化：

vector<int> vi = 10; // error: must use direct initialization to supply a size

这里的10是用来说明如何初始化vector对象的，我们用它的本意是想创建含有10个值初始化了的元素的vector对象，而非把数字10“拷贝”到vector中。因此，此时不宜使用拷贝初始化。

#### 列表初始值还是元素数量 ####

在某些情况下，初始化的真实含义依赖于传递初始值时用的是**花括号**还是**圆括号**。

例如，用一个整数来初始化vector<int>时，整数的含义可能是vector对象的容量也可能是元素的值。类似的，用两个整数来初始化vector<int>时，这两个整数可能一个是vector对象的容量，另一个是元素的初值，也可能它们是容量为2的vector对象中两个元素的初值。通过使用花括号或圆括号可以区分上述这些含义：

vector<int> v1(10); // v1 has ten elements with value 0
    vector<int> v2{ 10}; // v2 has one element with value 10
    vector<int> v3(10, 1); // v3 has ten elements with value 1
    vector<int> v4{ 10, 1}; // v4 has two elements with values 10 and 1

如果用的是**圆括号**，可以说提供的值是用来**构造**（construct）vector对象的。例如，v1的初始值说明了vector对象的容量; v3的两个初始值则分别说明了vector对象的容量和元素的初值。

如果用的是**花括号**，可以表述成我们想列表**初始化**（list initialize）该vector对象。也就是说，初始化过程会尽可能地把花括号内的值当成是元素初始值的列表来处理，只有在无法执行列表初始化时才会考虑其他初始化方式。

在上例中，给v2和v4提供的初始值都能作为元素的值，所以它们都会执行列表初始化，vector对象v2包含一个元素而vector对象v4包含两个元素。

另一方面，如果初始化时使用了花括号的形式但是提供的值又不能用来列表初始化，就要考虑用这样的值来构造vector对象了。例如，要想列表初始化一个含有string对象的vector对象，应该提供能赋给string对象的初值。此时不难区分到底是要列表初始化vector对象的元素还是用给定的容量值来构造vector对象：（Note：**勉强初始化**）

vector<string> v5{ "hi"}; // list initialization: v5 has one element
    vector<string> v6("hi"); // error: can't construct a vector from a string literal
    vector<string> v7{ 10}; // v7 has ten default-initialized elements
    vector<string> v8{ 10, "hi"}; // v8 has ten elements with value "hi"

尽管在上面的例子中除了第二条语句之外都用了花括号，但其实只有v5是列表初始化。要想列表初始化 vector对象，花括号里的值必须与元素类型相同。显然不能用int初始化 string对象，所以v7和v8提供的值不能作为元素的初始值。确认无法执行列表初始化后，**编译器会尝试用默认值初始化vector对象**。

### 向vector对象中添加元素 ###

对vector对象来说，直接初始化的方式适用于三种情况：

1.  初始值已知且数量较少，vector<T> v5\{a, b, c…\}
2.  初始值是另一个vector对象的副本，vector<T> v2(v1)
3.  所有元素的初始值都一样。vector<T> v3 (n, val)

然而更常见的情况是：创建一个vector对象时并不清楚实际所需的元素个数，元素的值也经常无法确定。还有些时候即使元素的初值已知，但如果这些值总量较大而各不相同，那么在创建vector对象的时候执行初始化操作也会显得过于烦琐。

举个例子，如果想创建一个vector对象令其包含从0到9共10个元素，使用列表初始化的方法很容易做到这一点，但如果vector对象包含的元素是从0到99或者从0到999呢？这时通过列表初始化把所有元素都一一罗列出来就不太合适了。

对于此例来说，更好的处理方法是先创建一个空vector，然后在运行时再利用vector的成员函数**push\_back**向其中添加元素。push\_back 负责把一个值当成vector对象的尾元素“压到（push）” vector对象的“尾端（back）”。例如:

vector<int> v2; // empty vector
    for (int i = 0; i != 100; ++i)
    	v2.push_back(i); // append sequential integers to v2
    // at end of loop v2 has 100 elements, values 0 . . . 99

同样的，如果直到运行时才能知道vector对象中元素的确切个数，也应该使用刚刚这种方法创建vector对象并为其赋值。例如，有时需要实时读入数据然后将其赋予vector对象：

// read words from the standard input and store them as elements in a vector
    string word;
    vector<string> text; // empty vector
    while (cin >> word) { 
    	text.push_back(word); // append word to text
    }

#### 关键概念：vector对象能高效增长 ####

C++标准要求vector应该能在运行时高效快速地添加元素。因此既然 vector对象能高效地增长，那么在定义vector对象的时候设定其大小也就没什么必要了，事实上如果这么做**性能可能更差**。只有一种例外情况，就是所有（all）元素的值都一样。一旦元素的值有所不同，更有效的办法是先定义一个空的vector对象，再在运行时向其中添加具体值。此外，在未来将介绍vector还提供了方法，允许我们进一步提升动态添加元素的性能。

开始的时候创建空的vector对象，在运行时再动态添加元素，这一做法与C语言及其他大多数语言中内置数组类型的用法不同。特别是如果用惯了C或者Java，可以预计在创建vector对象时顺便指定其容量是最好的。然而事实上，通常的情况是恰恰相反。

（在Java中，如果你一开始知道容器的容量，就设定容器的容量，这样可以减少容器扩容时所带来的消耗）

#### 向vector对象添加元素蕴含的编程假定 ####

由于能高效便捷地向vector对象中添加元素，很多编程工作被极大简化了。然而，这种简便性也伴随着一些对编写程序更高的要求:其中一条就是必须要确保所写的循环正确无误，特别是在循环**有可能改变vector对象容量**的时候。

随着对vector的更多使用，我们还会逐渐了解到其他一些隐含的要求，其中一条是现在就要指出的：如果循环体内部包含有向vector对象添加元素的语句，则不能使用范围for循环，具体原因在日后详细解释。

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

（在Java中，如果for循环遍历一个List时，增删元素，后台会抛出ConcurrentModificationException）

### 其他vector操作 ###

<table> 
 <thead> 
  <tr> 
   <th>.</th> 
   <th>.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>v.empty()</td> 
   <td>如果v不含有任何元素，返回真;否则返回假</td> 
  </tr> 
  <tr> 
   <td>v.size()</td> 
   <td>返回v中元素的个数</td> 
  </tr> 
  <tr> 
   <td>v.push_back(t)</td> 
   <td>向v的尾端添加一个值为t的元素</td> 
  </tr> 
  <tr> 
   <td>v[n]</td> 
   <td>返回v中第n个位置上元素的引用</td> 
  </tr> 
  <tr> 
   <td>v1 = v2</td> 
   <td>用v2中元素的拷贝替换v1中的元素</td> 
  </tr> 
  <tr> 
   <td>v1 ={a,b,c…}</td> 
   <td>用列表中元素的拷贝替换v1中的元素</td> 
  </tr> 
  <tr> 
   <td>vl == v2</td> 
   <td>v1和v2相等当且仅当它们的元素数量相同且对应位置的元素值都相同</td> 
  </tr> 
  <tr> 
   <td>v1 != v2</td> 
   <td>.</td> 
  </tr> 
  <tr> 
   <td>&lt;, &lt;=, &gt;, &gt;=</td> 
   <td>顾名思义，以字典顺序进行比较</td> 
  </tr> 
 </tbody> 
</table>

**访问vector对象中元素**的方法和访问string对象中字符的方法差不多，也是通过元素在vector对象中的位置。例如，可以使用范围for语句处理vector对象中的所有元素：

vector<int> v{ 1,2,3,4,5,6,7,8,9};
    for (auto &i : v) // for each element in v (note: i is a reference)
    	i *= i; // square the element value
    for (auto i : v) // for each element in v
    	cout << i << " "; // print the element
    cout << endl;

**vector的empty和size**两个成员与string 的同名成员功能完全一致：

*  empty检查vector对象是否包含元素然后返回一个布尔值;
 *  size则返回vector对象中元素的个数，返回值的类型是由vector定义的size\_type类型。

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

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

**vector比较**

**各个相等性运算符和关系运算符**也与string 的相应运算符功能一致。

两个vector对象相等当且仅当它们所含的元素个数相同，而且对应位置的元素值也相同。

关系运算符依照字典顺序进行比较：

*  如果两个vector对象的容量不同，但是在相同位置上的元素值都一样，则元素较少的vector对象小于元素较多的vector对象;
 *  若元素的值有区别，则vector对象的大小关系由第一对相异的元素值的大小关系决定。

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

*  一些类，如 string等，确实定义了自己的相等性运算符和关系运算符;
 *  另外一些，如 Sales\_item类支持的运算已经全都罗列在第一章中了，显然并不支持相等性判断和关系运算等操作。因此，不能比较两个vector<Sales\_item>对象。

#### 计算vector内对象的索引 ####

使用下标运算符能获取到指定的元素。和 string一样，vector对象的下标也是从О开始计起，下标的类型是相应的 size\_type类型。只要vector对象不是一个常量，就能向下标运算符返回的元素赋值。此外，也能通过计算得到 vector 内对象的索引，然后直接获取索引位置上的元素。

举个例子，假设有一组成绩的集合，其中成绩的取值是从0到100。以10分为一个分数段，要求统计各个分数段各有多少个成绩。显然，从0到100总共有101种可能的成绩取值，这些成绩分布在11个分数段上:每10个分数构成一个分数段，这样的分数段有10个，额外还有一个分数段表示满分100分。这样第一个分数段将统计成绩在0到9之间的数量;第二个分数段将统计成绩在10到19之间的数量，以此类推。最后一个分数段统计满分100分的数量。

// count the number of grades by clusters of ten: 0--9, 10--19, . .. 90--99, 100
    vector<unsigned> scores(11, 0); // 11 buckets, all initially 0
    unsigned grade;
    while (cin >> grade) {  // read the grades
    	if (grade <= 100) // handle only valid grades
    		++scores[grade/10]; // increment the counter for the current cluster
    }

输入：

42 65 95 100 39 67 95 76 88 76 83 92 76 93

如果输出scores，则为：

0 0 0 1 1 0 2 3 2 4 1

#### 不能用下标形式添加元素 ####

刚接触C++语言的程序员也许会认为可以通过vector对象的下标形式来添加元素，**事实并非如此**。下面的代码试图为vector对象ivec添加10个元素：

vector<int> ivec; // empty vector
    for (decltype(ivec.size()) ix = 0; ix != 10; ++ix)
    	ivec[ix] = ix; // disaster: ivec has no elements

然而，这段代码是错误的：ivec是一个空 vector，根本不包含任何元素，当然也就不能通过下标去访问任何元素!如前所述，正确的方法是使用push\_back：

for (decltype(ivec.size()) ix = 0; ix != 10; ++ix)
    	ivec.push_back(ix); // ok: adds a new element with value ix

**vector对象（以及string对象）的下标运算符可用于访问已存在的元素,而不能用于添加元素。**

#### 提示:只能对确知已存在的元素执行下标操作! ####

关于下标必须明确的一点是：只能对确知已存在的元素执行下标操作。例如,

vector<int> ivec; // empty vector
    cout << ivec[0]; // error: ivec has no elements!
    
    vector<int> ivec2(10); // vector with ten elements
    cout << ivec2[10]; // error: ivec2 has elements 0 . . . 9

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

不幸的是,这种通过下标访问不存在的元素的行为非常常见，而且会产生很严重的后果。所谓的缓冲区溢出（buffer overflow）指的就是这类错误，这也是导致PC及其他设备上应用程序出现安全问题的一个重要原因。

确保下标合法的一种有效手段就是尽可能使用范围for语句。

## 迭代器介绍 ##

已经知道可以使用下标运算符来访问string 对象的字符或vector对象的元素，还有另外一种更通用的机制也可以实现同样的目的，这就是迭代器（ iterator)。

除了vector之外，标准库还定义了其他几种容器。**所有标准库容器都可以使用迭代器**，但是其中**只有少数几种才同时支持下标运算符**。（Note：日后就用迭代器迭代）

严格来说，string对象不属于容器类型，但是string支持很多与容器类型类似的操作。vector支持下标运算符，这点和 string一样；string支持迭代器，这也和 vector是一样的。

类似于指针类型，**迭代器也提供了对对象的间接访问**。

*  就迭代器而言，其对象是容器中的元素或者string对象中的字符。
 *  使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另外一个元素。
 *  迭代器有有效和无效之分，这一点和指针差不多。有效的迭代器或者指向某个元素，或者指向容器中尾元素的下一位置；其他所有情况都属于无效。

### 使用迭代器 ###

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

// the compiler determines the type of b and e; see § 2.5.2 (p. 68)
    // b denotes the first element and e denotes one past the last element in v
    auto b = v.begin(), e = v.end(); // b and e have the same type

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

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

一般来说，我们不清楚（不在意）迭代器准确的类型到底是什么。在上面的例子中，使用auto关键字定义变量b和e ，这两个变量的类型也就是begin和 end的返回值类型，稍后做更详细的介绍。

#### 迭代器运算符 ####

下表列举了迭代器支持的一些运算。使用==和!=来比较两个合法的迭代器是否相等，如果两个迭代器指向的元素相同或者都是同一个容器的尾后迭代器，则它们相等；否则就说这两个迭代器不相等。

<table> 
 <thead> 
  <tr> 
   <th>.</th> 
   <th>.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*iter</td> 
   <td>返回迭代器iter所指元素的引用</td> 
  </tr> 
  <tr> 
   <td>iter-&gt;mem</td> 
   <td>解引用iter并获取该元素的名为mem的成员，等价于(*iter).mem</td> 
  </tr> 
  <tr> 
   <td>++iter</td> 
   <td>令iter指示容器中的下一个元素</td> 
  </tr> 
  <tr> 
   <td>–iter</td> 
   <td>令iter指示容器中的上一个元素</td> 
  </tr> 
  <tr> 
   <td>iter1 == iter2</td> 
   <td>判断两个迭代器是否相等，如果两个迭代器指示的是同一个元素或者它们是同一个容器的尾后迭代器，则相等；反之，不相等</td> 
  </tr> 
  <tr> 
   <td>iter1 != iter2</td> 
   <td>判断两个迭代器是否不相等</td> 
  </tr> 
 </tbody> 
</table>

和指针类似，也能通过解引用迭代器来获取它所指示的元素，执行解引用的迭代器必须合法并确实指示着某个元素。试图解引用一个非法迭代器或者尾后迭代器都是未被定义的行为。

举个例子，用迭代器把string对象的第一个字母改为了大写形式:

string s("some string");
    if (s.begin() != s.end()) {  // make sure s is not empty
    auto it = s.begin(); // it denotes the first character in s
    	*it = toupper(*it); // make that character uppercase
    }

若输出s，结果将是：

Some string

#### 将迭代器从一个元素移动到另外一个元素 ####

迭代器使用递增（++）运算符来从一个元素移动到下一个元素。从逻辑上来说，迭代器的递增和整数的递增类似，整数的递增是在整数值上“加1“，迭代器的递增则是将迭代器“向前移动一个位置”。

**因为end返回的迭代器并不实际指示某个元素，所以不能对其进行递增或解引用的操作。**

之前有一个程序把string对象中第一个单词改写为大写形式，现在利用迭代器及其递增运算符可以实现相同的功能：

// process characters in s until we run out of characters or we hit a whitespace
    for (auto it = s.begin(); it != s.end() && !isspace(*it);
    ++it)
    	*it = toupper(*it); // capitalize the current character

#### 关键概念：泛型编程 ####

原来使用C或Java的程序员在转而使用C++语言之后，会对for循环中使用!=而非<进行判断有点儿奇怪。**C++程序员习惯性地使用!=**，其原因和他们更愿意使用迭代器而非下标的原因一样（支持下标的容器只有少数）；因为**这种编程风格在标准库提供的所有容器上都有效**。

之前已经说过,只有string和 vector等一些标准库类型有下标运算符，而并非全都如此。

与之类似，**所有标准库容器的迭代器都定义了==和!=**，但是它们中的大多数都没有定义<运算符。因此，**只要我们养成使用迭代器和!=的习惯**，就不用太在意用的到底是哪种容器类型。

#### 迭代器类型 ####

就像不知道string 和 vector的size\_type成员到底是什么类型一样，一般来说我们也不知道（**其实是无须知道**）迭代器的精确类型。而实际上，那些拥有迭代器的标准库类型使用iterator和const\_iterator来表示迭代器的类型：

vector<int>::iterator it; // it can read and write vector<int> elements
    string::iterator it2; // it2 can read and write characters in a string
    vector<int>::const_iterator it3; // it3 can read but not write elements
    string::const_iterator it4; // it4 can read but not write
    characters

const\_iterator和常量指针差不多，能读取但**不能**修改它所指的元素值。相反，iterator的对象可读可写。

*  如果vector对象或string对象是一个常量，只能使用const\_iterator；
 *  如果vector对象或string对象不是常量，那么既能使用iterator也能使用const\_iterator。

#### 术语:迭代器和迭代器类型 ####

迭代器这个名词有三种不同的含义：

1.  可能是迭代器概念本身，
2.  可能是指容器定义的迭代器类型,
3.  可能是指某个迭代器对象。

**重点是理解存在一组概念上相关的类型，我们认定某个类型是迭代器当且仅当它支持一套操作，这套操作使得我们能访问容器的元素或者从某个元素移动到另外一个元素。**

每个容器类定义了一个名为 iterator的类型，该类型支持迭代器概念所规定的一套操作。

#### begin和end运算符 ####

begin和end返回的具体类型由对象是否是常量决定，

*  如果对象是常量，begin和end返回const\_iterator;
 *  如果对象不是常量，返回iterator:

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

有时候这种默认的行为并非我们所要。

如果对象只需读操作而无须写操作的话最好使用常量类型（比如 const\_iterator）。为了便于专门得到const\_iterator类型的返回值，**C++11新标准**引入了两个新函数，分别是cbegin和cend：

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

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

#### 结合解引用和成员访问操作 ####

解引用迭代器可获得迭代器所指的对象，如果该对象的类型恰好是类，就有可能希望进一步访问它的成员。例如，对于一个由字符串组成的vector对象来说，要想检查其元素是否为空，令it是该vector对象的迭代器，只需检查it所指字符串是否为空就可以了，其代码如下所示:

(*it).empty()

注意，(\*it). empty()中的圆括号必不可少，具体原因稍后介绍，该表达式的含义是先对it解引用，然后解引用的结果再执行点运算符。如果不加圆括号，点运算符将由it来执行，而非it解引用的结果：

(*it).empty() // dereferences it and calls the member empty on the resulting object
    *it.empty() // error: attempts to fetch the member named empty from it
    			// but it is an iterator and has no member named empty

上面第二个表达式的含义是从名为it的对象中寻找其 empty成员，显然it是一个迭代器，它没有哪个成员是叫empty的，所以第二个表达式将发生错误。

为了简化上述表达式，C++语言定义了**箭头运算符**（->）。箭头运算符把解引用和成员访问两个操作结合在一起，也就是说，it->mem和(\*it).mem表达的意思相同。

例如，假设用一个名为text的字符串向量存放文本文件中的数据，其中的元素或者是一句话或者是一个用于表示段落分隔的空字符串。如果要输出text中第一段的内容，可以利用迭代器写一个循环令其遍历text，直到遇到空字符串的元素为止：

// print each line in text up to the first blank line
    for (auto it = text.cbegin();
    it != text.cend() && !it->empty(); ++it)
    	cout << *it << endl;

#### 某些对vector对象的操作会使迭代器失效 ####

曾经介绍过，虽然vector对象可以动态地增长，但是也会有一些副作用。已知的一个限制是不能在范围for循环中向vector对象添加元素。另外一个限制是任何一种可能改变vector对象容量的操作，比如 push\_back，都会使该vector对象的迭代器失效。日后将详细解释迭代器是如何失效的。

**谨记，但凡是使用了迭代器的循环体，都不要向迭代器所属的容器添加元素。**

### 迭代器运算 ###

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

string和 vector的迭代器提供了更多额外的运算符，一方面可使得迭代器的每次移动跨过多个元素，另外也支持迭代器进行关系运算。所有这些运算被称作**迭代器运算**（iterator arithmetic），其细节如表列出：

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

#### 迭代器的算术运算 ####

可以令迭代器和一个整数值相加（或相减），其返回值是向前（或向后）移动了若干个位置的迭代器。执行这样的操作时，结果迭代器或者指示原vector对象（或string对象）内的一个元素，或者指示原vector对象（或string对象）尾元素的下一位置。

举个例子，下面的代码得到一个迭代器，它指向某vector对象中间位置的元素：

// compute an iterator to the element closest to the midpoint of vi
    auto mid = vi.begin() + vi.size() / 2;

对于string或vector的迭代器来说,除了判断是否相等,还能使用关系运算符（<、<=、>、>=）对其进行比较。参与比较的两个迭代器必须合法而且指向的是同一个容器的元素（或者尾元素的下一位置)。例如，假设it和mid是同一个vector对象的两个迭代器，可以用下面的代码来比较它们所指的位置孰前孰后：

if (it < mid)
        // process elements in the first half of vi

只要两个迭代器指向的是同一个容器中的元素或者尾元素的下一位置，就能将其相减，所得结果是两个迭代器的距离。所谓距离指的是右侧的迭代器向前移动多少位置就能追上左侧的迭代器，其类型是名为 **difference\_type** 的带符号整型数。string和vector都定义了difference\_type，因为这个距离可正可负，所以difference\_type是带符号类型的。

#### 使用迭代器运算 ####

使用迭代器运算的一个经典算法是二分搜索。

二分搜索从有序序列中寻找某个给定的值。二分搜索从序列中间的位置开始搜索，

*  如果中间位置的元素正好就是要找的元素，搜索完成;
 *  如果不是，
    
     *  假如该元素小于要找的元素，则在序列的后半部分继续搜素;
     *  假如该元素大于要找的元素，则在序列的前半部分继续搜索。

在缩小的范围中计算一个新的中间元素并重复之前的过程，直至最终找到目标或者没有元素可供继续搜索。

// text must be sorted
    // beg and end will denote the range we're searching
    auto beg = text.begin(), end = text.end();
    auto mid = text.begin() + (end - beg)/2; // original midpoint
    // while there are still elements to look at and we haven't yet found sought
    while (mid != end && *mid != sought) { 
        if (sought < *mid) // is the element we want in the first half?
    	    end = mid; // if so, adjust the range to ignore the second half
        else // the element we want is in the second half
        	beg = mid + 1; // start looking with the element just after mid
        mid = beg + (end - beg)/2; // new midpoint
    }

## 数组 ##

数组是一种类似于标准库类型vector的数据结构，但是在性能和灵活性的权衡上又与vector有所不同。

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

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

**如果不清楚元素的确切个数，请使用vector。**

### 定义和初始化内置数组 ###

数组是一种复合类型。数组的声明形如 a\[d\]，其中 a是数组的名字，d是数组的维度。维度说明了数组中元素的个数，因此必须大于0。数组中元素的个数也属于数组类型的一部分，编译的时候维度应该是已知的。也就是说，维度必须是一个常量表达式：

unsigned cnt = 42; // not a constant expression
    constexpr unsigned sz = 42; // constant expression
    							// constexpr see § 2.4.4 (p. 66)
    int arr[10]; // array of ten ints
    int *parr[sz]; // array of 42 pointers to int
    string bad[cnt]; // error: cnt is not a constant expression
    string strs[get_size()]; // ok if get_size is constexpr, error otherwise

默认情况下，数组的元素被默认初始化。

**和内置类型的变量一样,如果在*函数内部*定义了某种内置类型的数组，那么默认初始化会令数组含有未定义的值。**

定义数组的时候必须指定数组的类型，不允许用auto关键字由初始值的列表推断类型。另外和 vector一样，数组的元素应为对象，因此不存在引用的数组。

#### 显式初始化数组元素 ####

可以对数组的元素进行列表初始化，此时允许忽略数组的维度。

*  如果在声明时没有指明维度，编译器会根据初始值的数量计算并推测出来;
 *  相反，如果指明了维度，那么初始值的总数量不应该超出指定的大小。
 *  如果维度比提供的初始值数量大，则用提供的初始值初始化靠前的元素，剩下的元素被初始化成默认值：

const unsigned sz = 3;
    int ia1[sz] = { 0,1,2}; // array of three ints with values 0, 1, 2
    int a2[] = { 0, 1, 2}; // an array of dimension 3
    int a3[5] = { 0, 1, 2}; // equivalent to a3[] = {0, 1, 2, 0, 0}
    string a4[3] = { "hi", "bye"}; // same as a4[] = {"hi", "bye", ""}
    int a5[2] = { 0,1,2}; // error: too many initializers

#### 字符数组的特殊性 ####

字符数组有一种额外的初始化形式，我们可以用字符串字面值对此类数组初始化。当使用这种方式时，一定要注意字符串字面值的结尾处还有一个空字符，这个空字符也会像字符串的其他字符一样被拷贝到字符数组中去:

char a1[] = { 'C', '+', '+'}; // list initialization, no null
    char a2[] = { 'C', '+', '+', '\0'}; // list initialization, explicit null
    char a3[] = "C++"; // null terminator added
    automatically
    const char a4[6] = "Daniel"; // error: no space for the null!

#### 不允许拷贝和赋值 ####

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

int a[] = { 0, 1, 2}; // array of three ints
    int a2[] = a; // error: cannot initialize one array with another
    a2 = a; // error: cannot assign one array to another

一些编译器支持数组的赋值，这就是所谓的**编译器扩展**（compiler extension）。但一般来说，最好避免使用非标准特性,因为含有非标准特性的程序很可能在其他编译器上无法正常工作。

#### 理解复杂的数组声明 ####

和 vector一样，数组能存放大多数类型的对象。例如，可以定义一个存放指针的数组。又因为数组本身就是对象，所以允许定义数组的指针及数组的引用。在这几种情况中，定义存放指针的数组比较简单和直接，但是定义数组的指针或数组的引用就稍微复杂一点了:

int *ptrs[10]; // ptrs is an array of ten pointers to int
    int &refs[10] = /* ? */; // error: no arrays of references
    int (*Parray)[10] = &arr; // Parray points to an array of ten ints
    int (&arrRef)[10] = arr; // arrRef refers to an array of ten ints

默认情况下，类型修饰符从右向左依次绑定。

对于ptrs来说，**从右向左**理解其含义比较简单：首先知道我们定义的是一个大小为10的数组，它的名字是ptrs，然后知道数组中存放的是指向int的指针。

但是对于Parray来说，从右向左理解就不太合理了。因为数组的维度是紧跟着被声明的名字的，所以就数组而言，由内向外阅读要比从右向左好多了。

由内向外的顺序可帮助我们更好地理解 Parray 的含义：

*  首先是圆括号括起来的部分，\*Parray意味着Parray是个指针，
 *  接下来观察右边，可知道Parray是个指向大小为10的数组的指针，
 *  最后观察左边，知道数组中的元素是int。

这样最终的含义就明白无误了，Parray是一个指针，它指向一个int数组，数组中包含10个元素。

同理，(&arrRef)表示arrRef是一个引用，它引用的对象是一个大小为10的数组，数组中元素的类型是int。

当然，对修饰符的数量并没有特殊限制：

int *(&arry)[10] = ptrs; // arry is a reference to an array of ten pointers

按照由内向外的顺序阅读上述语句，

*  首先知道arry是一个引用，
 *  然后观察右边知道, arry引用的对象是一个大小为10的数组，
 *  最后观察左边知道，数组的元素类型是指向int的指针。

这样，arry就是一个含有10个int型指针的数组的引用。

要想理解数组声明的含义，**最好的办法是从数组的名字开始按照由内向外的顺序阅读**。

### 访问数组元素 ###

与标准库类型vector和 string一样，数组的元素也能使用范围for语句或下标运算符来访问。数组的索引从О开始，以一个包含10个元素的数组为例，它的索引从0到9，而非从1到10。

在使用数组下标的时候，通常将其定义为**size\_t**类型。size\_t是一种机器相关的无符号类型，它被设计得足够大以便能表示内存中任意对象的大小。在 cstddef头文件中定义了size\_t类型，这个文件是C标准库stddef.h头文件的C++语言版本。

数组除了大小固定这一特点外，其他用法与vector基本类似。例如，可以用数组来记录各分数段的成绩个数：

// count the number of grades by clusters of ten: 0--9, 10--19, ... 90--99, 100
    unsigned scores[11] = { }; // 11 buckets, all value initialized to 0
    unsigned grade;
    while (cin >> grade) { 
    	if (grade <= 100)
    		++scores[grade/10]; // increment the counter for the current cluster
    }

数组下标运算符与vector下标运算符**不太明显的区别**是，

*  数组的下标运算符是由C++语言直接定义的，这个运算符能用在数组类型的运算对象上。
 *  vector所用的下标运算符是库模板vector定义的，只能用于vector类型的运算对象。

与vector和 string一样，当需要遍历数组的所有元素时，最好的办法也是使用范围for语句。例如，下面的程序输出所有的scores：

for (auto i : scores) // for each counter in scores
        cout << i << " "; // print the value of that counter
    cout << endl;

因为维度是数组类型的一部分，所以系统知道数组scores 中有多少个元素，使用范围for语句可以减轻人为控制遍历过程的负担。

#### 检查下标的值 ####

与vector和 string一样，数组的下标是否在合理范围之内由程序员负责检查，所谓合理就是说下标应该大于等于0而且小于数组的大小。要想防止数组下标越界，除了小心谨慎注意细节以及对代码进行彻底的测试之外，没有其他好办法。对于一个程序来说，即使顺利通过编译并执行，也不能肯定它不包含此类致命的错误。

**大多数常见的安全问题都源于缓冲区溢出错误。当数组或其他类似数据结构的下标越界并试图访问非法内存区域时，就会产生此类错误。**

### 指针和数组 ###

在C++语言中，**指针和数组有非常紧密的联系**。就如即将介绍的，使用数组的时候编译器一般会把它转换成指针。

通常情况下，使用取地址符来获取指向某个对象的指针，取地址符可以用于任何对象。数组的元素也是对象，对数组使用下标运算符得到该数组指定位置的元素。因此像其他对象一样,对数组的元素使用取地址符就能得到指向该元素的指针：

string nums[] = { "one", "two", "three"}; // array of strings
    string *p = &nums[0]; // p points to the first element in nums

然而，数组还有一个特性：在很多用到数组名字的地方，编译器都会自动地将其替换为一个指向数组首元素的指针：

string *p2 = nums; // equivalent to p2 = &nums[0]

**在大多数表达式中，使用数组类型的对象其实是使用一个指向该数组首元素的指针。**

由上可知，在一些情况下数组的操作实际上是指针的操作，这一结论有很多隐含的意思。其中一层意思是当使用数组作为一个**auto**变量的初始值时，推断得到的类型是指针而非数组：

int ia[] = { 0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
    auto ia2(ia); // ia2 is an int* that points to the first element in ia
    ia2 = 42; // error: ia2 is a pointer, and we can't assign an int to a pointer

尽管ia是由10个整数构成的数组，但当使用ia作为初始值时，编译器实际执行的初始化过程类似于下面的形式：

auto ia2(&ia[0]); // now it's clear that ia2 has type int*

必须指出的是，当使用**decltype**关键字时上述转换不会发生，decltype(ia)返回的类型是由10个整数构成的数组：

// ia3 is an array of ten ints
    decltype(ia) ia3 = { 0,1,2,3,4,5,6,7,8,9};
    ia3 = p; // error: can't assign an int* to an array
    ia3[4] = i; // ok: assigns the value of i to an element in ia3

#### 指针也是迭代器 ####

与介绍的内容相比，指向数组元素的指针拥有更多功能。vector和 string 的迭代器支持的运算，数组的指针全都支持。例如，允许使用递增运算符将指向数组元素的指针向前移动到下一个位置上：

int arr[] = { 0,1,2,3,4,5,6,7,8,9};
    int *p = arr; // p points to the first element in arr
    ++p; // p points to arr[1]

就像使用迭代器遍历vector对象中的元素一样，使用指针也能遍历数组中的元素。

当然，这样做的前提是先得获取到指向数组第一个元素的指针和指向数组尾元素的下一位置的指针。

之前已经介绍过，通过数组名字或者数组中首元素的地址都能得到指向首元素的指针；不过获取尾后指针就要用到数组的另外一个特殊性质了。我们可以设法获取数组尾元素之后的那个并不存在的元素的地址：

int *e = &arr[10]; // pointer just past the last element in arr

这里显然使用下标运算符索引了一个不存在的元素，arr有10个元素，尾元素所在位置的索引是9，接下来那个不存在的元素唯一的用处就是提供其地址用于初始化 e。就像**尾后迭代器**一样，尾后指针也不指向具体的元素。因此，不能对尾后指针执行解引用或递增的操作。

利用上面得到的指针能重写之前的循环，令其输出arr的全部元素：

for (int *b = arr; b != e; ++b)
    	cout << *b << endl; // print the elements in arr

#### 标准库函数begin和end ####

尽管能计算得到尾后指针，但这种用法极易出错。为了让指针的使用更简单、更安全，C++11新标准引入了两个名为 begin和 end的函数。这两个函数与容器中的两个同名成员功能类似，不过数组毕竟不是类类型，因此这两个函数不是成员函数。正确的使用形式是将数组作为它们的参数：

#include <iterator>
    
    int ia[] = { 0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
    int *beg = begin(ia); // pointer to the first element in ia
    int *last = end(ia); // pointer one past the last element in ia

begin函数返回指向ia首元素的指针，end函数返回指向ia尾元素下一位置的指针，**这两个函数定义在iterator头文件中**。

使用begin和 end可以很容易地写出一个循环并处理数组中的元素。例如,假设arr是一个整型数组，下面的程序负责找到arr中的第一个负数：

// pbeg points to the first and pend points just past the last element in arr
    int *pbeg = begin(arr), *pend = end(arr);
    // find the first negative element, stopping if we've seen all the elements
    while (pbeg != pend && *pbeg >= 0)
    	++pbeg;

一个指针如果指向了某种内置类型数组的尾元素的“下一位置”，则其具备与vector的end函数返回的与迭代器类似的功能。**特别要注意，尾后指针不能执行解引用和递增操作**。

#### 指针运算 ####

指向数组元素的指针可以执行所有迭代器运算。这些运算，包括

*  解引用、
 *  递增、
 *  比较、
 *  与整数相加、
 *  两个指针相减
 *  …

用在指针和用在迭代器上意义完全一致。

**与整数相加**

给（从）一个指针加上（减去）某整数值，结果仍是指针。新指针指向的元素与原来  
的指针相比前进了（后退了）该整数值个位置：

constexpr size_t sz = 5;
    int arr[sz] = { 1,2,3,4,5};
    int *ip = arr; // equivalent to int *ip = &arr[0]
    int *ip2 = ip + 4; // ip2 points to arr[4], the last element in arr

ip加上4所得的结果仍是一个指针，该指针所指的元素与ip原来所指的元素相比前进了4个位置。

给指针加上一个整数，得到的新指针仍需指向同一数组的其他元素，或者指向同一数组的尾元素的下一位置（如果计算所得的指针超出了上述范围就将产生错误，而且这种错误编译器一般发现不了。）：

// ok: arr is converted to a pointer to its first element; p points one past the end of arr
    int *p = arr + sz; // use caution -- do not dereference!//指向同一数组的尾元素的下一位置
    int *p2 = arr + 10; // error: arr has only 5 elements; p2 has undefined value

当给arr加上sz时，编译器自动地将arr转换成指向数组 arr中首元素的指针。执行加法后，指针从首元素开始向前移动了sz（这里是5）个位置，指向新位置的元素。也就是说，它指向了数组arr尾元素的下一位置。

**两个指针相减**

和迭代器一样，两个指针相减的结果是它们之间的距离。参与运算的两个指针必须指向同一个数组当中的元素：

auto n = end(arr) - begin(arr); // n is 5, the number of elements in arr

两个指针相减的结果的类型是一种名为ptrdiff\_t 的标准库类型，和 size\_t一样，ptrdiff\_t 也是一种定义在 cstddef头文件中的机器相关的类型。因为差值可能为负值，所以ptrdiff\_t是一种带符号类型。

只要两个指针指向同一个数组的元素，或者指向该数组的尾元素的下一位置，就能利用关系运算符对其进行比较。例如，可以按照如下的方式遍历数组中的元素：

int *b = arr, *e = arr + sz;
    while (b < e) { 
    	// use *b
    	++b;
    }

如果两个指针分别指向不相关的对象，则不能比较它们：

int i = 0, sz = 42;
    int *p = &i, *e = &sz;
    // undefined: p and e are unrelated; comparison is meaningless!
    while (p < e)

尽管作用可能不是特别明显，但必须说明的是，**上述指针运算同样适用于空指针和所指对象并非数组的指针**。在后一种情况下，两个指针必须指向同一个对象或该对象的下一位置。如果p 是空指针，允许给 p加上或减去一个值为o的整型常量表达式。两个空指针也允许彼此相减，结果当然是0。

#### 解引用和指针运算的交互 ####

指针加上一个整数所得的结果还是一个指针。假设结果指针指向了一个元素，则允许解引用该结果指针：

int ia[] = { 0,2,4,6,8}; // array with 5 elements of type int
    int last = *(ia + 4); // ok: initializes last to 8, the value of ia[4]

表达式\* (ia+4)计算ia前进4个元素后的新地址，解引用该结果指针的效果等价于表达式ia\[ 4 \]。

回忆一下先前介绍过如果表达式含有**解引用运算符**和**点运算符**，最好在必要的地方加上圆括号。类似的，此例中指针加法的**圆括号也不可缺少**。如果写成下面的形式：

last = *ia + 4; // ok: last = 4, equivalent to ia[0] + 4

含义就与之前完全不同了，此时先解引用ia，然后给解引用的结果再加上4。

#### 下标和指针 ####

如前所述，**在很多情况下使用数组的名字其实用的是一个指向数组首元素的指针**。一个典型的例子是当对数组使用下标运算符时，编译器会自动执行上述转换操作。给定

int ia[] = { 0,2,4,6,8}; // array with 5 elements of type int

此时，ia\[0\]是一个使用了数组名字的表达式，对数组执行下标运算其实是对指向数组元素的指针执行下标运算：

int i = ia[2]; // ia is converted to a pointer to the first element in ia
    // ia[2] fetches the element to which (ia + 2) points
    int *p = ia; // p points to the first element in ia
    i = *(p + 2); // equivalent to i = ia[2]

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

int *p = &ia[2]; // p points to the element indexed by 2
    int j = p[1]; // p[1] is equivalent to *(p + 1),
    // p[1] is the same element as ia[3]
    int k = p[-2]; // p[-2] is the same element as ia[0]

虽然标准库类型string和vector也能执行下标运算，但是数组与它们相比还是有所不同。

*  标准库类型限定使用的下标必须是**无符号类型**，而内置的下标运算无此要求，上面的最后一个例子很好地说明了这一点。
 *  内置的下标运算符可以处理**负值**，当然，结果地址必须指向原来的指针所指同一数组中的元素（或是同一数组尾元素的下一位置)。

**内置的下标运算符所用的索引值不是无符号类型，这一点与vector和string不一样。**

### C风格字符串 ###

尽管C++支持C风格字符串，但**在C++程序中最好还是不要使用它们**。这是因为C风格字符串不仅使用起来不太方便，而且极易引发程序漏洞，是诸多安全问题的根本原因。

字符串字面值是一种通用结构的实例，这种结构即是C++由C继承而来的**C风格字符串**（C-style character string）。C风格字符串不是一种类型，而是为了表达和使用字符串而形成的一种约定俗成的写法。按此习惯书写的字符串存放在字符数组中并以**空字符结束**（null terminated）。以空字符结束的意思是在字符串最后一个字符后面跟着一个空字符(’\\0‘)。一般利用指针来操作这些字符串。

#### C标准库String函数 ####

下表列举了C语言标准库提供的一组函数，这些函数可用于操作C风格字符串，它们定义在cstring头文件中，cstring是C语言头文件string.h的C++版本。

<table> 
 <thead> 
  <tr> 
   <th>.</th> 
   <th>.</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>strlen§</td> 
   <td>返回p的长度，空字符不计算在内</td> 
  </tr> 
  <tr> 
   <td>strcmp(pi, p2)</td> 
   <td>比较p1和p2的相等性。如果p1==p2，返回0；如果p1&gt;p2,返回一个正值；如果pl&lt;p2，返回一个负值</td> 
  </tr> 
  <tr> 
   <td>strcat(pl, p2)</td> 
   <td>将p2附加到p1之后，返回p1</td> 
  </tr> 
  <tr> 
   <td>strcpy(p1, p2)</td> 
   <td>将p2拷贝给p1，返回p1</td> 
  </tr> 
 </tbody> 
</table>

**所列的函数不负责验证其字符串参数。**

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

char ca[] = { 'C', '+', '+'}; // not null terminated
    cout << strlen(ca) << endl; // disaster: ca isn't null terminated

此例中，ca虽然也是一个字符数组但它不是以空字符作为结束的，**因此上述程序将产生未定义的结果**。strlen函数将有可能沿着ca在内存中的位置不断向前寻找，直到遇到空字符才停下来。

#### 比较字符串 ####

比较两个C风格字符串的方法和之前学习过的比较标准库string对象的方法大相径庭。比较标准库string对象的时候，用的是普通的关系运算符和相等性运算符：

string s1 = "A string example";
    string s2 = "A different string";
    if (s1 < s2) // false: s2 is less than s1

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

const char ca1[] = "A string example";
    const char ca2[] = "A different string";
    if (ca1 < ca2) // undefined: compares two unrelated addresses

谨记之前介绍过的，当使用数组的时候其实真正用的是指向数组首元素的指针。因此，上面的if条件实际上比较的是两个const char\*的值。这两个指针指向的并非同一对象，所以将得到未定义的结果。

要想比较两个C风格字符串需要调用strcmp函数，此时比较的就不再是指针了。如果两个字符串相等，strcmp返回0；如果前面的字符串较大，返回正值;如果后面的字符串较大，返回负值：

if (strcmp(ca1, ca2) < 0) // same effect as string comparison s1 < s2

#### 目标字符串的大小由调用者指定 ####

连接或拷贝C风格字符串也与标准库string对象的同类操作差别很大。例如，要想把刚刚定义的那两个string对象s1和 s2连接起来，可以直接写成下面的形式：

// initialize largeStr as a concatenation of s1, a space, and s2
    string largeStr = s1 + " " + s2;

同样的操作如果放到cal和 ca2这两个数组身上就会产生错误了。表达式cal + ca2试图将两个指针相加，显然这样的操作没什么意义，也肯定是非法的。

正确的方法是使用strcat函数和strcpy函数。不过要想使用这两个函数，还必须提供一个用于存放结果字符串的数组，该数组必须足够大以便容纳下结果字符串及末尾的空字符。下面的代码虽然很常见，但是充满了安全风险，极易引发严重错误：

// disastrous if we miscalculated the size of largeStr
    strcpy(largeStr, ca1); // copies ca1 into largeStr
    strcat(largeStr, " "); // adds a space at the end of largeStr
    strcat(largeStr, ca2); // concatenates ca2 onto largeStr

一个潜在的问题是，我们在估算 largestr所需的空间时不容易估准，而且 largestr所存的内容一旦改变，就必须重新检查其空间是否足够。不幸的是，这样的代码到处都是，程序员根本没法照顾周全。这类代码充满了风险而且经常导致严重的安全泄漏。

**对大多数应用来说,使用标准库string要比使用C风格字符串更安全、更高效。**

（Note：放心去用标准库string）

### 与旧代码的接口 ###

很多C++程序在标准库出现之前就已经写成了，它们肯定没用到string和 vector类型。而且，有一些C+程序实际上是与C语言或其他语言的接口程序，当然也无法使用C++标准库。因此，现代的C++程序不得不与那些充满了数组和/或C风格字符串的代码衔接，为了使这一工作简单易行，C++专门提供了一组功能。

#### 混用string对象和C风格字符串 ####

前文介绍过允许使用字符串字面值来初始化string对象：

string s("Hello World"); // s holds Hello World

更一般的情况是，任何出现**字符串字面值**的地方都可以用**以空字符结束的字符数组**来替代：

*  允许使用**以空字符结束的字符数组**来初始化string对象或为 string对象赋值。
 *  在string 对象的**加法**运算中允许使用**以空字符结束的字符数组**作为其中一个运算对象（不能两个运算对象都是);
 *  在string对象的**复合赋值**运算中允许使用**以空字符结束的字符数组**作为右侧的运算对象。

上述性质反过来就不成立了：如果程序的某处需要一个C风格字符串，无法直接用string对象来代替它。例如，不能用string对象直接初始化指向字符的指针。

为了完成该功能，string专门提供了一个名为c\_str的成员函数：

char *str = s; // error: can't initialize a char* from a string
    const char *str = s.c_str(); // ok

顾名思义，c\_str函数的返回值是一个C风格的字符串。也就是说，函数的返回结果是一个指针，该指针指向一个以空字符结束的字符数组，而这个数组所存的数据恰好与那个string对象的一样。结果指针的类型是const char\*，从而确保我们不会改变字符数组的内容。

我们无法保证c\_str函数返回的数组一直有效，事实上，如果后续的操作改变了s的值就可能让之前返回的数组失去效用。

**如果执行完c\_str()函数后程序想一直都能使用其返回的数组，最好将该数组重新拷贝一份。**

#### 使用数组初始化vector对象 ####

前文介绍过不允许使用一个数组为另一个内置类型的数组赋初值，也不允许使用vector对象初始化数组。相反的，**允许使用数组来初始化vector对象**。要实现这一目的，只需指明要拷贝区域的首元素地址和尾后地址就可以了：

int int_arr[] = { 0, 1, 2, 3, 4, 5};
    // ivec has six elements; each is a copy of the corresponding element in int_arr
    vector<int> ivec(begin(int_arr), end(int_arr));

在上述代码中,用于创建ivec的两个指针实际上指明了用来初始化的值在数组int\_arr中的位置，其中第二个指针应指向待拷贝区域尾元素的下一位置。此例中，使用标准库函数begin和 end来分别计算int\_arr 的首指针和尾后指针。在最终的结果中，ivec将包含6个元素，它们的次序和值都与数组int\_arr完全一样。

用于初始化 vector对象的值也可能仅是数组的一部分：

// copies three elements: int_arr[1], int_arr[2], int_arr[3]
    vector<int> subVec(int_arr + 1, int_arr + 4);

这条初始化语句用3个元素创建了对象subvec，3个元素的值分别来自int\_arr\[1\]、int\_arr\[2\]和 int\_arr\[3\]。

#### 建议:尽量使用标准库类型而非数组 ####

使用指针和数组很容易出错。一部分原因是概念上的问题：**指针常用于底层操作**，因此容易引发一些与烦琐细节有关的错误。其他问题则源于语法错误，特别是声明指针时的语法错误。

**现代的C++程序应当尽量使用vector和迭代器，避免使用内置数组和指针；应该尽量使用string，避免使用C风格的基于数组的字符串。**

## 多维数组 ##

严格来说，C++语言中没有多维数组，**通常所说的多维数组其实是数组的数组**。谨记这一点，对今后理解和使用多维数组大有益处。

当一个数组的元素仍然是数组时，通常使用两个维度来定义它：一个维度表示数组本身大小，另外一个维度表示其元素（也是数组）大小：

int ia[3][4]; // array of size 3; each element is an array of ints of size 4
    // array of size 10; each element is a 20-element array whose elements are arrays of 30 ints
    int arr[10][20][30] = { 0}; // initialize all elements to 0

如前文所介绍的，按照**由内而外**的顺序阅读此类定义有助于更好地理解其真实含义。

在第一条语句中，我们定义的名字是ia，显然ia是一个含有3个元素的数组。接着观察右边发现，ia的元素也有自己的维度，所以ia的元素本身又都是含有4个元素的数组。再观察左边知道，真正存储的元素是整数。因此最后可以明确第一条语句的含义：**它定义了一个大小为3的数组，该数组的每个元素都是含有4个整数的数组**。

使用同样的方式理解arr的定义。首先arr是一个大小为10的数组，它的每个元素都是大小为20的数组，这些数组的元素又都是含有30个整数的数组。

实际上，定义数组时对下标运算符的数量并没有限制，因此只要愿意就可以定义这样一个数组：它的元素还是数组，下一级数组的元素还是数组，再下一级数组的元素还是数组，以此类推。

对于二维数组来说，常把第一个维度称作行，第二个维度称作列。

### 多维数组的初始化 ###

允许使用花括号括起来的一组值初始化多维数组，这点和普通的数组一样。下面的初始化形式中，多维数组的每一行分别用花括号括了起来：

int ia[3][4] = {  // three elements; each element is an array of size 4
    	{ 0, 1, 2, 3}, // initializers for the row indexed by 0
    	{ 4, 5, 6, 7}, // initializers for the row indexed by 1
    	{ 8, 9, 10, 11} // initializers for the row indexed by 2
    };

其中内层嵌套着的花括号**并非必需的**，例如下面的初始化语句，形式上更为简洁，完成的功能和上面这段代码完全一样：

// equivalent initialization without the optional nested braces for each row
    int ia[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11};

类似于一维数组，在初始化多维数组时也并非所有元素的值都必须包含在初始化列表之内。如果仅仅想初始化每一行的第一个元素，通过如下的语句即可：

// explicitly initialize only element 0 in each row
    int ia[3][4] = { {  0 }, {  4 }, {  8 }};

其他未列出的元素执行默认值初始化，这个过程和一维数组一样。在这种情况下如果再省略掉内层的花括号，结果就大不一样了。下面的代码

// explicitly initialize row 0; the remaining elements are value initialized
    int ix[3][4] = { 0, 3, 6, 9};

含义发生了变化，它初始化的是第一行的4个元素，其他元素被初始化为0。

### 多维数组的下标引用 ###

可以使用下标运算符来访问多维数组的元素，此时数组的每个维度对应一个下标运算符。

如果表达式含有的下标运算符数量和数组的维度一样多，该表达式的结果将是给定类型的元素;反之，如果表达式含有的下标运算符数量比数组的维度小，则表达式的结果将是给定索引处的一个内层数组：

// assigns the first element of arr to the last element in the last row of ia
    ia[2][3] = arr[0][0][0];//int arr[10][20][30] = {0}; 
    int (&row)[4] = ia[1]; // binds row to the second four-element array in ia

在**第一个例子**中，对于用到的两个数组来说，表达式提供的下标运算符数量都和它们各自的维度相同。在等号左侧，ia\[2\]得到数组ia的最后一行，此时返回的是表示ia最后一行的那个一维数组而非任何实际元素；对这个一维数组再取下标，得到编号为\[3\]的元素，也就是这一行的最后一个元素。

类似的，等号右侧的运算对象包含3个维度。首先通过索引0得到最外层的数组，它是一个大小为20的（多维）数组；接着获取这20个元素数组的第一个元素，得到一个大小为30的一维数组;最后再取出其中的第一个元素。

在**第二个例子**中，把 row定义成一个含有4个整数的数组的引用，然后将其绑定到ia的第2行。

再举一个例子，程序中经常会用到两层嵌套的for循环来处理多维数组的元素：

constexpr size_t rowCnt = 3, colCnt = 4;
    int ia[rowCnt][colCnt]; // 12 uninitialized elements
    // for each row
    for (size_t i = 0; i != rowCnt; ++i) { 
        // for each column within the row
        for (size_t j = 0; j != colCnt; ++j) { 
        	// assign the element's positional index as its value
        	ia[i][j] = i * colCnt + j;
        }
    }

外层的for循环遍历ia的所有元素，注意这里的元素是一维数组;内层的for循环则遍历那些一维数组的整数元素。此例中，我们将元素的值设为该元素在整个数组中的序号。

### 使用范围for语句处理多维数组 ###

由于在C++11新标准中新增了范围for语句，所以前一个程序可以简化为如下形式:

size_t cnt = 0;
    for (auto &row : ia) // for every element in the outer array
        for (auto &col : row) {  // for every element in the inner array
            col = cnt; // give this element the next value
            ++cnt; // increment cnt
        }

这个循环赋给ia元素的值和之前那个循环是完全相同的，区别之处是通过使用范围for语句把管理数组索引的任务交给了系统来完成。因为要改变元素的值，所以得把控制变量row和 col声明成引用类型。

*  第一个for循环遍历ia的所有元素，这些元素是大小为4的数组，因此row的类型就应该是含有4个整数的数组的引用。
 *  第二个for循环遍历那些4元素数组中的某一个，因此 col的类型是整数的引用。每次迭代把cnt的值赋给ia的当前元素，然后将cnt加1。

在上面的例子中，因为要改变数组元素的值，所以我们**选用引用类型**作为循环控制变量，但其实还有一个深层次的原因促使我们这么做。

举一个例子，考虑如下的循环：

for (const auto &row : ia) // for every element in the outer array
    	for (auto col : row) // for every element in the inner array
    		cout << col << endl;

这个循环中并没有任何写操作，可是我们还是将外层循环的控制变量声明成了引用类型，这是**为了避免数组被自动转成指针**。

假设不用引用类型，则循环如下述形式：

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

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

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

### 指针和多维数组 ###

当程序使用多维数组的名字时，也会自动将其转换成指向数组首元素的指针。

**定义指向多维数组的指针时，千万别忘了这个多维数组实际上是数组的数组。**

因为多维数组实际上是数组的数组，所以由多维数组名转换得来的指针实际上是指向第一个内层数组的指针：

int ia[3][4]; // array of size 3; each element is an array of ints of size 4
    int (*p)[4] = ia; // p points to an array of four ints//ia的第一行
    p = &ia[2]; // p now points to the last element in ia//ia的第三行

我们首先明确(\*p)意味着p是一个指针。接着观察右边发现，指针p所指的是一个维度为4的数组；再观察左边知道，数组中的元素是整数。因此，p就是指向含有4个整数的数组的指针。

**在上述声明中，圆括号必不可少：**

int *ip[4]; // array of pointers to int
    int (*ip)[4]; // pointer to an array of four ints

随着C++11新标准的提出，通过使用auto或者decltype就能尽可能地**避免在数组前面加上一个指针类型了**:

// print the value of each element in ia, with each inner array on its own line
    // p points to an array of four ints
    for (auto p = ia; p != ia + 3; ++p) { 
    // q points to the first element of an array of four ints; that is, q points to an int
        for (auto q = *p; q != *p + 4; ++q)
            cout << *q << ' ';
        cout << endl;
    }

使用标准库函数begin和end也能实现同样的功能，而且看起来更简洁一些：

#include <iterator>
    
    // p points to the first array in ia
    for (auto p = begin(ia); p != end(ia); ++p) { 
        // q points to the first element in an inner array
        for (auto q = begin(*p); q != end(*p); ++q)
        	cout << *q << ' '; // prints the int value to which q points
        cout << endl;
    }

### 类别别名简化多维数组的指针 ###

读、写和理解一个指向多维数组的指针是一个让人不胜其烦的工作，使用类型别名能让这项工作变得简单一点儿，例如：

using int_array = int[4]; // new style type alias declaration;
    typedef int int_array[4]; // equivalent typedef declaration;
    // print the value of each element in ia, with each inner array on its own line
    for (int_array *p = ia; p != ia + 3; ++p) { 
        for (int *q = *p; q != *p + 4; ++q)
        	cout << *q << ' ';
        cout << endl;
    }

程序将类型“4个整数组成的数组”命名为 int\_array，用类型名int\_array 定义外层循环的控制变量让程序显得简洁明了。

## 一些术语 ##

**缓冲区溢出**（buffer overflow）一种严重的程序故障，主要的原因是试图通过一个越界的索引访问容器内容，容器类型包括string、vector和数组等。

**类模板**（class template）用于创建具体类类型的模板。要想使用类模板,必须提供关于类型的辅助信息。例如，要定义一个vector对象需要指定元素的类型:vector<int>包含int类型的元素。

**拷贝初始化** （copy initialization） 使用赋值号（=）的初始化形式。新创建的对象是初始值的一个副本。

**直接初始化**（direct initialization）不使用赋值号(=)的初始化形式。

**实例化**（instantiation）编译器生成一个指定的模板类或函数的过程。

**值初始化**（value initialization）是一种初始化过程。内置类型初始化为0，类类型由类的默认构造函数初始化。只有当类包含默认构造函数时，该类的对象才会被值初始化。对于容器的初始化来说，如果只说明了容器的大小而没有指定初始值的话，就会执行值初始化。此时编译器会生成一个值，而容器的元素被初始化为该值。

[link]: https://baike.baidu.com/item/%E5%89%AF%E6%9C%AC/3646?fr=aladdin