C++基础之容器——array详解

最新推荐文章于 2026-05-06 08:17:01 发布
原创 最新推荐文章于 2026-05-06 08:17:01 发布 · 9k 阅读 · 30 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c++ #数据结构
本文详细介绍了C++中的std::array容器，包括其模板定义、成员类型和函数，如begin、end、rbegin、rend、size、front、back、data等。std::array是一个固定大小的序列容器，提供了类似于数组的功能，支持迭代器和常量迭代器，且元素存储在连续的内存空间中。此外，文章还提到了std::array与C++的数组和其它容器的区别，如其大小不可变，以及作为tuple的替代品的特性。

头文件
：头文件中定义了固定大小的数组容器array 类和两个函数begin和end。

模板类定义

原型定义

template < class T, size_t N > class array;

类介绍

数组array是一个大小固定的序列容器：容器中保存这特定数量的元素，元素按照严格的线性序列保存。
在容器内部，除了容器的元素不会保存任何其他的数据(甚至大小也不保存，大小是模板类的参数，在编译时确定)。就存储大小而言它与使用括号语法([])声明的数组一样高效。这个类只是在数组的基础上添加了成员函数和全局函数，这样数组就可以当作标准容器来使用。
与其他标准容器不同，array的大小是固定的，而且不会通过一个内存分配器来管理元素内存的分配：它是一个封装了固定数量元素的数组的聚合类型。因此，它不能动态的添加或删除元素（类似的大小可扩展的容器参见vector）。
大小为0的数组是有效的，但是不能对元素进行访问（ 成员函数front、back、data）。
与标准库中的其他容器不同，交换两个array的内容，不管是全部交换还是只交换一个范围内的元素(通常效率非常地的操作)，时间复杂度都是线性的。同时还使迭代器保留对原始数组的引用。
array的另一个独有的特征是，可以把array当作一个tuple对象来看待：<array>头文件中重载了get函数使array像tuple一样访问元素，还有指定的tuple_size和tuple的元素类型。

容器属性

顺序存储
容器中的元素以严格的线性序列存储。每个元素都可以通过它在序列中的位置来访问。
连续存储
容器的元素保存在一段连续的内存空间中，因此可以以常数时间复杂度来访问任意的元素(O(1))。可以通过使用指向一个元素的指针加上偏移来访问另一个元素。
大小固定
容器使用隐藏构造函数和析构函数来静态的申请和释放内存空间。容器的大小是编译时常量。没有内存或时间开销。

模板参数

T
元素的类型，别名为成员类型array::alue_type。
N
array的大小，元素的数量。

在成员函数中的参数假定与模板参数的名称相同。

成员类型

以下的别名是array的成员类型，他们广泛用于成员函数的参数和返回类型。
在这里插入图片描述

成员函数

std::array::begin

函数原型

     iterator begin() noexcept;
const_iterator begin() const noexcept;

功能
返回一个指向array容器第一个元素的迭代器。注意：与array::front函数(返回第一个元素的引用)不同，begin返回的是指向第一个元素的可以随机访问的迭代器。
在大小为0的数组中，返回值与array::end相同，但是返回的迭代器不应该解引用来访问元素。
参数
无
返回值
一个指向序列开始的迭代器。如果array是const的，则返回一个const_iterator，否则返回一个iterator。
成员类型iterator和const_iterator都是可以随机访问的(分别指向普通元素和静态的元素)。
Example

// array::begin example
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myarray = { 2, 16, 77, 34, 50 };

  std::cout << "myarray contains:";
  for ( auto it = myarray.begin(); it != myarray.end(); ++it )
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

Output:

myarray contains: 2 16 77 34 50

复杂度
常数
迭代器有效性
不会修改迭代器的有效性。
数据竞争
该函数不会访问array的元素，但是返回的迭代器可以访问和修改元素。同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。拷贝构造或在对返回的迭代器赋值都不会抛出异常。

std::array::end

函数原型

         iterator end() noexcept;
const_iterator end() const noexcept;

功能
返回一个指向array容器the past-the-end element的迭代器。
the past-the-end element是一个理论上的元素，在array最后一个元素的下一个位置。它不指向任何的元素，因此不能解引用来访问元素。
由于标准库函数访问元素范围不包括终止迭代器指向的元素，因此该函数通常用来与array::begin一起使用来指定容器的元素范围。
在大小为0的数组中，返回值与array::begin相同，但是返回的迭代器不应该解引用来访问元素。
参数
无
返回值
一个指向序列最后一个元素的下一个位置的迭代器。如果array是const的，则返回一个const_iterator，否则返回一个iterator。
成员类型iterator和const_iterator都是可以随机访问的(分别指向普通元素和静态的元素)。
Example

// array::end example
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myarray = { 5, 19, 77, 34, 99 };

  std::cout << "myarray contains:";
  for ( auto it = myarray.begin(); it != myarray.end(); ++it )
    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;
}

Output:

myarray contains: 5 19 77 34 99

复杂度
常数
迭代器有效性
不会修改迭代器的有效性。
数据竞争
该函数不会访问array的元素，但是返回的迭代器可以访问和修改元素。同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。拷贝构造或在对返回的迭代器赋值都不会抛出异常。

std::array::rbegin和std::array::rend

函数原型

 reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;

功能
rbegin： 返回一个反向的迭代器，指向容器最后一个元素。rbegin指向的元素正好是end函数指向元素的前一个。与另一个成员函数array::back不同，back返回的是指向最后一个元素的引用，而rbegin返回的是同一个元素的迭代器，并且迭代器可以任意访问成员。
rend： 返回一个指向容器第一个元素的前面一个元素的迭代器，该元素只是理论上的元素（该元素被定为为数组的反向结束位置）。rbegin和rend之间包含了容器的所有元素。
参数
无
返回值
rbegin： 一个反向迭代器，该迭代器指向反向第一个元素也就是容器最后一个元素。
rend： 一个指向反向结束位置的反向迭代器。

如果array是const的，则返回的迭代器是const_iterator。否则返回一个正常的迭代器。
成员类型reverse_iterator 和 const_reverse_iterator都是反向可以随机访问的迭代器(分别指向普通元素和const元素)。
Example

// array::rbegin/rend
#include <iostream>
#include <array>

int main ()
{
  std::array<int,4> myarray = {4, 26, 80, 14} ;

  std::cout << "myarray contains:";
  for ( auto rit=myarray.rbegin() ; rit < myarray.rend(); ++rit )
    std::cout << ' ' << *rit;

  std::cout << '\n';

  return 0;
}

Output:

myarray contains: 14 80 26 4

注意： 反向迭代器是反向增长的。

复杂度
常数
迭代器有效性
不会修改迭代器的有效性。
数据竞争
该函数不会访问array的元素，但是返回的迭代器可以访问和修改元素。同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。拷贝构造或在对返回的迭代器赋值都不会抛出异常。

std::array::cbegin和std::array::cend

函数原型

 const_iterator cbegin() const noexcept;
 const_iterator cend() const noexcept;

功能
cbegin： 返回指向容器第一个元素的const_iterator。const_iterator指向指向的内容是const的。迭代器可以向前和向后移动(除非它本身也是const的)。与array::begin返回的值是相同的，但是不能修改该函数返回的迭代器指向的内容，即使array本身并不是const的。
cend： 返回一个指向容器最后一个元素的下一个位置的const_iterator。与array::end返回的值是相同的，但是不能修改该函数返回的迭代器指向的内容，即使array本身并不是const的。
参数
无
返回值
cbegin： 返回指向容器第一个元素的const_iterator。
cend： 一个指向容器最后一个元素的下一个位置的const_iterator。

成员类型const_iterator是可以随机访问的迭代器类型，指向一个const元素。
Example

// array::cbegin example
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myarray = { 2, 16, 77, 34, 50 };

  std::cout << "myarray contains:";

  for ( auto it = myarray.cbegin(); it != myarray.cend(); ++it )
    std::cout << ' ' << *it;   // cannot modify *it

  std::cout << '\n';

  return 0;
}

Output:

myarray contains: 2 16 77 34 50

复杂度
常数
迭代器有效性
不会修改迭代器的有效性。
数据竞争
该函数不会访问array的元素，但是返回的迭代器可以访问和修改元素。同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。拷贝构造或在对返回的迭代器赋值都不会抛出异常。

std::array::crbegin和std::array::crend

函数原型

const_reverse_iterator crbegin() const noexcept;
const_reverse_iterator crend() const noexcept;

功能
功能就不再重复描述了，返回的是const 的反向迭代器。与rbegin与rend的区别就是返回的迭代器不能用来修改元素。
参数
无
返回值
反向的const 迭代器。
Example

// array::crbegin/crend
#include <iostream>
#include <array>

int main ()
{
  std::array<int,6> myarray = {10, 20, 30, 40, 50, 60} ;

  std::cout << "myarray backwards:";
  for ( auto rit=myarray.crbegin() ; rit < myarray.crend(); ++rit )
    std::cout << ' ' << *rit;   // cannot modify *rit

  std::cout << '\n';

  return 0;
}

Output:

myarray backwards: 60 50 40 30 20 10

复杂度
常数
迭代器有效性
不会修改迭代器的有效性。
数据竞争
该函数不会访问array的元素，但是返回的迭代器可以访问和修改元素。同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。拷贝构造或在对返回的迭代器赋值都不会抛出异常。

std::array::size

函数原型

constexpr size_type size() noexcept;

功能
返回容器中元素的数量。array的size总是与array类模板的参数N相等。与C++的sizeof不同，sizeof返回的是字节数，该函数返回元素数量。
参数
无
返回值
容器array中元素的数量，这是一个编译时常量。size_type是unsigned integer类型size_t的别名。
Example

// array::size
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myints;
  std::cout << "size of myints: " << myints.size() << std::endl;
  std::cout << "sizeof(myints): " << sizeof(myints) << std::endl;

  return 0;
}

Possible output:

size of myints: 5
sizeof(myints): 20

复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数不会访问array的元素：同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。

std::array::max_size

函数原型

constexpr size_type max_size() noexcept;

功能
返回容器可以保存元素的最大数量。max_size与size一样，永远与array类模板的第二个参数N相等。
参数
无
返回值
容器array可以保存元素的最大数量，这是一个常量。size_type是unsigned integer类型size_t的别名。
Example

// array::max_size
#include <iostream>
#include <array>

int main ()
{
  std::array<int,10> myints;
  std::cout << "size of myints: " << myints.size() << '\n';
  std::cout << "max_size of myints: " << myints.max_size() << '\n';

  return 0;
}

Possible output:

size of myints: 10
max_size of myints: 10

size和max_size总是匹配相等的。
复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数不会访问array的元素：同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。

std::array::empty

函数原型

constexpr bool empty() noexcept;

功能
返回一个布尔值，来表示容器是不是空的，也就是size是不是0。该函数不会修改容器的内容。清空容器可以使用array::fill方法。
参数
无
返回值
如果size为0则返回True，否则返回false。返回在是常数。
Example

// array::empty
#include <iostream>
#include <array>

int main ()
{
  std::array<int,0> first;
  std::array<int,5> second;
  std::cout << "first " << (first.empty() ? "is empty" : "is not empty") << '\n';
  std::cout << "second " << (second.empty() ? "is empty" : "is not empty") << '\n';
  return 0;
}

Output：

first is empty
second is not empty

复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数不会访问array的元素：同时访问或修改元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。

std::array::operator[]

函数原型

      reference operator[] (size_type n);
const_reference operator[] (size_type n) const;

功能
返回array容器在位置n处元素的引用。功能与array::at函数的功能类似，不同的是at函数会检查n是否在有效范围内，超出范围会抛出异常。
参数
n： array中元素的位置。第一个元素从0开始标记。
返回值
指定位置的元素。如果array是const的则返回一个const的引用，否则返回一个普通的引用。成员类型reference和const_reference是指向array元素的引用类型。
Example

// array::operator[]
#include <iostream>
#include <array>

int main ()
{
  std::array<int,10> myarray;
  unsigned int i;

  // assign some values:
  for (i=0; i<10; i++) myarray[i]=i;

  // print content
  std::cout << "myarray contains:";
  for (i=0; i<10; i++)
    std::cout << ' ' << myarray[i];
  std::cout << '\n';

  return 0;
}

Output：

myarray contains: 0 1 2 3 4 5 6 7 8 9

复杂度
常数
迭代器有效性
不会变化。
数据竞争
返回的引用可以访问或着修改元素值：同时修改不同的元素是安全的。
异常&安全
如果n小于size，该函数不会抛出异常；否则会导致不确定的行为。

std::array::at

函数原型

      reference at ( size_type n );
const_reference at ( size_type n ) const;

功能
返回array容器在位置n处元素的引用。该函数会检查n是否在有效范围内，如果超出范围则抛出out_of_range的异常。相反，operator[]操作符不会检查n的有效性。
参数
n： array中元素的位置。如果大于等于size的话会抛出out_of_range的异常。注意第一个元素从0开始。
返回值
array中指定位置的元素。如果array是const的则返回一个const的引用，否则返回一个普通的引用。成员类型reference和const_reference是指向array元素的引用类型。
Example

// array::at
#include <iostream>
#include <array>

int main ()
{
  std::array<int,10> myarray;

  // assign some values:
  for (int i=0; i<10; i++) myarray.at(i) = i+1;

  // print content:
  std::cout << "myarray contains:";
  for (int i=0; i<10; i++)
    std::cout << ' ' << myarray.at(i);
  std::cout << '\n';

  return 0;
}

Output：

myarray contains: 1 2 3 4 5 6 7 8 9 10

复杂度
常数
迭代器有效性
不会变化。
数据竞争
返回的引用可以访问或着修改元素值：同时修改不同的元素是安全的。
异常&安全
强保证： 如果出现异常，不会修改容器元素。如果n超出有效范围则抛出out_of_range的异常。

std::array::front

函数原型

      reference front();
const_reference front() const;

功能
返回容器第一个元素的引用。begin返回的是一个迭代器，而此函数返回一个直接引用。在空容器上调用该函数会导致不确定的行为。
参数
无
返回值
第一个元素的引用。如果array是const的则返回一个const的引用，否则返回一个普通的引用。成员类型reference和const_reference是指向array元素的引用类型。
Example

// array::front
#include <iostream>
#include <array>

int main ()
{
  std::array<int,3> myarray = {2, 16, 77};

  std::cout << "front is: " << myarray.front() << std::endl;   // 2
  std::cout << "back is: " << myarray.back() << std::endl;     // 77

  myarray.front() = 100;

  std::cout << "myarray now contains:";
  for ( int& x : myarray ) std::cout << ' ' << x;

  std::cout << '\n';

  return 0;
}

Output：

front is: 2
back is: 77
myarray now contains: 100 16 77

复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数的返回值可以访问或者修改元素值。同时修改其他元素是安全的。
异常&安全
如果容器不空，不会抛出异常。否则会导致不确定的行为。

std::array::back

函数原型

      reference back();
const_reference back() const;

功能
返回容器最后一个元素的引用。end返回的是一个指向最后一个元素下一个位置的迭代器，而此函数返回一个直接引用。在空容器上调用该函数会导致不确定的行为。
参数
无
返回值
最后一个元素的引用。如果array是const的则返回一个const的引用，否则返回一个普通的引用。成员类型reference和const_reference是指向array元素的引用类型。
Example

// array::back
#include <iostream>
#include <array>

int main ()
{
  std::array<int,3> myarray = {5, 19, 77};

  std::cout << "front is: " << myarray.front() << std::endl;   // 5
  std::cout << "back is: " << myarray.back() << std::endl;     // 77

  myarray.back() = 50;

  std::cout << "myarray now contains:";
  for ( int& x : myarray ) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

Output：

front is: 5
back is: 77
myarray now contains: 5 19 50

复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数的返回值可以访问或者修改元素值。同时修改其他元素是安全的。
异常&安全
如果容器不空，不会抛出异常。否则会导致不确定的行为。

std::array::data

函数原型

      value_type* data() noexcept;
const value_type* data() const noexcept;

功能
返回指向第一个元素的指针。由于array保存在一个连续的区域内，所以可以使用该指针加上偏移来访问任意的元素。
参数
无
返回值
array元素的指针。如果array是const的，则返回指向 const value_type的指针，否则返回一个普通指针。value_type是容器中元素的数据类型。
Example

// array::data
#include <iostream>
#include <cstring>
#include <array>

int main ()
{
  const char* cstr = "Test string";
  std::array<char,12> charray;

  std::memcpy (charray.data(),cstr,12);

  std::cout << charray.data() << '\n';

  return 0;
}

Output：

Test string

复杂度
常数
迭代器有效性
不会变化。
数据竞争
该函数不会直接访问array的元素，但是返回的指针可以用来访问和修改元素。同时访问或修改不同的元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。

std::array::fill

函数原型

void fill (const value_type& val);

功能
将array中所有元素的值都设置成val。
参数
val： 要填充的值
返回值
无
Example

// array::fill example
#include <iostream>
#include <array>

int main () {
  std::array<int,6> myarray;

  myarray.fill(5);

  std::cout << "myarray contains:";
  for ( int& x : myarray) { std::cout << ' ' << x; }

  std::cout << '\n';

  return 0;
}

Output：

myarray contains: 5 5 5 5 5 5

复杂度
线性的：与array的size相关
迭代器有效性
不会变化。
数据竞争
所有的数据都会变化
异常&安全
基本保证： 如果抛出异常，容器仍处于有效状态。如果赋值出现异常会抛出对应的异常信息。

std::array::swap

函数原型

void swap (array& x) noexcept(noexcept(swap(declval<value_type&>(),declval<value_type&>())));

功能
与另一个array的内容交换，两个array的数据类型和size必须相同。执行该函数后，该容器的内容与x的内容互换。与其他容器的swap不同，array的swap函数执行时间与size成线性关系。
参数
x： 与该容器类型和size相同的另一个容器。
返回值
无
如果其中一个元素交换出现异常，则会抛出一个异常信息。
Example

// swap arrays
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> first = {10, 20, 30, 40, 50};
  std::array<int,5> second = {11, 22, 33, 44, 55};

  first.swap (second);

  std::cout << "first:";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';

  std::cout << "second:";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

Output：

first: 11 22 33 44 55
second: 10 20 30 40 50

复杂度
与size成线性关系。
迭代器有效性
迭代器、指针和引用的有效性不会变化。迭代器和指针仍然指向对应容器的位置，值变为swap后的值，但引用的值不会变，指向原来的值。
数据竞争
该容器与x容器的值都被访问和修改了。
异常&安全
如果交换没有发生异常，该函数不会抛出异常。否则基本保证容器仍处于有效状态。

非成员函数重载

std::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个元素的引用。重载tuple的get函数是为了像处理tuple一样处理array。为此，头文件还使用定义的适当成员重载tuple_size和tuple_element type。
模板参数
I： array中元素的位置，第一个元素为0。
T： array中元素类型(通常可以从array隐式获得)。
N： array中元素的数量(通常可以从array隐式获得)。
函数参数
arr： 一个array容器。
返回值
array中指定位置元素的引用。
Example

// arrays as tuples
#include <iostream>
#include <array>
#include <tuple>

int main ()
{
  std::array<int,3> myarray = {10, 20, 30};
  std::tuple<int,int,int> mytuple (10, 20, 30);

  std::tuple_element<0,decltype(myarray)>::type myelement;  // int myelement

  myelement = std::get<2>(myarray);
  std::get<2>(myarray) = std::get<0>(myarray);
  std::get<0>(myarray) = myelement;

  std::cout << "first element in myarray: " << std::get<0>(myarray) << "\n";
  std::cout << "first element in mytuple: " << std::get<0>(mytuple) << "\n";

  return 0;
}

Output：

first element in myarray: 30
first element in mytuple: 10

复杂度
常数
迭代器有效性
不会变化。
数据竞争
array的第I个元素可能会被访问和修改。同步修改其他元素是安全的。
异常&安全
保证不抛出异常： 该函数永远不会抛出异常。

相关的操作符

前面已介绍

Android USB(type-c)耳机调试分析(十)
Android系统攻城狮
11-20 3816
简介：CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！】🚀】🚀人生格言：人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.​更多原创,欢迎关注：Android系统攻城狮​1.前言本篇目的：理解Android USB(type-c)耳机调试分析。
突破编程_C++_C++11新特性（array）
突破编程
03-20 2332
C++11 新特性：array
C++教程之array
QStack的博客
03-07 1009
上一篇文章我们介绍了C++中的迭代器，这篇文章将会介绍C++中数组的概念，数组是一种和vector类似的数据结构，但是其在性能和灵活性上的权衡中选择了性能而放弃了一定的灵活性，其与vector相同的地方是，它们都是同一类型的对象的容器，也都可以通过下标访问。其不同点是数组的大小是固定的，所以无法向一个数组添加元素，也正是因为其大小固定，所以其在运行时有更好的性能。需要注意的是一些编译器是不支持数组的拷贝，如果直接通过一个数组去初始化另一个数组可能会报错。在理解声明时可以按照从左到右，从内到外的顺序。
在Ubuntu 20.04上搞定D435i深度相机：从驱动安装到ROS Noetic完整避坑指南
最新发布
weixin_33728708的博客
05-06 187
本文详细介绍了在Ubuntu 20.04系统上配置Intel RealSense D435i深度相机的完整流程，包括驱动安装、ROS Noetic环境搭建及常见问题解决方案。通过step-by-step指南，帮助开发者快速实现相机与ROS的集成，优化性能并解决实际应用中的典型问题，适用于机器人导航、三维重建等领域。
【STL】C++ STL之array详解
行码棋
02-14 2万+
c++ STL之array详解
array详解
m0_59666413的博客
11-09 4914
array详细介绍
C++ array容器用法详解
Lemon_C17y的博客
02-19 2567
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 array 容器包含的 begin() 和 end() 成员函数不同的是，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
C++ array 容器详解
LXdian_LX的博客
07-28 615
是 C++ 中固定大小数组的现代替代方案，在保持 C 风格数组性能的同时，提供了类型安全、边界检查和 STL 兼容性等优势，应成为固定大小容器的首选。它结合了 C 风格数组的性能优势和 STL 容器的安全性与接口。是 C++11 引入的固定大小数组容器，位于。
C++中的array容器详解
C++发展史系列已完结，这段时间将会迎来系列作品——C++STL系列，敬请期待。作者邮箱：ljq20110324@outlook.com
01-10 575
C++中的array容器是C++11引入的固定大小数组容器，兼具原生数组的高效性和STL容器的安全性。它提供连续存储、随机访问、边界检查(at())和STL兼容接口。array在栈上分配内存，大小编译时确定，支持多种初始化方式。主要操作包括元素访问([], at(), front(), back())、容量查询(size(), empty())和修改(fill(), swap())。相比原生数组，array更安全(不会退化为指针)且功能更丰富(支持迭代器和STL算法)，适合已知大小的固定集合场景。
C++ STL array容器用法详解
东南坼的博客
07-14 577
array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全（原因后续会讲），且效率并没有因此变差。 和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。 STL 还提供有可动态扩展或收缩存储空间的 vector 容器，后续章节会对其做详细介绍。 array 容器以类模板的形式定义在
C++数据结构——array、vector、链表
知识搬运工的博客
03-25 6610
一、 array模板类 C++中的数组类型是继承了c语言的特性，在使用数组的时候要注意数组越界操作问题。为了更安全的对数组进行操作，C++提出了数组模板类array。array内存空间为连续的一段地址，适用于提前已知所要存储的数据类型和数量、进行大量的查、改操作，不适用于含有大量交换、删除、增加数据的操作，该容器无法动态改变大小，所以说提前已知存储数据类型和数量。 1、array模板...
C++ array函数
weixin_59141600的博客
09-16 1万+
c++ STL
C++数组Array
Simona_Wu的博客
07-12 2308
数组（Array）是C++中一种用于存储相同类型数据的集合。数组在内存中是连续存储的，因此可以通过索引访问数组中的每个元素。数组的大小在声明时确定，并且不能在运行时改变。
C++数组【修订】
热门推荐
cnds123的专栏
10-06 2万+
C++数组 C++支持数组数据结构，它可以存储一个固定大小的相同类型的元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。数组的声明并不是声明一个个单独的变量，如a0,a1,a2,a3,a4…,a99,而是声明一个数组变量，比如as,然后使用as[0],as[1],as[2],…,as[99]来代表一个个单独的变量，数组的特定元素可以通过索引来访问。所数组都是由连续的内存位置组成，最低的地址对应第一个元素，最高的地址对应最后一个元素。 C++中的一维数组 声明数..
C++中的数组(array)
m0_56312629的博客
08-01 1833
3.1 数组(array)
【C++ STL序列容器】array 数组
普罗米修斯的博客
04-22 3227
各个元素的值是不确定的（array 容器不会做默认初始化操作）普通数组的基础上添加了一些成员函数和全局函数。，且效率并没有因此变差。
C++ array
ljy121121的博客
12-30 1611
array是新C++标准增加的类型。与内置数组相比，array是一种更安全、更容易使用的数组类型。 既然C++ Primer这么说了，那就学一下吧。 array<int,42>p构造，规定数组元素类型和大小。 array<int,42>p={1,2,3}初始化列表，前三个位置为相应数字，之后的是默认值。 这里因为有默认值，所以如果构造类型是自定义的类，这个类就必须有默认构造才能这样初始化。 相比普通的内置数组，这种数组支持拷贝操作 array<int,10>q=p 或.
详解c++---array和模板
qq_68695298的博客
05-13 2314
array的介绍和模板的一些特性
【C++容器】array使用全览
obroccolio的博客
08-28 1226
本文介绍了C++11标准库中的std::array容器，它封装了固定大小的C风格数组，提供了更安全便捷的访问方式。主要特性包括：1）聚合初始化方式；2）支持迭代器遍历；3）固定大小，不可动态调整；4）提供多种元素访问方法（operator[]、at()等）；5）有限修改器（fill、swap）；6）支持非成员函数操作（比较、std::get等）。与vector不同，array的大小在编译时确定，性能接近原生数组，同时具备STL容器的安全性和便利性。文章通过代码示例详细演示了各种操作的使用方法。
C++：数组array
heima201907的博客
05-13 4773
之前学习了向量vector，其效率稍低，在C++中新增了模板类数组array，效率和数组相同。 数组array长度是固定的，使用栈存储，和数组效率相同，但更方便、安全。 创建方法： array<typeName, n_elem> ad; 和vector略有不同，array一定要在<>第二个参量位置定义长度n_elem。 例如： array<int,4> arr = {1,2,3,4}; 可以看到array是可以通过列表初始化的。书中提到在C++11中，vector也已经支
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值