数组是⼀组相同类型元素的集合

• 数组中存放的是1个或者多个数据，但是数组元素个数不能为0
• 数组中存放的多个数据，类型是相同的
  数组分为⼀维数组和多维数组，多维数组⼀般⽐较多⻅的是⼆维数组

一维数组

⼀维数组是最常⻅的，通常⽤来存放⼀组数据，⼀维数组是⼀块连续的空间

数组创建

type arr_name[常量值];

存放在数组的值被称为数组的元素，数组在创建的时候需要指定数组的⼤⼩和数组的元素类型
• type 指定的是数组中存放数据的类型，可以是：char、short、int、float 等，也可以⾃
定义的类型
• arr_name 是数组的名字，这个名字可以⾃定义，根据实际情况，起的有意义就⾏。
• []中的常量值是⽤来指定数组的⼤⼩的，数组的⼤⼩是根据实际的需求指定就⾏。在算法竞赛中为了为了保证不越界访问，往往会多开辟⼀些空间。
• 可以使⽤ const int N = 100 的⽅式定义常量，来指定数组的⼤⼩。

数组的初始化

有时候，数组在创建的时候，我们需要给定⼀些初始值，这种就称为初始化

//完全初始化，数据会依次放⼊数组  
int arr[5] = {1,2,3,4,5};  
//不完全初始化  
int arr2[6] = {1};//第⼀个元素初始化为1，剩余的元素默认初始化为0  
//错误的初始化 - 初始化项太多  
int arr3[3] = {1, 2, 3, 4};

数组元素访问

数组是有下标的，下标是从0开始的，假设数组有n个元素，最后⼀个元素的下标是n-1 ，下标就相当于数组元素的编号

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

数组的访问提供了⼀个操作符 [] ，这个操作符叫：下标引⽤操作符
有了下标访问操作符，我们就可以轻松的访问到数组的元素了，⽐如我们访问下标为7的元素，我们就可以使⽤ arr[7] ，想要访问下标是3的元素，就可以使⽤ arr[3]

数组元素的打印

想要访问整个数组的内容，只要我们产⽣数组所有元素的下标就可以了，那我们使⽤ for 循环产⽣所有的下标，接下来使⽤下标访问就⾏了

如果产⽣的下标超出了有效下标的范围，⽐如，使⽤负数作为下标，或者超出了下标
的最⼤值，再使⽤这个下标访问元素就会造成：越界访问。越界访问访问的时候，代码编译
时语法没报错，但是运⾏时⼀定会出问题的

数组和sizeof

• sizeof(数组名) ，计算的是数组的总⼤⼩，单位是字节
• sizeof(数组名)/sizeof(第⼀个元素) ，计算的是数组的元素个数

数组元素的打印

#include <iostream>  
using namespace std;  

int main()  
{  
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};  
	int i = 0;  
	for(i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)  
	{  
		cout << arr[i] << " ";  
	}  
	return 0;  
}

范围for

打印数组元素除了可以使⽤之前讲过的三种循环外，还有⼀个更⽅便的⽅式，使⽤范围 for 。范围for是在 C++11 这个标准中引⼊的，如果你使⽤的编译器默认不⽀持 C++11 ，可能需要配置才能使⽤

范围for语法

for ( 类型 变量名 : 数组名 )  
	语句 //多条语句需要加⼤括号

#include <iostream>  
using namespace std;  

int main()  
{  
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  
	for (int e : arr)  
	{  
		cout << e << " ";  
	}  
	return 0;  
}

上⾯代码中的 for 就是 范围for ，代码的意思是将 arr 数组中的元素，依次放在 e 变量中，然后
打印 e ，直到遍历完整个数组的元素。这⾥的 e 是⼀个单独的变量，不是数组的元素，所以对 e 的修改，不会影响数组。
但是对于范围 for 要慎重使⽤！范围 for 是对数组中所有元素进⾏遍历的，但是实际在做题的过程中，可能只需要遍历数组中指定个数的元素，这样范围 for 就不合适了。

auto关键字

auto 的主要⽤途是让编译器⾃动推导出变量的类型的

#include <iostream>  
using namespace std;  

int main()  
{
	auto a = 3.14;  
	auto b = 100;  
	auto c = 'x';  
	
	return 0;  
}

#include <iostream>  
using namespace std;  

int main()  
{  
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  
	
	for (auto e : arr)
	//auto能够⾃动推导数组中每个元素的数据类型，在数组范围内遍历打印元素
	{  
		cout << e << " ";  
	}  
	return 0;  
}

范围 for 中 e 前⾯的类型可以可以是 auto 关键字，当不知道数组中放什么类型的时候，可以使⽤ auto 作为类型， auto 在范围 for 中很常⽤。如果明确的知道数组元素的数据类型，也可以将auto 换成对应的数据类型

memset设置数组内容

void * memset ( void * ptr, int value, size_t num );

• ptr – 指针：指向了要设置的内存块的起始位置
• value – 要设置的值
• num – 设置的字节个数
  memset 是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容，需要头⽂件<cstring>

#include <iostream>  
#include <cstring>  
using namespace std;  

int main ()  
{  
	char str[] = "hello world";  
	memset(str, 'x', 6);  
	cout << str << endl;  
	int arr[] = {1,2,3,4,5};  
	memset(arr, 0, sizeof(arr));//这⾥数组的⼤⼩也可以⾃⼰计算  
	for(auto i : arr)  
	{  
		cout << i << " ";
	}  
	cout << endl;  
	return 0;  
}

错误使⽤

#include <iostream>  
using namespace std; 

int main ()  
{  
	int arr[] = {1,2,3,4,5};  
	memset(arr, 1, 4 * sizeof(int));  
	for(auto e : arr)  
	{  
		cout << e << " ";  
	}  
	cout << endl;  
	return 0;  
}

当value设置为1或者其他⾮0的数字时，打印结果不符合预期
主要原因是 memset 函数是给每个字节设置 value 值，⽽⼀个整型元素占⽤4个字节，⼀个整型的每个字节都被设置为1，⼆进制就是： 00000001000000010000000100000001 ，转换成⼗进制就是： 16843009 ，因此结果是不符合预期的。

memcpy拷⻉数组内容

在使⽤数组的时候，有时候我们需要将数组a的内容给数组b

C++中有⼀个库函数 memcpy 可以做数组内容的拷⻉，当然 memcpy 其实是⽤来做内存块的拷⻉的，当然⽤来做数组内容的拷⻉也是没问题的

void * memcpy ( void * destination, const void * source, size_t num );

• destination – ⽬标空间的起始地址
• source – 源数据空间的起始地址
• num – 拷⻉的数据的字节个数

#include <iostream>  
#include <cstring>  
using namespace std;  

int main()  
{  
	int a[10] = {1,2,3,4,5,6,7,8,9,10};  
	int b[10] = {0};  
	memcpy(b, a, 10 * sizeof(int));  
	for(int e: b)  
	{  
		cout << e << " ";  
	}  
	
	return 0;  
}

当然如果拷⻉ double 类型的数组时，计算时应该使⽤ sizeof(double) ，要灵活变化