7. 数组

7.1 数组的概念

1）数组：可以用来表达类型相同的元素的集合，集合的名字就是数组名.
2）数组里的元素都有编号，元素的编号叫下标，通过数组名和下标就能访问元素.
3）一维数组的定义方法如下：

类型名 数组名[元素个数];

4）其中元素个数必须是常量或者常量表达式，不能是变量，而且其值必须是正整数，元素个数也称为数组的长度.

int a[100]; //名字为a的数组，有100个元素，每个元素都是一个int型变量

T a[N]; 	 //T为类型名（char、int、double...），a为数组名，N为正整数表示元素的个数

（1）数组a有N个元素，每个元素都是一个类型为T的变量.
（2）N个元素在内存里是一个挨一个连续存放的.
（3）a数组一共占用N * sizeof(T)字节的存储空间.
（4）表达式sizeof（a）的值就是整个数组的体积N * sizeof(T).

int a[100];

5）数组下标从0开始，N个元素的数组，下标从0到N-1.
6）数组名a代表的就是数组的地址，假设为p，那么变量a[i]的地址就是p + i*sizeof（int）.

例题：输入10个整数，按照输入的相反顺序输出.

#include <iostream>
using namespace std;
#define NUM 10  //使用符号常量便于修改
int main(){
    int a[NUM];
    for (int i = 0; i < 10; i++){
        cin >> a[i];
    }
    for (int j = NUM - 1; j >= 0; j--){
        cout<< a[j] <<" ";
    }

    return 0;
}

输入：1 2 3 4 5 6 7 8 9 0
输出：0 9 8 7 6 5 4 3 2 1

例题：筛选法求偶数，输出0-100间的所有偶数

#include <iostream>
using namespace std;
#define MAX_NUM 100  //使用符号常量便于修改
bool isPrime[MAX_NUM + 10];
int main(){

    for (int i = 0; i < MAX_NUM; i++){
        isPrime[i] = true;
    }
    for (int i = 2; i <= MAX_NUM; i++){
        if (i % 2 == 0){
            cout<< i <<" ";
        }
    }

    return 0;
}

输出：2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100

7.2 数组的初始化

**1）在定义一个数组时就可以给数组中的元素赋值：

类型名 数组名[常量表达式] = {值，值，值...};

2）{}中的各数据值即为各元素的初值，中间用逗号隔开.
3）数组初始化时，{}中的值个数可以少于元素个数，其余元素全被初始化为0.

int a[10] = {0,1,2,3}; //只给a[0]~a[3]赋值，其余元素为0

例题：输入1-7，输出Monday-Sunday，其他输入输出illegal

#include <iostream>
#include <string>
using namespace std;
string weekdays[] = {   //string是字符串类型，可存放字符串常量
"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
int main(){
    int n;
    cin >> n;
    if (n < 1 || n > 7){
        cout << "illegal."<<endl;
    }
    else
        cout << weekdays[n-1]<<endl;
    return 0;
}

输入：7
输出：Sunday

7.3 数组越界

1）数组元素的下表可以是任何整数，可以是负数，也可以是大于数组的元素个数，而不会导致编译错误.

int a[10];
a[-2] = 5;
a[200] = 10;
a[10] = 5;

但运行时很可能出错！！！
int a[10];

a[-2] = 5;a[10] = 5;都可能导致程序运行时出错！！！
因为写入了别的变量的内存空间，或者写入了指令的内存空间.

2）常见的数组越界情况如下：
（1）用变量作为数组下标时，不小心可能会导致数组越界
（2）可能视图访问不该访问的区域，导致程序崩溃
（3）可能引起意外修改其他变量的值，导致程序运行结果不正确
（4）数组越界的程序在某些编译器可以正确运行，换一个可能就不行

7.4 二维数组

7.4.1 二维数组的基本概念

1）定义二维数组基本形式：T a[N][M];
2）T为类型名，M、N为正整数或值为正整数的常量表达式.
3）每个元素都是类型为T的变量
4）N * M个元素在内存中是连续存放的.
5）数组占用了一片连续的、大小为NMsizeof(T)字节的存储空间.
6）表达式sizeof(a)的值就是整个数组的体积，即NMsizeof(T).
7）访问数组的方法：数组名[行下标][列下标]，行下标和列下表都从0开始.
8）数组T[N][M]每一行都有M个元素，且每一行的元素都是连续存放的.
9）a[0][0]是数组中最小的元素，如果a[0][0]的存放地址为n，则a[i][j]的存放地址为：n + i * M * sizeof(T) + j * sizeof(T)
10）二维数组的每一行都可以看做一个一维数组

7.4.2 二维数组的存放方式和初始化

1）二维数组的存放方式：

int a[2][3]；

2）二维数组的初始化：

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

3）二维数组初始化时，如果对每行都初始化，那么可以不给出行数.
4）a是一个2行3列的数组，a[1][2]被初始化为0.

int a[][3] = {{2,3,4}, {3,4}};

例题：遍历二维数组.

#define ROW 20
#define COL 30
int a[ROW][COL];
for (int i = 0; i < ROW; i++){
	for (int j = 0; j < COL; j++){
		cout<<a[i][j]<<" ";
	}
	cout<<endl;
}

例题：矩阵乘法

#include <iostream>
using namespace std;
#define ROW 8
#define COL 8
int a[ROW][COL];
int b[ROW][COL];
int c[ROW][COL];
int main(){

    int m,n,p,q;
    //输入a矩阵
    cin >> m >> n;
    for (int i = 0; i < m; i++){
        for (int j = 0; j < n; j++){
            cin >> a[i][j];
        }
    }
    //输入b矩阵
    cin >> p >> q;
    for (int i = 0; i < p; i++){
        for (int j = 0; j < q; j++){
            cin >> b[i][j];
        }
    }

    if (m > 8 || n > 8 || p > 8 || q > 8 || n != p){
        cout << "illegal input!"<<endl;
    }
    //输出a矩阵
    for (int i = 0; i < m; i++){
        for (int j = 0; j < n; j++){
            cout << a[i][j] <<" ";
        }
        cout<<endl;
    }
    //输出b矩阵
    for (int i = 0; i < p; i++){
        for (int j = 0; j < q; j++){
            cout << b[i][j]<<" ";
        }
        cout<<endl;
    }
    //输出c矩阵
    for (int i = 0; i < m; i++){
        for (int j = 0; j < q; j++){
            for (int k = 0; k < n; k++){
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    for (int i = 0; i < m; i++){
        for (int j = 0; j < q; j++){
            cout << c[i][j]<<" ";
        }
        cout <<endl;
    }

    return 0;
}

输入：2 3 1 2 3 4 5 6 3 2 1 2 3 4 5 6
输出：
1 2 3
4 5 6
1 2
3 4
5 6
22 28
49 64