C++ массивы (std::array)
Концепты
Заголовок раздела «Концепты»- Преимущество C++ массивов над C массивами
- Копирование и инициализация массивов
- Индексирование C++ массивов
data- Получение адресов элементов массива
- Типы данных кроме
intпод элементы массива
Примеры
Заголовок раздела «Примеры»Для фрагментов без main подключите <array> и <iostream> и поместите код в main.
1. Получение адреса первого элемента
Заголовок раздела «1. Получение адреса первого элемента»std::array<int, 2> arr{ 1, 2 };int* p{ arr.data() };*p = 3;std::cout << arr[0] << std::endl;std::cout << arr[1] << std::endl;Выполнение по шагам
Ответ
arr.data() возвращает указатель на первый элемент, как и &arr[0].
Запись через этот указатель изменяет элемент.
Печатает 3 и 2.
2. Количество элементов
Заголовок раздела «2. Количество элементов»std::array<int, 3> arr{ 4, 7, 9 };std::cout << arr.size() << std::endl;Ответ
Печатает 3.
arr.size() возвращает количество элементов, а не число байтов.
Здесь это аргумент размера в std::array<int, 3>.
3. Инициализация C++ массивов (1)
Заголовок раздела «3. Инициализация C++ массивов (1)»std::array<int, 2> arr{ 1, 2 };std::array<int, 2> other{ 3, 4 };arr = other;Выполнение по шагам
Ответ
Тут каждый элемент копириуется из other в arr.
4. Инициализация C++ массивов (2)
Заголовок раздела «4. Инициализация C++ массивов (2)»std::array<int, 2> arr{ 1, 2 };std::array<int, 2> other{ arr };Выполнение по шагам
Ответ
Тут тоже, но при создании other.
5. Адрес массива
Заголовок раздела «5. Адрес массива»std::array<int, 2> arr{ 1, 2 };std::array<int, 2>* p{ &arr };*p = { 3, 4 };std::cout << arr[0] << std::endl;std::cout << arr[1] << std::endl;Выполнение по шагам
Ответ
p будет содержать адрес начала всего массива.
Этот адрес указывает на весь массив со всеми его элементами.
Здесь, изначальные элементы перезаписываются на 3, 4.
6. Dereference адреса массива
Заголовок раздела «6. Dereference адреса массива»std::array<int, 2> arr{ 1, 2 };std::array<int, 2>* p{ &arr };std::array<int, 2> arr1{ *p };arr1[0] = 3;arr1[1] = 4;std::cout << arr[0] << std::endl;std::cout << arr[1] << std::endl;Выполнение по шагам
Ответ
p указывает на переменную типа std::array<int, 2>, а выражение *p даёт значение
типа std::array<int, 2>, то есть в arr1 попадет копия всего массива
Поскольку arr1 это копия, ее изменения не повлияют на arr.
7. Индексирование элементов из адреса
Заголовок раздела «7. Индексирование элементов из адреса»std::array<int, 2> arr{ 1, 2 };std::array<int, 2>* p{ &arr };(*p)[0] = 3;(*p)[1] = 4;std::cout << arr[0] << std::endl;std::cout << arr[1] << std::endl;Выполнение по шагам
Ответ
*p обращается к исходной переменной arr.
(*p)[0] и (*p)[1] обращаются к его элементам, поэтому присваивания изменяют arr.
Печатает 3 и 4.
8. Матрицы (двумерные массивы)
Заголовок раздела «8. Матрицы (двумерные массивы)»std::array<std::array<int, 2>, 3> arr{ std::array{ 1, 2 }, { 3, 4 }, { 5, 6 },};std::array<int, 2> firstRow { arr[0] };std::array<int, 2> lastRow { arr[2] };arr[0][0] = 7;arr[2][1] = 8;arr[1] = { 9, 10 };Выполнение по шагам
Ответ
Тут иллюстрируется использование массива, где тип элемента не int, а массив.
Каждый элемент массива по сути теперь хранит в себе по два инта.
В инициализации
arrнеобходимо указатьstd::array, потому что иначе компилятор не может определить тип элемента из инициализации. Ему нужно слегка помочь.Механизм этого вам пока не обязательно понимать.
Можно ли использовать пользовательский тип как элемент массива?
Можно. Попробуйте определить тип, например:
struct Item{ int f1; int f2;};И использовать его в качестве типа элемента, вот так:
std::array<Item, 3> arr{ Item{ 1, 2 }, { 3, 4 }, { 5, 6 },};Структуры и массивы
Заголовок раздела «Структуры и массивы»1. Поле массива из адресов
Заголовок раздела «1. Поле массива из адресов»#include <iostream>#include <array>
struct A{ std::array<int*, 2> f;};
int main(){ int var1; int var2; A a { .f = { &var1, &var2 } }; *a.f[0] = 1; *a.f[1] = 2; int** b = a.f.data(); int c = **b;
std::cout << var1 << std::endl; std::cout << var2 << std::endl;
std::cout << a.f[0] << std::endl; std::cout << a.f[1] << std::endl;
std::cout << b << std::endl; std::cout << c << std::endl;}Выполнение по шагам
Ответ:
Строчка A a { .f = { &var1, &var2 } }; инициализирует a,
вписав в поле a.f[0] адрес на var1 и в a.f[1] адрес на var2.
В строчке *a.f[0] = ..., происходит переход по адресу, сохраненному в a.f[0]:
*a.f[0] -> *(a.f[0]) -> *(&var1) -> var1.
В int** b = a.f.data(); метод .data() возвращает &(a.f[0]) типа int**.
Это адрес первого элемента массива f внутри a.
Выведется:
1,2как значенияvar1иvar2;- адреса
var1иvar2как значенияa.f[0]иa.f[1]; cбудет равно1.
2. Размер структуры (2)
Заголовок раздела «2. Размер структуры (2)»#include <iostream>#include <array>
struct A{ std::array<int, 4> f1; int* f2;};
int main(){ std::cout << sizeof(A) << std::endl;}Ответ:
std::array<int, 4> f1- это 4int, каждый по 4 байта - 16 байт;int* f2- 8 байтов на 64-битном процессоре.
В сумме 24 байта.
3. Инициализация поля массива
Заголовок раздела «3. Инициализация поля массива»#include <iostream>#include <array>
struct A{ std::array<int, 2> arr;};
int main(){ A a { { 1, 2 } }; A b { { 3, 4 } }; b = a;
std::cout << b.arr[0] << std::endl; std::cout << b.arr[1] << std::endl;}Выполнение по шагам
Ответ:
Выведется 1, 2.
4. Копирование структуры с полем-массивом
Заголовок раздела «4. Копирование структуры с полем-массивом»#include <iostream>#include <array>
struct A{ std::array<int, 2> arr;};
int main(){ A a { { 1, 2 } }; A b { a };
a.arr[0] = 3;
std::cout << b.arr[0] << std::endl; std::cout << b.arr[1] << std::endl; std::cout << a.arr[0] << std::endl; std::cout << a.arr[1] << std::endl;}Выполнение по шагам
Ответ:
A b{ a } копирует значения всех полей, включая массив целиком, поэлементно.
На момент копирования в a лежит arr[0] = 1, arr[1] = 2,
поэтому в b попадут те же значения: b.arr[0] = 1, b.arr[1] = 2.
Но это отдельная копия в отдельной памяти: сам массив arr
хранится внутри A по значению, а не по адресу.
Поэтому последующее изменение a.arr[0] = 3
меняет только a, а b остается нетронутым.
Выведется 1, 2, 3, 2.
5. Массив структур
Заголовок раздела «5. Массив структур»#include <iostream>#include <array>
struct A{ int f1; int f2;};
int main(){ std::array<A, 3> arr{};
arr[0].f2 = 1;
arr[1] = A{ 2, 3 };
A copy { arr[2] }; copy.f1 = 4; copy.f2 = 5;
std::cout << arr[0].f1 << std::endl; std::cout << arr[0].f2 << std::endl; std::cout << arr[1].f1 << std::endl; std::cout << arr[1].f2 << std::endl; std::cout << arr[2].f1 << std::endl; std::cout << arr[2].f2 << std::endl;}Выполнение по шагам
Ответ:
Строчка std::array<A, 3> arr{};:
- Определяет массив из трех переменных типа
A. В общей сложности выделется память под 6int-ов. - Фигурные скобки означают “инициализация нулями”.
Каждый элемент массива заполнится дефолтным
A, то естьA{}, что означает, что все 6int-ов станут нулями.
В arr[0].f2 = 1;, arr[0] получает доступ к памяти
первой переменной в массиве.
Эта переменная типа A (не int! очень важно понимать).
В ней внутри во второе поле (.f2) вписывается 1 (= 1).
arr[1] = A{ 2, 3 }; перезаписывает весь второй элемент
результатом выражения A{ 2, 3 }.
Это перезапишет оба поля.
A copy { arr[2] }; считывает из третьего элемента массива,
копируя то, что есть там, во временную переменную copy.
copy хранит копию значения из arr[2] типа A (то есть, имеет копию всех полей).
Следовательно, последующие воздействия на copy не повлияют на arr[2].
0123006. (продвинутый уровень): Разбиение массива структур
Заголовок раздела «6. (продвинутый уровень): Разбиение массива структур»#include <array>#include <cstddef>#include <cstdint>#include <iostream>
const size_t count = 2;
struct Monitor{ double diagonalInches;};
struct Keyboard{ uint8_t rows; uint8_t columns;};
struct Computer{ Monitor monitor; Keyboard keyboard;};
struct Computers{ std::array<Monitor, count> monitors; std::array<Keyboard, count> keyboards;};
struct ComputerRef{ Monitor* monitor; Keyboard* keyboard;};
ComputerRef getComputer(Computers* computers, size_t index){ return ComputerRef{ &computers->monitors[index], &computers->keyboards[index], };}
int main(){ { std::array<Computer, count> computers{}; computers[0].monitor.diagonalInches = 27; computers[0].keyboard.rows = 6; std::cout << sizeof(computers) << std::endl; }
{ Computers computers{}; ComputerRef computer = getComputer(&computers, 0); computer.monitor->diagonalInches = 27; computer.keyboard->rows = 6; std::cout << sizeof(computers) << std::endl; }}Ответ
Первый блок напечатает 32, то есть 2 * 16: каждый Computer занимает 16 байт,
хотя его части занимают всего 8 + 2 = 10.
double требует выравнивания по 8, и размер структуры тоже должен быть кратен 8,
иначе следующий элемент массива оказался бы на невыровненном адресе.
Поэтому в конце каждого компьютера остается 6 пустых байт.
Второй блок хранит части в отдельных массивах и печатает 24.
Сами массивы занимают 16 + 4 = 20 байт, но Computers — тоже структура,
и ее размер должен быть кратен выравниванию Monitor, то есть 8,
поэтому в конце нее остается еще 4 пустых байта. Зато пустые байты между компьютерами
исчезли, и с ростом числа элементов экономия растет:
тысяча компьютеров займет 10000 байт вместо 16000.
Оба блока записывают в первый компьютер одни и те же значения.
getComputer возвращает ComputerRef с указателями на части по одному и тому же индексу,
поэтому через computer.monitor и computer.keyboard можно обращаться к частям
одного компьютера, как будто они по-прежнему лежат вместе.