c++标准模板（STL）（std::array）（三）-Toy模板网

这篇具有很好参考价值的文章主要介绍了c++标准模板（STL）（std::array）（三）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

定义于头文件 <array>

template<

class T,
std::size_t N

> struct array;

(C++11 起

文章来源地址https://www.toymoban.com/news/detail-431817.html

std::array 是封装固定大小数组的容器。

此容器是一个聚合类型，其语义等同于保有一个 C 风格数组 T[N] 作为其唯一非静态数据成员的结构体。不同于 C 风格数组，它不会自动退化成 T* 。它能作为聚合类型聚合初始化，只要有至多 N 个能转换成 T 的初始化器： std::array<int, 3> a = {1,2,3}; 。

该结构体结合了 C 风格数组的性能、可访问性与容器的优点，比如可获取大小、支持赋值、随机访问迭代器等。

std::array 满足容器 (Container) 和可逆容器 (ReversibleContainer) 的要求，除了默认构造的 array 是非空的，以及进行交换的复杂度是线性，它满足连续容器 (ContiguousContainer) (C++17 起)的要求并部分满足序列容器 (SequenceContainer) 的要求。

当其长度为零时 array （ N == 0 ）有特殊情况。此时， array.begin() == array.end() ，并拥有某个唯一值。在零长 array 上调用 front() 或 back() 是未定义的。

亦可将 array 当做拥有 N 个同类型元素的元组。

迭代器非法化

按照规则，指向 array 的迭代器在 array 的生存期间决不非法化。然而要注意，在 swap 时，迭代器将继续指向同一 array 的元素，并将改变元素的值。

迭代器

返回指向容器第一个元素的迭代器

std::array<T,N>::begin, std::array<T,N>::cbegin

iterator begin() noexcept;		(C++17 前)
constexpr iterator begin() noexcept;		(C++17 起)
const_iterator begin() const noexcept;		(C++17 前)
constexpr const_iterator begin() const noexcept;		(C++17 起)
const_iterator cbegin() const noexcept;		(C++17 前)
constexpr const_iterator cbegin() const noexcept;		(C++17 起)

返回指向容器首元素的迭代器。

若容器为空，则返回的迭代器将等于 end() 。

c++标准模板（STL）（std::array）（三）

参数

（无）

返回值

指向首元素的迭代器。

复杂度

常数。

返回指向容器尾端的迭代器

std::array<T,N>::end, std::array<T,N>::cend

iterator end() noexcept;		(C++17 前)
constexpr iterator end() noexcept;		(C++17 起)
const_iterator end() const noexcept;		(C++17 前)
constexpr const_iterator end() const noexcept;		(C++17 起)
const_iterator cend() const noexcept;		(C++17 前)
constexpr const_iterator cend() const noexcept;		(C++17 起)

返回指向容器末元素后一元素的迭代器。

此元素表现为占位符；试图访问它导致未定义行为。

c++标准模板（STL）（std::array）（三）

参数

（无）

返回值

指向后随最后元素的迭代器。

复杂度

常数。

返回指向容器最后元素的逆向迭代器

std::array<T,N>::rbegin, std::array<T,N>::crbegin

reverse_iterator rbegin() noexcept;		(C++17 前)
constexpr reverse_iterator rbegin() noexcept;		(C++17 起)
const_reverse_iterator rbegin() const noexcept;		(C++17 前)
constexpr const_reverse_iterator rbegin() const noexcept;		(C++17 起)
const_reverse_iterator crbegin() const noexcept;		(C++17 前)
constexpr const_reverse_iterator crbegin() const noexcept;		(C++17 起)

返回指向逆向容器首元素的逆向迭代器。它对应非逆向容器的末元素。

c++标准模板（STL）（std::array）（三）

参数

（无）

返回值

指向首元素的逆向迭代器。

复杂度

常数。

返回指向前端的逆向迭代器

std::array<T,N>::rend, std::array<T,N>::crend

reverse_iterator rend() noexcept;		(C++17 前)
constexpr reverse_iterator rend() noexcept;		(C++17 起)
const_reverse_iterator rend() const noexcept;		(C++17 前)
constexpr const_reverse_iterator rend() const noexcept;		(C++17 起)
const_reverse_iterator crend() const noexcept;		(C++17 前)
constexpr const_reverse_iterator crend() const noexcept;		(C++17 起)

返回指向逆向容器末元素后一元素的逆向迭代器。它对应非逆向容器首元素的前一元素。此元素表现为占位符，试图访问它导致未定义行为。

c++标准模板（STL）（std::array）（三）

参数

（无）

返回值

指向末元素后一元素的逆向迭代器。

复杂度

常数。

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <array>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

using namespace std;

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };

    //遵循聚合初始化的规则初始化 array （注意默认初始化可以导致非类的 T 的不确定值）
    std::array<Cell, 6> array1;
    std::cout << "array1:   ";
    std::copy(array1.begin(), array1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::generate(array1.begin(), array1.end(), generate);
    std::cout << "array1:   ";
    std::copy(array1.begin(), array1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    //返回指向容器首元素的迭代器。若容器为空，则返回的迭代器将等于 end() 。
    //返回指向容器末元素后一元素的迭代器。此元素表现为占位符；试图访问它导致未定义行为。
    for (std::array<Cell, 6>::iterator it = array1.begin(); it != array1.end(); it++)
    {
        *it = generate();
    }

    std::cout << "array1 const_iterator:   " << std::endl;
    for (std::array<Cell, 6>::const_iterator cit = array1.cbegin(); cit != array1.cend(); cit++)
    {
        std::cout << cit << " " << *cit << std::endl;
    }
    std::cout << std::endl;

    //返回指向逆向容器首元素的逆向迭代器。它对应非逆向容器的末元素。
    //返回指向逆向容器末元素后一元素的逆向迭代器。
    //它对应非逆向容器首元素的前一元素。此元素表现为占位符，试图访问它导致未定义行为。
    for (std::array<Cell, 6>::reverse_iterator  rit = array1.rbegin(); rit != array1.rend(); rit++)
    {
        *rit = generate();
    }

    std::cout << "array1 const_reverse_iterator:   " << std::endl;
    for (std::array<Cell, 6>::const_reverse_iterator crit = array1.crbegin(); crit != array1.crend(); crit++)
    {
        std::cout << "crit: " << " " << *crit << std::endl;
    }
    std::cout << std::endl;

    return 0;
}