C++ 数组知识点摘录

一维数组

声明一维数组的一般形式为：
<元素类型> <数组名>[<元素个数>];
<元素类型>指明了数组元素的类型，可以是整型、实型、布尔型和字符型等简单数据类型，也可以是用户定义的复合数据类型，包括数组类型；
<数组名>由标识符充当，是整个数组的名字；<数组名>后面的方括号是必须的，C 和 C++ 把[ ]作为运算符处理，其优先级与括号相同，左结合；
方括号中的<元素个数>是整常量表达式，可以省略，表示数组元素的个数，注意数组元素的下标是从零开始计数的。

例如：

int a[10];

上述声明了一个数组名为 a 的整型数组，它有10个整型元素，下标的变化范围是0~9。

数组元素的访问

给定一个数组，我们可以采用以下形式访问数组里的元素：

<数组名>[<下标表达式>]

<下标表达式>是值为整型的表达式，它指明了拟访问的数组元素的下标。
例如，数组 a 的10个元素可以依次表示为：a[0] ，a[1] ，a[2] ，…… ，a[9]。
注意：如果访问数组元素时使用的下标超出了元素的数目，会导致访问越界错误。C 和 C++ 不检查访问越界，如果发生了访问越界，有可能导致程序在运行时发生错误。
数组的各元素按顺序存储在一片连续的内存单元中。数组int a[10]的内存分配见下图所示：

数组的初始化

数组初始化的方法是把初始值按顺序放在花括号中，数值之间用逗号分开。
例如：

int  a[10]={4};
float  r[20]={0.1, 5.1};
double  d[3]={10.0,5.0,1.0};

需要注意以下两点：
1.如果初始值的数目小于数组元素的数目，数组剩余的元素被自动初始化为 0。
例如：

int  n[5]={0};  //将数组 n 的所有数组元素都初始化为 0

注意：初始值的数目不能超过数组中元素的数目。
2.声明数组时可以省略数组元素的数目，这时系统会根据初始值的数目来确定数组元素的数目。
例如：

int  x[]={ 1, 2, 3, 4, 5 };

实际上声明了一个包含了5个整型元素的数组 x ：x[0] …… x[4] ，其值分别被初始化为 1 ，…… ，5。
这里再强调一下：我们不能直接操作某个数组，只能对数组中的某一个元素进行操作。也就是说，数组需要“拆开来用”，每次只能操作一个数组元素，操作数组元素的方法和操作普通变量的方法相同，“拆开数组”的方法就是数组名加下标访问数组元素的方式。
例如：

a[7]= 4;     // 给数组元素 a[7] 赋值
x = 2 * a[i+2];     // 数组元素作表达式的运算量

数组的遍历

对于数组而言，最常见的用法是使用循环语句来操作数组，对数组元素进行遍历和处理。
例如下面的程序对数组 n 中的元素求和：

int n[10] = {12,34,55,71,1,65,423,19,540,10};     // 声明数组n并初始化
int i, sum = 0;     // 定义循环变量和累加和变量
// 循环遍历数组并求和
for (i = 0; i <= 10-1; i++)
{
    sum += n[i];
}
cout << "The summary is: " << sum << endl;     // 输出求和结果

数组作为函数的参数

由于数组的存储是内存中一块连续的单元，数组元素的个数也是不确定的（不同的数组可能包含不同个数的数组元素），因此函数传递数组需要传递两个信息，一个是数组的地址（数组名就是数组地址），告诉被调用函数该数组存放在内存什么地方，另一个是数组元素个数，告诉被调用函数访问该数组时允许的下标范围（防止访问越界）。
参数传入一个整型数组的函数的函数原型如下：

void  convertScores(int a[],  int len);

第一个参数 a 是一个数组类型的形式参数。该参数 a 接收传入数组的数组名，也就是数组的首地址，其后的方括号中的数组长度不需要，即使有，编译器也会将其忽略；
第二个参数 len 是整型参数。该参数 len 传入数组 a 的长度，即 a 有 len 个数组元素，访问 a 的元素的下标范围就是 0 到 len-1。
例如：下面的程序将一个整型数组中存放的10名同学的百分制成绩转换为5分制，并输出。

#include <iostream>
using namespace std;
// 分数转换函数的函数原型，其中：s-学生成绩数组名，len-学生成绩个数
void convertScores(int s[], int len);
int main()
{
    // 定义学生成绩数组并初始化
    int scores[10] = {85, 63, 72, 52, 95, 82, 77, 69, 88, 73};
    convertScores(scores, 10);     // 调用分数转换函数convertScores
    // 转换完成后输出分数数组中的分数
    for(int i = 0; i < 10; i++)
        cout << "scores["<<i<<"] = " << scores[i] << endl;
    return 0;
}
// 函数convertScores
void convertScores(int s[], int len)
{
    // 逐个访问数组中的每个元素，并做转换
    for (int i = 0; i < len; i++)
        s[i] = s[i]/20;     // 修改 s[i] 实际上就是修改 main 函数中的 scores[i]，因为 s 和 scores 拥有相同的地址值
}

程序的输出为：

scores[0] = 4
scores[1] = 3
scores[2] = 3
scores[3] = 2
scores[4] = 4
scores[5] = 4
scores[6] = 3
scores[7] = 3
scores[8] = 4
scores[9] = 3

上述示例中函数调用convertScores(scores, 10);导致数组 scores 中的每个元素都被转换了。也就是说，在被调用函数体内对数组 s（形式参数）的元素进行的修改操作实际上作用在了数组 scores（实在参数）的元素上，这是否就是传引用呢？
实际上，C 和 C++ 在处理数组参数时是严格地采取了传值方式。
参数传递数组的方式有比较特殊的地方，要理解传递数组的机制，首先要明确下面两点：
和一般变量一样，数组名也是有值的，数组名的值就是数组的第一个元素的地址（首地址）；
和一般变量一样，数组作为函数参数进行传递时，传递的也是数组变量的值，即数组第一个元素的地址。
由于数组名的值就是数组的第一个元素的地址，而访问数组元素的方式是数组名加下标（也就是首地址加下标），才使得尽管采取的是传值方式，但在被调用函数 convertScores 中，通过 s 加下标的方式访问数组元素，实际*问的就是 main 函数中定义的数组 scores 的数组元素，因为 s 和 scores 代表了同样的地址位置。