STL教程(六): 序列容器--array

  一、array简介

template < class T, size_t N > class array;

参数介绍：

    T：包含的元素的类型，即array::value_type。

     N：array容器包含元素的数量

array是固定大小的序列容器，元素存储在连续的内存位置，指向元素的指针可以进行偏移以访问其他元素，且随机访问的时间是恒定的。

容器使用隐式构造函数和析构函数来静态分配所需的空间。它的大小N是编译时常量，并且不通过分配器管理其元素的分配：它们是封装固定大小元素数组的聚合类型。因此，它们不能动态扩展或收缩。

零大小的数组是有效的，但它们不应该被引用以访问它的内容。
与标准库中的其他容器不同，交换两个数组容器是一种线性操作，涉及单独交换范围内的所有元素，这通常是一种效率相当低的操作

二、array的成员函数

1、迭代器

iterator begin();  // 返回容器的迭代器到第一个元素
const_iterator cbegin(); // 返回容器的迭代器到第一个元素
iterator end();    // 返回容器的迭代器到最后一个元素 
const_iterator cend();   // 返回容器的迭代器到最后一个元素
reverse_iterator rbegin(); // 返回容器的反向迭代器到第一个元素
const_reverse_iterator crbegin();// 返回容器的反向迭代器到第一个元素
reverse_iterator rend();   // 返回容器的反向迭代器到最后一个元素
const_reverse_iterator crend();  // 返回容器的反向迭代器到最后一个元素

2、容量相关

bool empty(); // 判断容器是否为空
size_type size();// 返回容器中当前元素个数
size_type max_size(); //返回容器内可存放的最大元素个数

3、元素访问

// 返回对容器中位置n处元素的值
reference operator[] (size_type n);
const_reference operator[] (size_type n) const;


// 返回容器中位置n处元素的值,若n不在容器中有效元素的范围内，则抛出out_of_range异常
reference at ( size_type n );
const_reference at ( size_type n ) const;

// 返回容器中第一个元素的引用,若容器为空，则导致未定义的行为。
reference front();
const_reference front() const;

// 返回容器中最后一个元素的引用,若容器为空，则导致未定义的行为。
reference back();
const_reference back() const;

// 返回指向数组对象中第一个元素的指针。因为数组中的元素存储在连续的存储位置，所以检索到的指针可以偏移以访问数组中的任何元素。
value_type* data() noexcept;
const value_type* data() const noexcept;

4、修改容器

// 将val 设置为容器对象中所有元素的值。
void fill (const value_type& val);

// 用x的内容交换该array容器的内容，x是另一个相同类型（包括相同大小）的array对象
void swap (array& x) 

5、非成员函数

// 关系运算符
// 在两个array容器之间执行适当的比较操作。其是按顺序依次比较元素来执行的，在第一个不匹配处停止
template <class T, size_T N>
  bool operator == ( const array<T,N>& lhs, const array<T,N>& rhs );

template <class T, size_T N>
  bool operator != ( const array<T,N>& lhs, const array<T,N>& rhs );

template <class T, size_T N>
  bool operator <  ( const array<T,N>& lhs, const array<T,N>& rhs );

template <class T, size_T N>
  bool operator <= ( const array<T,N>& lhs, const array<T,N>& rhs );

template <class T, size_T N>
  bool operator >  ( const array<T,N>& lhs, const array<T,N>& rhs );

template <class T, size_T N>
  bool operator >= ( const array<T,N>& lhs, const array<T,N>& rhs );

// 返回对array容器arr的第I个元素的引用。
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;

示例代码：

#include <iostream>
#include <array>
 
int main()
{
    std::array<int, 3> arr;
 
    // set values:
    std::get<0>(arr) = 1;
    std::get<1>(arr) = 2;
    std::get<2>(arr) = 3;
 
    // get values:
    std::cout << "(" << std::get<0>(arr) << ", " << std::get<1>(arr)
              << ", " << std::get<2>(arr) << ")\n";

    std::array<int, 3> alice{1, 2, 3};
    std::array<int, 3> bob{7, 8, 9};
    std::array<int, 3> eve{1, 2, 3};
 
    std::cout << std::boolalpha;
 
    // Compare non equal containers
    std::cout << "alice == bob returns " << (alice == bob) << '\n';
    std::cout << "alice != bob returns " << (alice != bob) << '\n';
    std::cout << "alice <  bob returns " << (alice < bob) << '\n';
    std::cout << "alice <= bob returns " << (alice <= bob) << '\n';
    std::cout << "alice >  bob returns " << (alice > bob) << '\n';
    std::cout << "alice >= bob returns " << (alice >= bob) << '\n';
 
    std::cout << '\n';
 
    // Compare equal containers
    std::cout << "alice == eve returns " << (alice == eve) << '\n';
    std::cout << "alice != eve returns " << (alice != eve) << '\n';
    std::cout << "alice <  eve returns " << (alice < eve) << '\n';
    std::cout << "alice <= eve returns " << (alice <= eve) << '\n';
    std::cout << "alice >  eve returns " << (alice > eve) << '\n';
    std::cout << "alice >= eve returns " << (alice >= eve) << '\n';

}

输出为;

(1, 2, 3)
alice == bob returns false
alice != bob returns true
alice <  bob returns true
alice <= bob returns true
alice >  bob returns false
alice >= bob returns false
 
alice == eve returns true
alice != eve returns false
alice <  eve returns false
alice <= eve returns true
alice >  eve returns false
alice >= eve returns true