【C++】4-1.25 C++11的数组类std::array

小灰灰 2023-01-20 08:06 72阅读 0赞

### 【C++】4-1.25 C++11的数组类std::array ###

*  C风格数组
 *  C++风格数组std::array
 *  创建C++风格数组
 *  数组类std::array的成员函数
 *  使用示例

# C风格数组 #

C风格的数组又叫C++原生数组

#include <iostream>
    int main()
    { 
    	int arr[6]{  1,2,3,4,5,6 };
    	return 0;
    }

注意：  
C风格的数组可能存在的问题：  
1，可能会退化为指针，如下示例：

#include <iostream>
    
    void fun1(int a[])
    { 
    	std::cout << "[2.1]" << sizeof(a) / sizeof(a[0]) << std::endl;
    	
    	// 在函数里面用a时，a不在是数组，而退化为指针
    	std::cout << "[2.2]" << sizeof(a) << std::endl; //退化为指针了
    	std::cout << "[2.3]" << sizeof(a[0]) << std::endl << std::endl;;
    }
    
    
    int main()
    { 
    	int arr[6]{  1,2,3,4,5,6 };
    	std::cout << "[1.1]"<< sizeof(arr) / sizeof(arr[0]) << std::endl;
    	std::cout << "[1.2]" << sizeof(arr)    << std::endl;
    	std::cout << "[1.3]" << sizeof(arr[0]) << std::endl;
    	std::cout << std::endl;	
    	
    	// 将数组作为函数参数，传递给fun1
    	fun1(arr);
    
    	std::cout << "[3.1]" << sizeof(&arr) << std::endl;
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70]  
2，C风格的数组，不知道自己的大小，需要通过 sizeof(arr)/sizeof(arr\[0\]) 来间接获取；  
3，两个数组之间无法直接赋值:  
array1 = array2; //数组名称即就是数组的首地址，是指针常量；

4，不能自动推导类型：auto array1\[\] = \{1,2,3\};// 语法不允许，编译会报错

# C++风格数组std::array #

C++风格数组是一个容器类，它有迭代器（可以认为是一种用于访问成员的高级指针）  
C++风格数组，可直接赋值；  
C++风格数组，知道自己大小：size()  
C++风格数组，能和另一个数组交换内容：swap()  
C++风格数组，能以指定值填充自己: fill()  
C++风格数组，取某个位置的元素( 做越界检查) ：at()

注意：  
C++ 风格的数组与C风格的数组限制是一样的，比如：  
数组内只能存储同样类型的数据；  
数组大小一旦确定，就不可更改了，不可扩大、缩小；

在使用C++ 风格的数组与C风格的数组在运行时，  
性能基本是一致的（性能并没有增加开销，但是增加更多友好的操作特性），  
建议多使用C++ 风格的数组！

# 创建C++风格数组 #

C++数组类是一个模板类，可以容纳任何类型的数据；

**语法：**  
std::array < 数组 类型, 数组大小> 数组名字;  
std::array < 数组 类型, 数组大小> 数组名字 \{ 值1, 值2, …\}; //列表初始化

对于c++17，引入了对类模板的参数进行推导，可以采用下面的方式：  
// 定义数组对象，  
std::array a1 \{1, 2, 3，4\}; // c++17可以推导出 std::array<int, 4>

// 定义数组对象，并使用列表初始化数组；  
std::array a2 \{‘a’, ‘b’, ‘c’, ‘d’\}; // c++17可以推导出 std::array<char, 4>

示例：

#include <iostream>
    #include <array>
    int main()
    { 
    	std::array arr1{  1,2,3 };  //c++17 才支持类型自动推导
    	std::cout << arr1.size() << std::endl;
    	std::cout << "[3.1]" << sizeof(&arr1) << std::endl;
    
    	// 创建C++风格数组
    	std::array<int, 5> arr2;
    	std::array<char, 5> arr3{  'H','e','l','l','o' };
    
    	return 0;
    }

# 数组类std::array的成员函数 #

容量

<table> 
 <thead> 
  <tr> 
   <th>empty</th> 
   <th>检查容器是否为空</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>size</td> 
   <td>返回容纳的元素数</td> 
  </tr> 
  <tr> 
   <td>max_size</td> 
   <td>返回可容纳的最大元素数</td> 
  </tr> 
 </tbody> 
</table>

操作

<table> 
 <thead> 
  <tr> 
   <th>fill</th> 
   <th>以指定值填充容器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>swap</td> 
   <td>交换内容</td> 
  </tr> 
 </tbody> 
</table>

元素访问

<table> 
 <thead> 
  <tr> 
   <th>at</th> 
   <th>访问指定的元素，同时进行越界检查</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[]</td> 
   <td>访问指定的元素</td> 
  </tr> 
  <tr> 
   <td>front</td> 
   <td>访问第一个元素</td> 
  </tr> 
  <tr> 
   <td>back</td> 
   <td>访问最后一个元素</td> 
  </tr> 
  <tr> 
   <td>data</td> 
   <td>返回指向内存中数组第一个元素的指针</td> 
  </tr> 
 </tbody> 
</table>

迭代器

<table> 
 <thead> 
  <tr> 
   <th>beginc/begin</th> 
   <th>返回指向容器第一个元素的迭代器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>endc/end</td> 
   <td>返回指向容器尾端的迭代器</td> 
  </tr> 
  <tr> 
   <td>rbeginc/rbegin</td> 
   <td>返回指向容器最后元素的逆向迭代器</td> 
  </tr> 
  <tr> 
   <td>rendc/rend</td> 
   <td>返回指向前端的逆向迭代器</td> 
  </tr> 
 </tbody> 
</table>

# 使用示例 #

下面的代码在windows操作系统下运行  
IDE:vs2017 社区版，  
c++语言标准：ISO C++14

示例

#include <iostream>
    
    #include <array>
    
    // 自定义一个print函数用于打印数组
    // 函数参数是数组对象的引用
    void userPrint(std::array<int,3> &arr)
    { 
    	for (auto x : arr)
    	{ 
    		std::cout << x << "*";
    	}
    	std::cout << std::endl;
    }
    
    //search函数，在数组中查找一个值
    //&arr 被搜寻对象， goal为搜寻内容；
    int search(std::array<int, 3> &arr, int goal)
    { 
    	bool isExist{  false };
    	int i = 0;
    	for (auto x : arr)
    	{ 
    		if (x == goal)
    		{ 
    			isExist = true;
    			break;
    		}
    		i++;
    	}
    
    	if (isExist) return i;
    	else return -1;
    }
    
    int main()
    { 
    	// 1. 创建 数组
    	std::array<int, 3> arr1{ 5,3,7};
    	userPrint(arr1);
    
    	// 2. 为数组赋值
    	arr1 = {  1,2,3};	
    	userPrint(arr1);
    
    	// 3. 交换数组
    	std::array<int, 3> arr2{  17,8,29};
    	arr1.swap(arr2);
    	userPrint(arr1);
    	userPrint(arr2);
    
    	// 4. 求数组大小
    	// 由于数组定义后大小不可变，所以size/max_size值一样！
    	std::cout << arr1.size() << std::endl;
    	std::cout << arr1.max_size() << std::endl;
    
    	// 5. 编写search函数，在数组中查找一个值
    	std::cout << search(arr1,29) << std::endl;
    	std::cout << search(arr1, 10) << std::endl;
    	
    	// 6. sort 排序
    	// 默认是从大到小排序
    	std::sort(arr1.rbegin(), arr1.rend());
    	userPrint(arr1);
    
    	// 7.二维数组
    	std::array<std::array<int, 3>, 4> arr3;
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70]: /images/20221021/ffbe59d7545c4687bd2df514a35236a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 1]: /images/20221021/d957f0352f244fd58de6d69666192bc8.png