Перейти к содержимому

C++ массивы (std::array)

  • Преимущество C++ массивов над C массивами
  • Копирование и инициализация массивов
  • Индексирование C++ массивов
  • data
  • Получение адресов элементов массива
  • Типы данных кроме int под элементы массива

Для фрагментов без main подключите <array> и <iostream> и поместите код в main.

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.

std::array<int, 3> arr{ 4, 7, 9 };
std::cout << arr.size() << std::endl;
Ответ

Печатает 3. arr.size() возвращает количество элементов, а не число байтов. Здесь это аргумент размера в std::array<int, 3>.

std::array<int, 2> arr{ 1, 2 };
std::array<int, 2> other{ 3, 4 };
arr = other;
Выполнение по шагам
Ответ

Тут каждый элемент копириуется из other в arr.

std::array<int, 2> arr{ 1, 2 };
std::array<int, 2> other{ arr };
Выполнение по шагам
Ответ

Тут тоже, но при создании other.

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.

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.

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.

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 },
};
#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.
#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 - это 4 int, каждый по 4 байта - 16 байт;
  • int* f2 - 8 байтов на 64-битном процессоре.

В сумме 24 байта.

#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.

#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.

#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. В общей сложности выделется память под 6 int-ов.
  • Фигурные скобки означают “инициализация нулями”. Каждый элемент массива заполнится дефолтным A, то есть A{}, что означает, что все 6 int-ов станут нулями.

В 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].

0
1
2
3
0
0

6. (продвинутый уровень): Разбиение массива структур

Заголовок раздела «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 пустых байт.

Массив структур: два элемента Computer с выравниванием

Второй блок хранит части в отдельных массивах и печатает 24. Сами массивы занимают 16 + 4 = 20 байт, но Computers — тоже структура, и ее размер должен быть кратен выравниванию Monitor, то есть 8, поэтому в конце нее остается еще 4 пустых байта. Зато пустые байты между компьютерами исчезли, и с ростом числа элементов экономия растет: тысяча компьютеров займет 10000 байт вместо 16000.

Структура из массивов: раздельное хранение мониторов и клавиатур

Оба блока записывают в первый компьютер одни и те же значения. getComputer возвращает ComputerRef с указателями на части по одному и тому же индексу, поэтому через computer.monitor и computer.keyboard можно обращаться к частям одного компьютера, как будто они по-прежнему лежат вместе.