C++ 数组

目录

一维数组

一维数组的创建

一维数组的初始化

一维数组的使用

一维数组在内存中的存储

二维数组

二维数组的创建

二维数组的初始化

二维数组的使用

二维数组在内存中的存储

数组越界

一维数组

数组是一组形同类型的集合。

一维数组的创建

数组的创建方式：

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

这里我们 [ const_n] const_n不一定要是常量表达式，也可以是变量，但是得看我们的C标准。

数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。

数组创建的实例：

//代码1
int arr1[10];

//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？
//这种写法我们一般认为是错误的，但是在其他的语言或者C标准是支持这样写的。

//代码3
char arr3[10];
float arr4[1];
double arr5[20];

一维数组的初始化

数组的初始化是指在创建数组的同时给数组内容一些合理的初始值（初始化）。
初始化方式：

type_t   arr_name   [const_n]={num1,num2,……，mum(const_n)};
我们初始化的时候初始值使用一对{}括起来的，而我们的元素个数就是const_n个。

注释：
我们的字符串数组创建的时候也可以不用{}括起来，是可以用 "  "包含的：
char arr[3]="abc";

我们看一下以下创建数组的方式：

int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";//对字符串特殊的定义数组方式。

在上面我们看到有些数组并没有给定数组的大小的，而是直接初始化值的。
这里说明一下： 数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定的。也就是说，你不给定数组的大小，但是你给定了数组初始值，这个时候我们的编译器会自动计算数组的大小的。

如果我们定义一个数组：int arr[10]={1，2，3};这个叫做数组的不完全初始化，顾名思义就是我们初始化的个数不等于我们的给定数组的大小。不完全初始化的时候如果我们后期不给数组赋值的话编译器默认是初始化为0的。

这里我们们针对字符串数组来系统的讲解一下：
上面我们讲了字符串数组可以：char arr6[] = “abcdef”;这样字定义。
我们从表面上看过去这个数组的大小是6，但是其实他的大小是7，因为在我们的字符串后面隐藏了一个字符 \0 但是这个字符是不被计算道数组大小里面的所以数组的大小是6.

这里我们可以看到有个\0，而这个\0是作为字符串的结束标志的。

一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。
在使用之前我们先了解一下我们数组的下标，在我们的编程中我们的数组下标默认是从0开始的。
我们来看代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };//数组的不完全初始化
    //计算数组的元素个数
    int sz = sizeof(arr) / sizeof(arr[0]);
    //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
    int i = 0;//做下标
    for (i = 0; i < 10; i++)
    {
        arr[i] = i;
    }
    //输出数组的内容
    for (i = 0; i < 10; ++i)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

这里我们就需要了解一下怎么计算素组的大小，前面我们也提到过了计算素组大小的关键字sizeof（），sizeof（arr）计算的整个素组元素的字节大小，而我们的sizeof(arr[0]）是计算一个元素的字节大小，这样总的字节大小/每个元素的字节大小，就得到了元素个数。

一维数组在内存中的存储

既然我们知道了数组是用来存放形同类型的数据的，但是这些数组在内存中是怎么存储的呢？
是在内存中随机存储的还是有序的存储的呢？现在我们就来探讨一下：

我们探讨的最好方法就是是打印出每个元素的地址，来找一下他们的规律。

#include <stdio.h>
int main()
{
 	 int arr[10] = {0};
	 int i = 0;
	 int sz = sizeof(arr)/sizeof(arr[0]);
 for(i=0; i<sz; ++i)
 {
 	 printf("&arr[%d] = %p\n", i, &arr[i]);
 }
	 return 0;
}

这里我们补充一个知识点：%p是用来打印地址的

这个是他们的打印结果。
我们试着画出他们的内存分布：

注释：这里与由于地址过长，我们统一先取出后4为作为对比。
我们假设0xF748是我们的开始地址，依次往后对我们的地址增加0xF748后一位地址就是0xF749这个时候我们对比一下第一个元素和第二个元素以及我们的第二个元素和第三个元素，发现他们的差值都是4个字节，而我们定义的数组的类型是int的，而int类型所占内存的大小也是4个字节。
我们还可以对比一下其他的元素：

我们发现上一个元素于下一个元素的地址差值都是4，这样我们就知道了数组在内存中是连续存储的，而且每个元素所占大小于我们定义数组的类型有关。

注：还有一点就是我们地址是以16进制的形式存储的，所以这里我们的转换成10进制来计算。

二维数组

所谓二维数组有点类似于我们线性代数，有行和列之分。
而我们的二维数组其实和一维数组差不多，甚至是可以吧二维数组看成是一个一维数组的一维数组。

就比如：

1 2 3 4 
2 3 4 5
6 7 8 9

这个就是一个三行四列的数组。

二维数组的创建

二维数组的创建方式：

type_t   arr_name   [row][col];
//row：表示有多少行
//col：表示有多少列

比如：

int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组的初始化

这里的初始化和一位数组有点相似的，而我们刚才也说过了我们可以通过降维吧二维数组看成是一个一维的一维数组。也就是说我们可以把一行看成是一维数组的第一个元素，以此类推。

这样子我们初始化的时候就得这样子了：

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

当然如果我们不给{}也是行的：

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

这个时候我们的编译器会自动匹配的。

如果我们不完全初始化呢？也是和一维数组一样编译器会默认初始化为0的。

我们在定义一维数组的时候我们可以省略数组的大小，那是不是说明我们的二维数组也行呢？
答案是肯定的，但是我们只能省略行不能省略列

如果我们省略了列的话，我们知道了行但是不知道一行有多少个元素，这个时候编译器不知道一行的元素够了没，也就不知道要不要默认初始化0，这个时候就出问题了。

二维数组的使用

二维数组的使用也是通过下标的方式。

#include <stdio.h>
int main()
{
 	int arr[3][4] = {0};
 	int i = 0;
 for(i=0; i<3; i++)
 {
 		int j = 0;
		for(j=0; j<4; j++)
 		{
 			arr[i][j] = i+j;
  		}
 }
 for(i=0; i<3; i++)
 {
 		int j = 0;
 		for(j=0; j<4; j++)
 		{
 			printf("%d ", arr[i][j]);
 		}
 }
 return 0;
}

二维数组在内存中的存储

像一维数组一样，这里我们尝试打印二维数组的每个元素的地址

#include <stdio.h>
int main()
{
 	int arr[3][4];
 	int i = 0;
 for(i=0; i<3; i++)
 {
 		int j = 0;
 		for(j=0; j<4; j++)
 		{
 			printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
 		}
 }
 return 0;
}

同样的我们会发现：

发现它的上一个元素和下一个元素的地址的差值还是4，也就是说它的内存分布其实和一维数组是一样的，同样的数组元素是连续存储的，而且元素所占大小取决于定义数组的类型。

数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i=0; i<=10; i++)
   {
        printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
   }
 return 0;
}

这类我们的数组大小是10，也就是说我们的数组下标是从0-9的，但是我们的for循环中却遍历数组的下标是从00-10 的明显业界访问了。