`array` 類別（C++ 標準程式庫）

發行項
10/12/2023

說明的物件可控制長度 N 之 Ty 類型項目的序列。序列會儲存成陣列 Ty，包含在 array<Ty, N> 物件中。

語法

template <class Ty, std::size_t N>
class array;

參數

Ty
元素的類型。

N
項目的數目。

成員

類型定義	描述
`const_iterator`	用於受控制序列的常數迭代器類型。
`const_pointer`	項目的常數指標類型。
`const_reference`	項目的常數參考類型。
`const_reverse_iterator`	用於受控制序列的常數反向迭代器類型。
`difference_type`	兩個項目之間帶正負號距離的類型。
`iterator`	受控制序列之迭代器的類型。
`pointer`	項目的指標類型。
`reference`	項目的參考類型。
`reverse_iterator`	受控制序列的反向迭代器類型。
`size_type`	兩個項目之間不帶正負號距離的類型。
`value_type`	元素的類型。

成員函式	描述
`array`	建構陣列物件。
`assign`	（已過時。使用 `fill` 。）取代所有元素。
`at`	存取指定位置的項目。
`back`	存取最後一個項目。
`begin`	指定受控制序列的開頭。
`cbegin`	將隨機存取常數迭代器傳回陣列中的第一個項目。
`cend`	傳回隨機存取指向陣列結尾之後一個項目的常數迭代器。
`crbegin`	將常數迭代器傳回反向陣列中的第一個項目。
`crend`	將常數迭代器傳回反向陣列的結尾。
`data`	取得第一個項目的位址。
`empty`	測試項目是否存在。
`end`	指定受控制序列的結尾。
`fill`	取代所有具有指定值的項目。
`front`	存取第一個項目。
`max_size`	計算元素的數目。
`rbegin`	指定反向受控制序列的開頭。
`rend`	指定反向受控制序列的結尾。
`size`	計算元素的數目。
`swap`	交換兩個容器的內容。

運算子	描述
`array::operator=`	取代受控制的序列。
`array::operator[]`	存取指定位置的項目。

備註

該類型具有預設建構函式 array() 與預設指派運算子 operator=，且可滿足 aggregate 的需求。因此，array<Ty, N> 類型的物件可以使用彙總初始設定式加以初始化。例如，

array<int, 4> ai = { 1, 2, 3 };

建立含有四個整數值的物件 ai，將前三個項目分別初始化為值 1、 2 和 3，並將第四個項目初始化為 0。

需求

標頭：<array>

命名空間：std

`array::array`

建構陣列物件。

array();

array(const array& right);

參數

right
要插入的物件或範圍。

備註

預設建構函式 array() 會讓受控制序列處於未初始化狀態 (預設為初始化)。您使用它來指定未初始化的受控制序列。

複製建構函式 array(const array& right) 會使用序列 [right.begin(), right.end()) 來初始化受控制序列。您可以使用它來指定初始受控制序列，這是陣列物件 right 所控制之序列的複本。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1(c0);

    // display contents " 0 1 2 3"
    for (const auto& it : c1)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

`array::assign`

在 C++11 中已過時，由 fill 取代。取代所有項目。

`array::at`

存取指定位置的項目。

reference at(size_type off);

constexpr const_reference at(size_type off) const;

參數

off
要存取的項目的位置。

備註

成員函式會傳回位於 off 位置的受控制序列項目的參考。如果該位置無效，函式就會擲回類別 out_of_range 的物件。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display odd elements " 1 3"
    std::cout << " " << c0.at(1);
    std::cout << " " << c0.at(3);
    std::cout << std::endl;

    return (0);
}

`array::back`

存取最後一個項目。

reference back();

constexpr const_reference back() const;

備註

成員函式會傳回受控制序列的最後一個項目的參考，絕對不能空白。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    std::cout << " " << c0.back();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::begin`

指定受控制序列的開頭。

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

備註

成員函式傳回的隨機存取迭代器，指向序列的第一個項目 (或空序列結尾以外的位置)。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::iterator it2 = c0.begin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::cbegin`

傳回 const 迭代器，為範圍中的第一個項目定址。

const_iterator cbegin() const noexcept;

傳回值

const 隨機存取迭代器，指向範圍的第一個項目，或指向空白範圍結尾 (空白範圍 cbegin() == cend()) 之外的位置。

備註

使用的 cbegin 傳回值，就無法修改範圍中的專案。

您可以使用此成員函式取代 begin() 成員函式，以確保傳回值是 const_iterator。一般而言，它會與類型推算關鍵字搭配 auto 使用，如下列範例所示。在此範例中，請考慮將 Container 視為任何支援 begin() 和 cbegin() 且可修改 (非 const) 的容器類型。

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`array::cend`

傳回 const 迭代器，為範圍中最後一個項目之外的位置定址。

const_iterator cend() const noexcept;

傳回值

指向範圍結尾之外的隨機存取迭代器。

備註

cend 用來測試迭代器是否已超過其範圍結尾。

您可以使用此成員函式取代 end() 成員函式，以確保傳回值是 const_iterator。一般而言，它會與類型推算關鍵字搭配 auto 使用，如下列範例所示。在此範例中，請考慮將 Container 視為任何支援 end() 和 cend() 且可修改 (非 const) 的容器類型。

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

所 cend 傳回的值不應該取值。

`array::const_iterator`

用於受控制序列的常數迭代器類型。

typedef implementation-defined const_iterator;

備註

此類型所描述的物件可作為受控制序列的常數隨機存取迭代器。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> MyArray;

int main()
{
    MyArray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    std::cout << "it1:";
    for (MyArray::const_iterator it1 = c0.begin();
        it1 != c0.end();
        ++it1) {
        std::cout << " " << *it1;
    }
    std::cout << std::endl;

    // display first element " 0"
    MyArray::const_iterator it2 = c0.begin();
    std::cout << "it2:";
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

it1: 0 1 2 3
it2: 0

`array::const_pointer`

項目的常數指標類型。

typedef const Ty *const_pointer;

備註

此類型所描述的物件可以作為序列之元素的常數指標。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_pointer ptr = &*c0.begin();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::const_reference`

項目的常數參考類型。

typedef const Ty& const_reference;

備註

此類型所說明的物件可作為受控制序列之元素的常數參考。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_reference ref = *c0.begin();
    std::cout << " " << ref;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::const_reverse_iterator`

用於受控制序列的常數反向迭代器類型。

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

備註

此類型所描述的物件可作為受控制序列的常數反向迭代器。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::const_reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::crbegin`

將常數迭代器傳回反向陣列中的第一個項目。

const_reverse_iterator crbegin() const;

傳回值

const 反轉隨機存取迭代器，其定址反轉陣列中的第一個項目，或定址未反轉陣列中的最後一個項目。

備註

使用的 crbegin 傳回值，無法修改陣列物件。

範例

#include <array>
#include <iostream>

int main( )
{
   using namespace std;
   array<int, 2> v1 = {1, 2};
   array<int, 2>::iterator v1_Iter;
   array<int, 2>::const_reverse_iterator v1_rIter;

   v1_Iter = v1.begin( );
   cout << "The first element of array is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed array is "
        << *v1_rIter << "." << endl;
}

The first element of array is 1.
The first element of the reversed array is 2.

`array::crend`

傳回 const 迭代器，其定址反轉陣列中最後一個元素的下一個位置。

const_reverse_iterator crend() const noexcept;

傳回值

const 反轉隨機存取迭代器，其定址反轉陣列中最後一個元素的下一個位置 (此位置在未反轉的陣列中優先於第一個元素)。

備註

crend 與反向陣列搭配使用，就像與陣列一樣 array::cend 。

使用的傳回值 crend （適當遞減），就無法修改陣列物件。

crend 可以用來測試反轉迭代器是否已到達其陣列的結尾。

所 crend 傳回的值不應該取值。

範例

#include <array>
#include <iostream>

int main( )
{
   using namespace std;
   array<int, 2> v1 = {1, 2};
   array<int, 2>::const_reverse_iterator v1_rIter;

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`array::data`

取得第一個項目的位址。

Ty *data();

const Ty *data() const;

備註

這些成員函式會傳回受控制序列中第一個元素的位址。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::pointer ptr = c0.data();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::difference_type`

兩個項目之間帶正負號距離的類型。

typedef std::ptrdiff_t difference_type;

備註

此帶正負號的整數類型所描述的物件可代表受控制序列中任何兩個項目位址之間的差距。這是類型的同義字 std::ptrdiff_t 。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display distance first-last " -4"
    Myarray::difference_type diff = c0.begin() - c0.end();
    std::cout << " " << diff;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
-4

`array::empty`

測試項目是否不存在。

constexpr bool empty() const;

備註

唯有 N == 0 時，成員函式才會傳回 true。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display whether c0 is empty " false"
    std::cout << std::boolalpha << " " << c0.empty();
    std::cout << std::endl;

    std::array<int, 0> c1;

    // display whether c1 is empty " true"
    std::cout << std::boolalpha << " " << c1.empty();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
false
true

`array::end`

指定受控制序列的結尾。

reference end();

const_reference end() const;

備註

成員函式會傳回指向序列結尾之外的隨機存取迭代器。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::iterator it2 = c0.end();
    std::cout << " " << *--it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::fill`

清除陣列，並將指定的專案複製到空陣列。

void fill(const Type& val);

參數

val
插入陣列中之項目的值。

備註

fill 會以指定的值取代陣列的每個項目。

範例

#include <array>
#include <iostream>

int main()
{
    using namespace std;
    array<int, 2> v1 = { 1, 2 };

    cout << "v1 = ";
    for (const auto& it : v1)
    {
        std::cout << " " << it;
    }
    cout << endl;

    v1.fill(3);
    cout << "v1 = ";
    for (const auto& it : v1)
    {
        std::cout << " " << it;
    }
    cout << endl;
}

`array::front`

存取第一個項目。

reference front();

constexpr const_reference front() const;

備註

成員函式會傳回受控制序列的第一個項目的參考，絕對不能空白。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    std::cout << " " << c0.front();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::iterator`

受控制序列之迭代器的類型。

typedef implementation-defined iterator;

備註

此類型說明可作為受控制序列之隨機存取迭代器的物件。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> MyArray;

int main()
{
    MyArray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    std::cout << "it1:";
    for (MyArray::iterator it1 = c0.begin();
        it1 != c0.end();
        ++it1) {
        std::cout << " " << *it1;
    }
    std::cout << std::endl;

    // display first element " 0"
    MyArray::iterator it2 = c0.begin();
    std::cout << "it2:";
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

it1: 0 1 2 3

it2: 0

`array::max_size`

計算元素的數目。

constexpr size_type max_size() const;

備註

此成員函式會傳回 N。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display (maximum) size " 4"
    std::cout << " " << c0.max_size();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::operator[]`

存取指定位置的項目。

reference operator[](size_type off);

constexpr const_reference operator[](size_type off) const;

參數

off
要存取的項目的位置。

備註

成員函式會傳回位於 off 位置的受控制序列項目的參考。如果位置不正確，就不會定義行為。

也有一個非成員 get 函式可供取得元素的 array 參考。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display odd elements " 1 3"
    std::cout << " " << c0[1];
    std::cout << " " << c0[3];
    std::cout << std::endl;

    return (0);
}

0 1 2 3
1 3

`array::operator=`

取代受控制的序列。

array<Value> operator=(array<Value> right);

參數

right
要複製的容器。

備註

成員運算子會將 right 的每個元素指派給受控制序列的對應元素，然後傳回 *this。您使用它將受控制序列取代為 right 中受控制序列的複本。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1;
    c1 = c0;

    // display copied contents " 0 1 2 3"
        // display contents " 0 1 2 3"
    for (auto it : c1)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

`array::pointer`

項目的指標類型。

typedef Ty *pointer;

備註

此類型所描述的物件可以作為序列之元素的指標。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::pointer ptr = &*c0.begin();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::rbegin`

指定反向受控制序列的開頭。

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

備註

成員函式會傳回指向受控制序列結尾之外的反向迭代器。因此，它會指定反向序列的開頭。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::const_reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::reference`

項目的參考類型。

typedef Ty& reference;

備註

此類型所說明的物件可做為受控制序列之元素的參考。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::reference ref = *c0.begin();
    std::cout << " " << ref;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::rend`

指定反向受控制序列的結尾。

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

備註

成員函式傳回的反向迭代器，指向序列的第一個項目 (或空序列結尾以外的位置)。因此，它會指定反向序列的結尾。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_reverse_iterator it2 = c0.rend();
    std::cout << " " << *--it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::reverse_iterator`

受控制序列的反向迭代器類型。

typedef std::reverse_iterator<iterator> reverse_iterator;

備註

此類型所描述的物件可作為受控制序列的反向迭代器。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::size`

計算元素的數目。

constexpr size_type size() const;

備註

此成員函式會傳回 N。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display size " 4"
    std::cout << " " << c0.size();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::size_type`

兩個項目之間不帶正負號距離的類型。

typedef std::size_t size_type;

備註

此不帶正負號的整數類型所描述的物件可代表任何受控制序列的長度。這是類型的同義字 std::size_t 。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display distance last-first " 4"
    Myarray::size_type diff = c0.end() - c0.begin();
    std::cout << " " << diff;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::swap`

將這個陣列的內容與另一個陣列交換。

void swap(array& right);

參數

right
要與之交換內容的陣列。

備註

成員函式會交換和右之間的 *this 受控制序列。它會執行與成正比 N 的專案指派和建構函式呼叫。

另外還有一個非成員 swap 函式可供交換兩 array 個實例。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1 = { 4, 5, 6, 7 };
    c0.swap(c1);

    // display swapped contents " 4 5 6 7"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    swap(c0, c1);

    // display swapped contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4 5 6 7
0 1 2 3

`array::value_type`

元素的類型。

typedef Ty value_type;

備註

此類型是範本參數 Ty的同義字。

範例

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        Myarray::value_type val = it;
        std::cout << " " << val;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

另請參閱

<array>

array 類別 （C++ 標準程式庫）

語法

參數

成員

備註

需求

array::array

參數

備註

範例

array::assign

array::at

參數

備註

範例

array::back

備註

範例

array::begin

備註

範例

array::cbegin

傳回值

備註

array::cend

傳回值

備註

array::const_iterator

備註

範例

array::const_pointer

備註

範例

array::const_reference

備註

範例

array::const_reverse_iterator

備註

範例

array::crbegin

傳回值

備註

範例

array::crend

傳回值

備註

範例

array::data

備註

範例

array::difference_type

備註

範例

array::empty

備註

範例

array::end

備註

範例

array::fill

參數

備註

範例

array::front

備註

範例

array::iterator

備註

範例

array::max_size

備註

範例

array::operator[]

參數

備註

範例

array::operator=

參數

備註

範例