{

// array::assign: Replaces all elements

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

Myarray c0 = { 0, 1, 2, 3 };

// display contents " 0 1 2 3"

for (Myarray::const_iterator it = c0.begin();

it != c0.end(); ++it)

std::cout << " " << *it;

std::cout << std::endl;

Myarray c1;

c1.assign(4);

// display contents " 4 4 4 4"

for (Myarray::const_iterator it = c1.begin();

it != c1.end(); ++it)

std::cout << " " << *it; // 4 4 4 4

std::cout << std::endl;

return 0;

{

// construction uses aggregate initialization

std::array<int, 3> a1{ { 1, 2, 3 } }; // double-braces required in C++11 (not in C++14)

std::array<int, 3> a2 = { 1, 2, 3 }; // never required after =

std::array<std::string, 2> a3 = { std::string("a"), "b" };

// container operations are supported

std::sort(a1.begin(), a1.end());

std::reverse_copy(a2.begin(), a2.end(), std::ostream_iterator<int>(std::cout, " "));

std::cout << '\n';

// ranged for loop is supported

for (const auto& s : a3)

std::cout << s << ' ';

std::cout << '\n';

return 0;

{

{ // array::array: The array classes are aggregate types, and thus have no custom constructors.

// default initialization (local = automatic storage):

std::array<int, 3> first; // uninitialized: {?,?,?}

// initializer-list initializations:

std::array<int, 3> second = { 10, 20 }; // initialized as: {10,20,0}

std::array<int, 3> third = { 1, 2, 3 }; // initialized as: {1,2,3}

// copy initialization:

std::array<int, 3> fourth = third; // copy: {1,2,3}

std::cout << "The contents of fourth are:";

for (auto x : fourth) std::cout << ' ' << x;

std::cout << '\n';

}

{ // array::at: Returns a reference to the element at position n in the array

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';

}

{ // array::back: Returns a reference to the last element in the array container.

// array::front: Returns a reference to the first element in the array container.

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;

myarray.front() = 999;

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

for (int& x : myarray) std::cout << ' ' << x; // 999 19 50

std::cout << '\n';

}

{ // array::begin: Returns an iterator pointing to the first element in the array container.

// array::end: Returns an iterator pointing to the past-the-end element in the array container.

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';

}

{ // array::cbegin: Returns a const_iterator pointing to the first element in the array container.

// array::cend: Returns a const_iterator pointing to the past-the-end element in the array container.

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';

}

{ // array::crbegin: Returns a const_reverse_iterator pointing to the last element in the array container.

// array::crend: Returns a const_reverse_iterator pointing to the theoretical element preceding

// the first element in the vector, which is considered its reverse end.

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';

}

{ // array::data: Returns a pointer to the first element in the array object.

const char* cstr = "Test string";

std::array<char, 12> charray;

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

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

}

{ // array::empty: Returns a bool value indicating whether the array container is empty, i.e. whether its size is 0.

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';

}

{ // array::fill: Sets val as the value for all the elements in the array object.

std::array<int, 6> myarray;

myarray.fill(5);

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

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

std::cout << '\n';

}

{ // array::max_size: Returns the maximum number of elements that the array container can hold

// array::size: Returns the number of elements in the array container.

std::array<int, 10> myints;

std::cout << "size of myints: " << myints.size() << '\n';

std::cout << "max_size of myints: " << myints.max_size() << '\n';

std::cout << "sizeof(myints): " << sizeof(myints) << std::endl;

}

{ // array::operator[]: Returns a reference to the element at position n in the array container.

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';

}

{ // array::rbegin: Returns a reverse iterator pointing to the last element in the array container.

// array::rend: Returns a reverse iterator pointing to the theoretical element preceding

// the first element in the array (which is considered its reverse end).

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';

}

{ // array::swap: Exchanges the content of the array by the content of x,

// which is another array object of the same type (including the same size).

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';

}

{ // std::get: Returns a reference to the Ith element of array arr

// std::tuple_element<array>: Accesses the static type of the elements in an array object as if it was a tuple.

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";

}

{ // std::relational operators(array): Performs the appropriate comparison operation between the array containers lhs and rhs.

std::array<int, 5> a = { 10, 20, 30, 40, 50 };

std::array<int, 5> b = { 10, 20, 30, 40, 50 };

std::array<int, 5> c = { 50, 40, 30, 20, 10 };

if (a == b) std::cout << "a and b are equal\n";

if (b != c) std::cout << "b and c are not equal\n";

if (b<c) std::cout << "b is less than c\n";

if (c>b) std::cout << "c is greater than b\n";

if (a <= b) std::cout << "a is less than or equal to b\n";

if (a >= b) std::cout << "a is greater than or equal to b\n";

}

return 0;