NO.21十六届蓝桥杯备战|一维数组|范围for|memset|memcpy(C++)

数组是⼀组雷同范例元素的聚集

• 数组中存放的是1个大概多个数据，但是数组元素个数不能为0
  
• 数组中存放的多个数据，范例是雷同的
  数组分为⼀维数组和多维数组，多维数组⼀般⽐较多⻅的是⼆维数组
  

一维数组

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

数组创建

1. type arr_name[常量值];

复制代码

存放在数组的值被称为数组的元素，数组在创建的时间须要指定命组的⼤⼩和数组的元素范例
• type 指定的是数组中存放数据的范例，可以是：char、short、int、float 等，也可以⾃
界说的范例
• arr_name 是数组的名字，这个名字可以⾃界说，根据实际情况，起的故意义就⾏。
• []中的常量值是⽤来指定命组的⼤⼩的，数组的⼤⼩是根据实际的需求指定就⾏。在算法比赛中为了为了包管不越界访问，通常会多开发⼀些空间。
• 可以使⽤ const int N = 100 的⽅式界说常量，来指定命组的⼤⼩。
数组的初始化

偶然间，数组在创建的时间，我们须要给定⼀些初始值，这种就称为初始化

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

复制代码

数组元素访问

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

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(第⼀个元素) ，盘算的是数组的元素个数
  

数组元素的打印

1. #include <iostream>  
2. using namespace std;  
4. int main()  
5. {  
6.         int arr[10] = {1,2,3,4,5,6,7,8,9,10};  
7.         int i = 0;  
8.         for(i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)  
9.         {  
10.                 cout << arr[i] << " ";  
11.         }  
12.         return 0;  
13. }

复制代码

范围for

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

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

复制代码

1. #include <iostream>  
2. using namespace std;  
4. int main()  
5. {  
6.         int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  
7.         for (int e : arr)  
8.         {  
9.                 cout << e << " ";  
10.         }  
11.         return 0;  
12. }

复制代码

上⾯代码中的 for 就是 范围for ，代码的意思是将 arr 数组中的元素，依次放在 e 变量中，然后
打印 e ，直到遍历完备个数组的元素。这⾥的 e 是⼀个单独的变量，不是数组的元素，以是对 e 的修改，不会影响数组。
但是对于范围 for 要慎重使⽤！范围 for 是对数组中全部元素进⾏遍历的，但是实际在做题的过程中，大概只须要遍历数组中指定个数的元素，如许范围 for 就不符合了。
auto关键字

auto 的紧张⽤途是让编译器⾃动推导出变量的范例的

1. #include <iostream>  
2. using namespace std;  
4. int main()  
5. {
6.         auto a = 3.14;  
7.         auto b = 100;  
8.         auto c = 'x';  
9.        
10.         return 0;  
11. }

复制代码

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

复制代码

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

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

复制代码

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

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
5. int main ()  
6. {  
7.         char str[] = "hello world";  
8.         memset(str, 'x', 6);  
9.         cout << str << endl;  
10.         int arr[] = {1,2,3,4,5};  
11.         memset(arr, 0, sizeof(arr));//这⾥数组的⼤⼩也可以⾃⼰计算  
12.         for(auto i : arr)  
13.         {  
14.                 cout << i << " ";
15.         }  
16.         cout << endl;  
17.         return 0;  
18. }

复制代码

错误使⽤

1. #include <iostream>  
2. using namespace std;
4. int main ()  
5. {  
6.         int arr[] = {1,2,3,4,5};  
7.         memset(arr, 1, 4 * sizeof(int));  
8.         for(auto e : arr)  
9.         {  
10.                 cout << e << " ";  
11.         }  
12.         cout << endl;  
13.         return 0;  
14. }

复制代码

当value设置为1大概其他⾮0的数字时，打印结果不符合预期
紧张缘故原由是 memset 函数是给每个字节设置 value 值，⽽⼀个整型元素占⽤4个字节，⼀个整型的每个字节都被设置为1，⼆进制就是： 00000001000000010000000100000001 ，转换成⼗进制就是： 16843009 ，因此结果是不符合预期的。
memcpy拷⻉数组内容

在使⽤数组的时间，偶然间我们须要将数组a的内容给数组b

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

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

复制代码

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

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
5. int main()  
6. {  
7.         int a[10] = {1,2,3,4,5,6,7,8,9,10};  
8.         int b[10] = {0};  
9.         memcpy(b, a, 10 * sizeof(int));  
10.         for(int e: b)  
11.         {  
12.                 cout << e << " ";  
13.         }  
14.        
15.         return 0;  
16. }

复制代码

固然如果拷⻉ double 范例的数组时，盘算时应该使⽤ sizeof(double) ，要机动厘革