数组

3.5 数组

1. 数组是一种类似于标准库类型vector的数据结构，但是在性能和灵活性的权衡上又与vector有所不同。
   
   • 两者相同点：都是存放类型相同的对象的容器。
   • 两者不同点：数组的大小确定不变，因此不能随意向数组中增添元素
2. 数组的大小固定，因此对某些特殊的应用来说程序在运行时的性能较好，但也相应的损失了一些灵活性。
3. 如果不清楚元素的个数，那么请用vector

---

3.5.1 定义和初始化内置数组

数组是一种复合类型

• 形式 a[d] : a是数组的名字，d是数组的维度(数组中元素的个数)。

int arr[5];     //int类型的数组，数组的名字是arr,维度是5

• 维度必须是常量表达式
  
  • 常量表达式(const expression)：值不会改变并且在编译过程中就能得到计算结果的表达式。
  • 原因：数组中的元素个数也属于数组类型一部分，因此在编译时维度应该是已知的。

unsigned cnt = 42;              //不是常量表达式
constexpr unsigned sz = 42;     //常量表达式
int arr[10];                    //含有是十个整数的数组
int *parr[sz];                  //含有42个整型指针的数组
string bad[cnt];                //**错误：cnt不是常量表达式**
auto arr[4] = {1,2,3};          //错误。不允许用auto关键字由初始值列表推断类型。

和内置类型的变量一样，如果定义在函数外部，则默认初始化。否则，默认初始化会令数组含有未定义的值。

---

显示初始化数组元素

• 如果对数组的元素进行列表初始化，此时可以忽略数组的维度。编译器会在编译阶段根据初始值的数量计算出维度。

int a2[] = {0,1,2};             //维度为3
string a3[3] = {"hi","bye"};    //等价于：string a3[3] ={"hi","bye",""}

---

字符数组的特殊性

char a1[] = {'C','+','+'};      //列表初始化，没有空字符
char a2[] = {'C','+','+','\0'}; //列表初始化，含有显示的空字符
char a3[] = "C++";              //自动添加表示字符串结束的空字符
const char a4[6] = "Daniel";    //错误，没有空间可存放空字符

• 当用字符串字面值初始化数组时，如a3 数组，字符串的结尾处还有一个空字符，这个空字符也会被拷贝到字符数组中去，占用一个位置。

---

不允许拷贝和赋值

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

---

理解复杂的数组声明

• 数组的指针
• 数组的引用
• 存放指针的数组
  观察下面代码：

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

从内向外，然后从右向左理解比较好理解：
- 当没括号时，如int *ptrs[10] 从右向左理解：首先定义了一个大小为10的数组，它的名字是ptrs，然后知道数组中存放的是指针，指向int类型。
- -
- 有括号时，从内向外，然后从右向左理解比较好理解：int (*Parray)[10] = &arr; 首先圆括号中的部分，*Parray这是一个指针。然后观察右侧，一个大小为10的数组，可知，Parray是一个指向大小为10的数组的指针，观察左侧，int类型，所以数组中的元素类型是int类型。

再举一个例子

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

首先括号中的，知道arry是一个引用，再看右侧[10],是一个大小为10的数组，因此，arry是大小为10的数组的引用。再看左侧 int * ，int的指针，因此，arry是一个大小为10的数组的引用，该数组中含有十个int类型指针。

---

3.5.2 访问数组元素

• 可以使用范围for语句或下标运算符访问
• 数组的索引从0开始
• 使用数组下标时，定义为 size_t类型。（string::size_type vector<int>::size_type）
• size_t是一种机器相关的无符号类型，它被设计的足够大以便能表示内存中任意对象的大小。（size_type与机器无关，其他特性都与size_t 相似）

---

3.5.3 指针和数组

在C++语言中，指针和数组有着非常紧密的联系，使用数组的时候编译器一般会把它转换成指针。
- 使用取地址符&获取某个对象的指针，取地址符可以用于任何对象。

string nums[] = {"one","two"};
string *p = &num[0];                //p指向nums的第一个元素
string *p2 = nums;                  //等价于p2 = &nums[0]

在大多数情况下，使用数组类型的对象其实是用一个指向该数组首元素的指针。

• 在一些情况下数组的操作实际上就是指针的操作
  
  • 当使用数组作为一个auto变量的初始值时，推断得到的类型是指针而非数组。

int ia[] = {0,1,2,3,4,5,6,7,8,9};//含有10个整数的数组
auto ia2(ia);                   //ia2是一个整型指针，指向ia的第一个元素
auto ia2(&ia[0]);           //上述语句在编译器中执行的初始化过程类似这个语句
//显然ia2是int*类型
ia2 = 42;                       //错误：ia2是指针

decltype(ia) ia3 = {0,1,2,3,4,5,6,7,8,9};
//ia3是一个含有10个整数的数组。

---

指针也是迭代器

• vector和string的迭代器支持的运算，数组的指针也全部支持。

int arr[] = {0,1,2,3,4,5,6,7,8,9};
int *e = &arr[10];      //获取尾后指针，作用跟尾后迭代器的作用一样
for(int *b = arr; b != e; ++b)
    cout << *b << endl;

使用尾后指针的做法很容易出错，因此，C++11引入了 begin 和 end 的函数

标准库函数begin 和 end

为了让让指针的使用更简单，更安全，C++11引入了这两个函数。
- 定义在头文件#include<iterator>
- 这两个函数跟容器的两个同名成员功能类似，不过数组不是类类型，因此这两个函数不是成员函数( 不能用 a.begin()形式)。

int ai[] = {0,1,2,3,4,5,6,7,8,9};
int *beg = begin(ia);       //指向ia首元素的指针
int *last = end(ia);        //指向ia尾元素的下一个位置的指针

int arr[] = {1,2,3,4,5,6,7};
int *pbeg = begin(arr),*pend = end(arr);
while(pbeg != pend)
{
    cout << *pbeg << endl;
    ++pbeg;
}

尾后指针不能执行解引用和递增操作，如同尾后迭代器。

---

指针运算

• 指针可以执行解引用，递增，比较，与整数相加，两个指针相减等，用在指针和用在迭代器上的意义完全一致。

constexpr size_t sz = 5;
int arr[sz] = {1,2,3,4,5};
int *ip = arr;              //等价于int *ip = &arr[0]
int *ip2 = ip + 4;          //ip2指向arr的尾元素arr[4]

auto n = end(arr) - begin(arr); //n的值时5,也就是arr中元素的数量

两个指针相减的结果的类型：ptrdiff_t 的标准库类型，和size_t一样，ptrdiff_t 也是一种定义在cstddef头文件中的机器相关的类型，因为差值可能为负值，所以是一种带符号类型的。（vector和string容器迭代器的差值类型时:difference_t,也是带符号类型的）

---

解引用和指针运算的交互

int ia[] = {0,2,4,6,8};
int last = *(ia + 4);   //  把last初始为8，也就是ia[4]的值

• 如果表达式含有解引用运算符和点运算符，做好在必要的地方加上括号。类似的，如下例：

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