std :: vector против std :: array в C ++

В чем разница между a std::vectorи a std::arrayв C ++? Когда одно должно быть предпочтительнее другого? Каковы плюсы и минусы каждого? Все, что делает мой учебник, это перечисляет, как они одинаковы.

std::vectorявляется шаблоном класса, который инкапсулирует динамический массив ¹ , сохраненный в куче, который автоматически увеличивается и уменьшается при добавлении или удалении элементов. Он предоставляет все хуки ( begin(), end()итераторы и т. Д.), Которые делают его работоспособным с остальной частью STL. У него также есть несколько полезных методов, которые позволяют вам выполнять операции, которые в обычном массиве будут громоздкими, например, вставлять элементы в середине вектора (он выполняет всю работу по перемещению следующих элементов за кулисами).

Поскольку он хранит элементы в памяти, выделенной в куче, он имеет некоторые накладные расходы в отношении статических массивов.

std::arrayэто шаблонный класс, который инкапсулирует массив статического размера, хранящийся внутри самого объекта, что означает, что, если вы создадите экземпляр класса в стеке, сам массив будет в стеке. Его размер должен быть известен во время компиляции (он передается как параметр шаблона), и он не может увеличиваться или уменьшаться.

Он более ограничен std::vector, но часто более эффективен, особенно для небольших размеров, потому что на практике это в основном облегченная оболочка вокруг массива в стиле C. Однако он более безопасен, поскольку неявное преобразование в указатель отключено и обеспечивает большую часть функций, связанных с STL, std::vectorи других контейнеров, поэтому его можно легко использовать с алгоритмами STL & co. Во всяком случае, для самого ограничения фиксированного размера это гораздо менее гибко, чем std::vector.

Для ознакомления std::arrayпосмотрите эту статью ; для быстрого ознакомления с std::vectorоперациями, которые возможны на нем, вы можете посмотреть его документацию .

1. На самом деле, я думаю, что в стандарте они описаны с точки зрения максимальной сложности различных операций (например, произвольный доступ в постоянное время, итерация по всем элементам в линейное время, добавление и удаление элементов в конце в постоянное амортизированное время, и т.д.), но у AFAIK нет другого метода выполнения таких требований, кроме использования динамического массива. Как утверждает @Lucretiel, стандарт фактически требует, чтобы элементы хранились непрерывно, поэтому это динамический массив, хранящийся там, где его размещает связанный распределитель.

Используя std::vector<T>класс:

• ... так же быстро, как и использование встроенных массивов, при условии, что вы делаете только то, что позволяют встроенные массивы (чтение и запись в существующие элементы).

• ... автоматически изменяет размер при вставке новых элементов.

• ... позволяет вставлять новые элементы в начале или в середине вектора, автоматически «сдвигая» остальные элементы «вверх» (имеет ли это смысл?). Это позволяет вам удалять элементы в любом месте std::vector, автоматически сдвигая остальные элементы вниз.

• ... позволяет выполнять чтение с проверкой диапазона с помощью at()метода (вы всегда можете использовать индексаторы, []если не хотите, чтобы эта проверка выполнялась).

Есть два основных предостережения std::vector<T>:

1. У вас нет надежного доступа к базовому указателю, что может быть проблемой, если вы имеете дело со сторонними функциями, которые требуют адрес массива.

2. std::vector<bool>Класс глупо. Он реализован как сжатое битовое поле, а не как массив. Избегайте этого, если вы хотите массив bools!

3. Во время использования std::vector<T>s будет немного больше, чем массив C ++ с тем же количеством элементов. Это потому, что им нужно отслеживать небольшое количество другой информации, например их текущий размер, и потому что всякий раз, когда std::vector<T>размер s изменяется, они резервируют больше места, чем им нужно. Это предотвращает изменение размера при каждом добавлении нового элемента. Такое поведение можно изменить, предоставив кастом allocator, но я никогда не чувствовал необходимости делать это!

Изменить: После прочтения ответа Zud на вопрос, я чувствовал, что я должен добавить это:

std::array<T>Класс не такой же , как массив C ++. std::array<T>очень тонкая обертка вокруг массивов C ++, основная цель которой - скрыть указатель от пользователя класса (в C ++ массивы неявно приводятся как указатели, часто приводящие к ужасающему эффекту). std::array<T>Класс также хранит ее размер (длина), которая может быть очень полезным.

Чтобы подчеркнуть точку зрения @MatteoItalia, разница в эффективности заключается в том, где хранятся данные. Куча памяти (требуется с vector) требует вызова системы для выделения памяти, и это может быть дорого, если вы считаете циклы. Стековая память (возможная для array) практически не требует затрат времени, потому что память выделяется путем простой настройки указателя стека, и это делается один раз при входе в функцию. Стек также позволяет избежать фрагментации памяти. Конечно, std::arrayне всегда будет в стеке; это зависит от того, где вы его выделите, но все равно будет выделяться на одну кучу меньше памяти из кучи по сравнению с вектором. Если у тебя есть

• маленький «массив» (скажем, менее 100 элементов) - (типичный стек составляет около 8 МБ, поэтому не выделяйте больше, чем несколько КБ в стеке или меньше, если ваш код рекурсивный)
• размер будет фиксированным
• время жизни находится в области действия функции (или является значением члена с тем же временем жизни, что и у родительского класса)
• ты считаешь циклы,

определенно используйте std::arrayнад вектором. Если какое-либо из этих требований не соответствует действительности, используйте a std::vector.

Если вы рассматриваете возможность использования многомерных массивов, то есть одно дополнительное отличие между std :: array и std :: vector. У многомерного std :: array будут элементы, упакованные в память во всех измерениях, так же, как массив AC стиля. Многомерный std :: vector не будет упакован во всех измерениях.

Учитывая следующие декларации:

int cConc[3][5];
std::array<std::array<int, 5>, 3> aConc;
int **ptrConc;      // initialized to [3][5] via new and destructed via delete
std::vector<std::vector<int>> vConc;    // initialized to [3][5]

Указатель на первый элемент в массиве c-style (cConc) или std :: array (aConc) может быть повторен по всему массиву путем добавления 1 к каждому предыдущему элементу. Они плотно упакованы.

Указатель на первый элемент в векторном массиве (vConc) или массиве указателей (ptrConc) может быть повторен только через первые 5 (в данном случае) элементов, и затем для моей служебной информации существует 12 байтов (в моей системе) служебных данных. следующий вектор.

Это означает, что массив std :: vector>, инициализированный как массив [3] [1000], будет намного меньше в памяти, чем массив, инициализированный как массив [1000] [3], и оба будут больше в памяти, чем std: Массив выделяется в любом случае.

Это также означает, что вы не можете просто передать многомерный векторный массив (или указатель), скажем, в openGL без учета накладных расходов памяти, но вы можете наивно передать многомерный массив std :: array в openGL и заставить его работать.

Вектор - это контейнерный класс, а массив - выделенная память.