C++ array函数

已于 2022-09-16 22:14:08 修改
阅读量1w 收藏 89
点赞数 18
分类专栏： STL 文章标签： c++ c语言 算法
于 2022-09-16 21:54:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59141600/article/details/126898379
版权

C++ array

1、前要：

数组是固定大小的序列容器：它们包含按严格的线性顺序排列的特定数量的元素。一个array—也就是容器类array<>的一份实体—模塑出一个static array。它包覆一个寻常的statci C-style array 并提供一个STL容器的接口。

通用格式：arrat<类型名，元素个数>数组名；

注意，因为长度固定，这里的元素个数不能是变量。

array成员函数
函数功能
begin(),end(),cbegin(),cend()提供正向迭代器支持
rbegin(),rend(),crbegin(),crend()提供反向迭代器支持
size()返回数组大小
max_size()返回数组最大大小
empty()判断数组是否为空
at(),operator[]获取数组的元素
front()返回数组第一个元素的引用
back()返回数组最后一个元素的引用
data()返回指向数组对象包含的数据的指针
fill()用值填充数组
swap()交换两个数组元素
get(array)返回某一个数组元素的引用

2、成员函数与用法示例

array用法及初始化
template<class T,size_t N> class array;
//T为所包含元素的类型，别名为成员类型value_type.N的数组大小，以元素数表示。

在使用array前，首先需要添加array这个头文件，即 #include****

注意：array<>是唯一一个无任何东西被指定为初值时，会被预初始化的容器。这就意味着对于基础类型，初值可能不明确，而不是0，下面定义一个有110个int元素的数组arr：

std::array<int,110> arr;
//上面定义的arr并未进行初始化。未初始化将会分配随机值，如下图：

请添加图片描述

所以尽量不要定义未初始化的数组，否则访问数组元素，而该元素恰好未初始化时，可能出现意想不到的错误。

//array数组对象初始化与标准初始化一摸一样，如：
std::array<int,110>arr{};//将数组所有元素初始化为0
std::array<int, 110>arr{1,2,3,4};//将数组前四个元素分别初始化为1，2，3，4 其余全部为0
fill()

​ fill()函数可以用指定值给数组中所有元素赋值

fill()函数原型如下：

void fill(const value_type &u);//value_type为数组元素类型

【例子】：

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

int main(){
    std::array<int, 110> arr{1,2,3,4,5,6,7,8,9};
    arr.fill(3);//用3对数组所有元素赋值
    for (auto i:arr) {
        cout<<i<<" ";
    }
    cout<<endl;
    return 0;
}
array元素的获取

  • array元素的获取可以使用下标 [] (与标准数组用法相同)，以及STL容器所持有的at()。

  • []与at()的区别在于，[]不会进行检查数字是否越界，at()会进行检查(时间开销很少)，如果越界则抛出std::out_of_rang异常。

  • 因此，除非确定访问没有越界，否则应该尽量使用更安全的at()。

  • #include <iostream>
#include <array>
using namespace std;

int main(){
    std::array<int, 110> arr{1,2,3,4,5,6,7,8,9};
    arr.at(9) = arr.at(3) + arr.at(5);
    arr[10] = arr[1] + arr[8];
    cout<<arr.at(9)<<endl;
    cout<<arr[10]<<endl;
//    arr[11]=6;//越界访问，程序异常，但Qt creator并未报错
    arr.at(11) = 6;//异常
    cout<<arr.at(11)<<endl;
    return 0;
}
front()和back()

​ front() 返回数组第一个元素的引用

​ back()返回数组最后一个元素的引用

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

int main(){
    std::array<int, 11> arr{1,2,3,4,5,6,7,8,9};
    arr.front() = 666;
    arr.back() = 666;
    for(auto i:arr){
        cout<<i<<" ";
    }
    cout<<endl;
    return 0;
}

程序运行结果：

666 2 3 4 5 6 7 8 9 0 666

data()

​ 返回指向数组对象中第一个元素的指针，该元素无参数

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

int main(){
    std::array<int, 10> arr{1,2,3,4,5,6,7,8,9};
    
    cout << *arr.data()<<endl;
    cout << *(arr.data()+6)<<endl;
    
    const char *str = "Test string";
    std::array<char, 12> charray;
    std::memcpy(charray.data(), str, charray.size());
    
    cout << charray.data() << endl;
    return 0;
}

程序运行结果为:

1

7

Test string

size() 和 max_size()

​ 由于array在创建的时候必须明确指定大小，而且array为固定容器，因此size()与max_size()的返回值是相同的，通常使用size()函数。

返回值类型size_t即无符号整数。

使用size()可以有效避免使用for遍历数组时，发生越界的情况。同时它也使得你在写程序的时候，不必去花心思记忆数组大小。

std::array<int , 1o> arr{1,2,3,4,5,6,7,8,9,10};

for(unsigned int i(0);i < arr.size();i++){
		cout<<arr[i]<<" ";
cout << endl;
}
empty()

该函数在array中为鸡肋函数，因为array在定义的时候已经指明了大小，不可能为空。

Tuple接口

array提供tuple接口。因此可以使用表达式tuple_size<>::value取得元素个数，用tuple_element<>::type取得特定元素的类型，用get<>()取得某特定元素。

get()

get()函数为非成员函数重载。

该函数返回array中指定元素的引用。

函数原型如下：

template <size_t I,class T , size_t N>T & get(array<T, N>& arr)noexcept;
template <size_t I,class T , size_t N>T && get(array<T, N>&& arr)noexcept;
template <size_t I,class T , size_t N>const T & get(const array<T, N>& arr)noexcept;
//参数I为：元素在数组中的位置，第一个元素的位置为0.
//参数T为：数组中包含的元素模型（通常从arr隐式获取）。
//参数N为：数组的大小，以元素数为单位（通常从arr隐式中获得）。
//由于参数T、N可以从arr中隐式中获取，所以使用的时候不显示指定二者。
/*
		注意参数I必须明确为数字，不能使用变量，下面为错误用例
*/
int n = 3;
std::get<n>(arr);

例如

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

int main(){
    std::array<int, 10 > arr{1,2,3,4,5,6,7,8,9,10};
    int a = std::get<6>(arr);
    cout<<a<<endl;
    
    std::get<5>(arr) = 666;
    for (auto i : arr) {
        cout<<i<<" ";
    }
    cout<<endl;
    return 0;
}

程序运行结果如下：

7

1 2 3 4 5 666 7 8 9 10

tuple_size ::value 、、tuple<i,tupleType>::type

在array中用途不大，示例如下：

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

int main(){
    std::array<string, 5> arr = {"one","two","three","four","five"};
    //返回元素的个数，或者说是元组的长度
    cout<<std::tuple_size<decltype(arr)>::value<<endl;
    
    
    //type为array第二个成员变量类型，string型
    std::tuple_element<1,decltype(arr)>::type type;
    type = get<1>(arr);
    cout<<type<<endl;
    
    return 0;
    
}

/*
	补充decltype相关的知识：
	(1)decltype含义和举例：用于推导类型
*	1 decltype对于给定的变量名或者表达式，decltype能够告诉你该名字或者表达式的类型
*		从表达式的类型推断出要定义的变量类型，并且不想初始化变量--使用decltype
*		decltype说明符：主要作用：返回操作数的数据类型
*
*		decltype的特点：
*			1.decltype的自动类型推断会发生在编译期间
*			2.decltype不会真正计算表达式的值
*	1.1decltype后的圆括号是个变量
*	1.2decltype后的圆括号是个不是个变量，表达式。返回表达式结果对应类型
*	1.3decltype后的圆括号是个函数--返回值是函数返回值类型
*
/
array元素的修改

array元素的修改与标准数组用法几乎相同，如：

std::array<int , 10> arr{1,2,3,4,5,6,7,8,9,10};
arr[3] = 6;
arr[2] = arr[0] + arr[1];

同样可以使用指针，引用对其进行修改。

不同于标准数组的是，只要array类型的数组的数据类型和数组长度都相同的话，可以直接用数组B的值覆盖数组A的值，“=”。

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

int main(){
    std::array<int , 3> arr_1{1,2,3};
    std::array<int, 3> arr_2{4,5,6};
    
    arr_2 = arr_1;//用arr_1的元素覆盖arr_2的元素
    
    for (auto i : arr_1) {
        cout<<i<<" ";
    }
    cout<<endl;
    
    for (auto i : arr_1) {
        cout<<i<<" ";
    }
    cout<<endl;
    
    return 0;
    
}

程序运行结果为：

1 2 3

1 2 3

swap()

交换两个array的值，注意：这两个数组的大小和数据类型必须相同。

无返回值，无参数。线性操作（效率较低）

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

int main(){
    std::array<int , 10> arr_1{1,2,3,4,5,6,7,8,9,10};
    std::array<int, 10> arr_2{0,0,0,0,0,0,0,0,0,1};
    
    arr_1.swap(arr_2);
    for (auto i : arr_1) {
            cout<<i<<" ";
        }
        cout<<endl;
        
        for (auto i : arr_2) {
            cout<<i<<" ";
        }
        cout<<endl;
        
        return 0;
}

程序运行结果如下：

0 0 0 0 0 0 0 0 0 1

1 2 3 4 5 6 7 8 9 10

array迭代器
名称功能
begin()返回指向数组第一个元素的迭代器
end()返回指向数组最后一个元素后紧跟的理论元素迭代器
cbegin()返回指向数组第一个元素的const类型迭代器
cend()返回指向数组最后一个元素后紧跟的理论元素的const类型迭代器
rbegin()返回一个反向的迭代器，该迭代器指向数组的最后一个元素
rend()返回一个反向迭代器，该迭代器指向数组第一个元素之前的理论元素
crbegin()返回一个const类型反向迭代器，该迭代器指向数组最后一个一个元素
crend()返回一个const类型反向迭代器，该迭代器指向数组第一个元素之前的理论元素
下面为数组迭代器的简单用法:
#include <iostream>
#include <array>
using namespace std;

int main(){
    std::array<int, 10> arr{1,2,3,4,5,6,7,8,9,10};
    
    array<int, 10>::iterator it_beg = arr.begin();
    array<int, 10>::reverse_iterator rit_beg = arr.rbegin();
    
    for (; it_beg!=arr.end(); it_beg++) {
        cout<<*it_beg*2<<" "; //二倍输出
    }
    cout<<endl;
    
    for (; rit_beg!=arr.rend(); rit_beg++) {
        cout<<*rit_beg<<" ";//倒序输出数组元素
    }
    cout<<endl;
    
    return 0;
}

在使用时最好使用全局的begin()和end()函数从容器中获取迭代器，因为它们是通用的。

如上述array<int, 10>::iterator it_beg = arr.begin();可以改为一下语句

array<int, 10>::iterator it_beg = std::arr.begin();

array元素的比较

可以用任何比较运算符比较两个数组容器，只要它们有相同的大小，保存的是相同的元素，而且这种类型的元素还要支持比较运算符。示例如下：

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

int main(){
    std::array<int, 3 >arr_1{1,2,3};
    std::array<int, 3>arr_2{1,2,3};
    std::array<int, 3> arr_3{1,3,2};
    
    if (arr_1 == arr_2) {
        cout<<"arr_1 = arr_2"<<endl;
    }
    
    if (arr_1!=arr_3) {
        cout<<"arr_1!=arr_3"<<endl;
    }
    
    if (arr_1 < arr_3) {
        cout << "arr_1 < arr_3" << endl;
    }
    
    return 0;
}

代码运行结果如下：

arr_1 = arr_2

arr_1!=arr_3

arr_1 < arr_3

friendly e
关注
专栏目录
【STL】C++ STL之array详解
行码棋
02-14 1万+
c++ STL之array详解
【C++】C++11的std::array的详细剖析
Yngz_Miao的博客
10-31 4万+
当学习C++的时候，数组是最基本的结构之一，通常通过以下的方式来定义： int a[5]; int *b = new int[5]; 上面一句是在栈上定义了一个长度为5的数组，下面一句是在堆上定义了一个长度为5的数组，并用一个指针指向它。 在C++11中，引入了一种新的数组定义方式std::array。 std::array的特性 std::array是具有固定大小的数组。因此，它并不支持添加...
C++数据结构之：数组Array
最新发布
weixin_45068267的博客
05-17 897
it人员无论是使用哪种高级语言开发东东，想要更高效有层次的开发程序的话都躲不开三件套：数据结构，算法和设计模式。数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。
C++中的几种数组：array，vector，valarray
知不道道不知知不知道道道知的博客
07-08 1042
1. 内置数组（C语言风格数组）   数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。c++内置的原生数组可以存储一个固定大小的相同类型元素的顺序集合，并且其中的特定元素可以通过索引访问。它由连续的内存位置组成，最低的地址对应第一个元素，最高的地址对应最后一个元素。声明格式如下： type arrayName [ arraySize ]; 定义和初始化 ： // 默认初始化 int arr[5]; // 创建包含5个int型整数的数组，未被初始化 int arr[5] = {}; //创建
C语言数组（Array）
qq_52363432的博客
08-08 1万+
数组是一组相同类型元素的集合。 数组的创建 type_t arr_name [const_n]; //type_t 是指数组的元素类型 //const_n 是一个常量表达式，用来指定数组的大小 例如 int arr[10]; char arr[20]; 特别注意:[ ]中必须是常量表达式！ 数组的初始化 int arr1[20] = {1,2,3};//不完全初始化，剩余的默认初始化为0 int arr2[] = { 1,2,3};//数组元素个数视大括号内而定 char...
c++ array模板类使用
我的博客
08-10 6万+
目录 1、array模板类的定义 （1）array模板类的声明 （2）容器属性 （3）array模板类的说明 （4）array模板类头文件 2、array模板类的使用 （1）Iterators （2）Capacity （3）Element access （4）Modifiers （5）Compare （6）Other 本章是对c++ array模板类的知识归纳，讲述了c+...
探讨:C++中函数返回引用的注意事项
09-05
在C++编程语言中，函数返回值有两种主要方式：返回值和返回引用。返回值会创建一个临时副本，而返回引用则不会。本文主要讨论了在C++中使用函数返回引用时需要注意的一些关键点。 首先，函数可以返回引用作为其...
c++ 实现matlab smooth 函数
05-02
在C++中实现MATLAB的`smooth`函数是一项挑战，因为MATLAB的`smooth`函数提供了多种平滑方法，如移动平均、高斯滤波、Savitzky-Golay滤波等。本文将深入探讨如何用C++来实现这些平滑技术，以达到与MATLAB类似的效果。...
c++部分头文件的成员函数
02-18
在VS2022上整理，有关array,set,stack,queue,vector,map,set,priority_queue的成员函数及说明
C++中memset函数用法详解
09-02
`memset`函数是C++（实际上也源自C语言）中用于初始化内存的工具，它的功能是将一块内存区域的所有字节设置为特定的值。在深入讲解`memset`之前，我们先来了解一下函数的基本语法： ```cpp void* memset(void* s, ...
c++从函数返回数组的方法代码
08-25
在C++编程语言中，直接从函数返回一个完整的数组是不允许的。这是由于数组名实际上是一个指向其首元素的指针，因此当你试图返回一个数组时，实际上返回的是一个指向数组首元素的指针。然而，为了实现从函数中传递和...
C++11 array使用详解
SENLINZM的专栏
08-19 1万+
C++11中的array使用详解
C++ Array 数组
weixin_44387066的博客
04-28 4806
C++ Array 数组，是一个包含了一些列变量的变量，可以视为一个集合。 例如： int main() { int example[5]; example[0] = 2; } 定义一个包含五个整型变量的数组 example， 即在内存空间中开辟 20 bytes （int 为 4 bytes）的空间给这个数组。数组内变量编号从0开始。[index] 可用于访问其中的变量。 #includ...
C++STL容器篇array的手动实现
生活需要深度
07-07 751
前段时间写了一个通过C++ array类简单了解C++容器初始化机制_Harris_ayaka的博客-CSDN博客，现在我整理一下C++ array中具体细节。详情参考array 类（C++ 标准库） | Microsoft Docsarray类 首先是语法：template class array; 接收两个模板参数，并且将数组的尺寸作为模板参数之一，因此两个不同大小但元素类型相同的的array将被视为不同的类型，例如：array a1; ...
array数组容器 C++
那年聪聪
03-27 4318
array数组容器
C语言中数组的总结
热门推荐
Calm的博客
05-26 22万+
目录 一维数组的创建和初始化 一维数组的使用 一维数组在内存中的存储 指针的初步介绍 一维数组的指针访问 二维数组的创建和初始化 二维数组的使用 二维数组在内存中的存储 二维数组的指针访问 有关数组的运算 数组作为函数参数 1.一维数组的创建和初始化 数组的创建：在创建数组时，我们必须定义数组的类型和大小，数组的大小不能为0，数组中的元素类型都是相同的。 eg: int arr[
C语言数组 函数
qq_42200456的博客
07-23 4298
一维数组： #include &lt;stdio.h&gt; int b[5]; //未初始化的全局变量是0 int main() { int i; //int array[5]; //未初始化的局部变量是垃圾值 //int array[5] = {1, 2, 3, 4, 5}; //int array[5] = {1, 2}; //对部分元素初始化，其他未初始化元素...
【C++】array和vector，数组三者区别和联系
qiyujie123的博客
10-10 254
共同点 （1.）都和数组相似，都可以使用标准数组的表示方法来访问每个元素（array和vector都对下标运算符[ ]进行了重载） （2.）三者的存储都是连续的，可以进行随机访问 不同点 （0.）数组是不安全的，array和vector是比较安全的（有效的避免越界等问题） （1.）array对象和数组存储在相同的内存区域（栈）中，vector对象存储在自由存储区（堆） （2.）array可以将一个对象赋值给另一个array对象，但是数组不行 （3.）vector属于变长的容器，即可..
C++11：尽量使用std::array来代替数组
脱离了低级趣味的流氓
05-23 5万+
C++11后，标准库引入了更现代化的数组std::array，cppreference.com是这样介绍的： 定义于头文件 &amp;lt;array&amp;gt; template&amp;lt; class T, std::size_t N &amp;gt; struct array; (C++11 起) std::array 是封装固定大小数组的容器。 此容器是一个聚合类型，其语义等同于保有...
array is array
09-27
array is array指的是如何判断一个对象是否为数组。在JavaScript中，可以使用Array.isArray()方法来判断一个对象是否为数组。该方法会返回一个布尔值，如果对象是数组则返回true，否则返回false。例如，Array.isArray([1, 2, 3])会返回true，而Array.isArray("Array")会返回false。 需要注意的是，Array.isArray()方法是在ES5.1中推出的，不支持IE6~8。如果需要在不支持该方法的浏览器上进行兼容处理，可以使用以下代码： if(typeof Array.isArray != "function") { Array.isArray = function(obj){ return Object.prototype.toString.call(obj) == "[object Array]"; } } 这段代码会检查Array.isArray()方法是否存在，如果不存在，则定义一个新的Array.isArray()方法。该方法通过调用Object.prototype.toString()方法来判断对象的类型是否为数组。 总结一下，array is array指的是判断一个对象是否为数组的方法。使用Array.isArray()可以方便地判断一个对象是否为数组。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值