std::array против производительности массива

Какие преимущества использования std::array перед обычными?

Он имеет дружественную семантику значений, поэтому его можно передавать в функции или возвращать из них по значению. Его интерфейс упрощает определение размера и использование с алгоритмами на основе итераторов в стиле STL.

Он более производительный?

Он должен быть точно таким же. По определению это простой агрегат, содержащий массив в качестве единственного члена.

Просто проще обрабатывать для копирования/доступа?

да.

std::array — это очень тонкая оболочка вокруг массива в стиле C, в основном определяемая как

template<typename T, size_t N>
struct array
{
    T _data[N];
    T& operator[](size_t);
    const T& operator[](size_t) const;
    // other member functions and typedefs
};

Это агрегат, и он позволяет вам использовать его почти как фундаментальный тип (т.е. вы можете передавать по значению, присваивать и т. д., тогда как стандартный массив C не может быть назначен или скопирован непосредственно в другой массив). Вы должны взглянуть на некоторую стандартную реализацию (перейти к определению из вашей любимой IDE или напрямую открыть <array>), это часть стандартной библиотеки C++, которую довольно легко читать и понимать.

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

Вы не должны заметить никакой разницы в производительности во время выполнения, пока вы все еще можете пользоваться дополнительными функциями.

Использование массивов в стиле std::array вместо int[] — хорошая идея, если у вас есть C++11 или boost.

Он более производительный?

Он должен быть точно таким же. По определению это простой агрегат, содержащий массив в качестве единственного члена.

Ситуация кажется более сложной, так как std::array не всегда производит идентичный код сборки по сравнению с C-массивом в зависимости от конкретной платформы.

Я проверил эту конкретную ситуацию на godbolt:

#include <array>
void test(double* const C, const double* const A,
          const double* const B, const size_t size) {
  for (size_t i = 0; i < size; i++) {
    //double arr[2] = {0.e0};//
    std::array<double, 2> arr = {0.e0};//different to double arr[2] for some compiler
    for (size_t j = 0; j < size; j++) {
      arr[0] += A[i] * B[j];
      arr[1] += A[j] * B[i];
    }
    C[i] += arr[0];
    C[i] += arr[1];
  }
}

GCC и Clang создают идентичный ассемблерный код как для версии C-массива, так и для версии std::array.

Однако MSVC и ICPC создают разные ассемблерные коды для каждой версии массива. (Я протестировал ICPC19 с -Ofast и -Os; MSVC -Ox и -Os)

Я понятия не имею, почему это так (я действительно ожидал бы точно такого же поведения std::array и c-array). Возможно, используются разные стратегии оптимизации.

В качестве небольшого дополнения: кажется, в ICPC есть ошибка с

#pragma simd 

для векторизации при использовании c-массива в некоторых ситуациях (код c-массива выдает неправильный вывод; версия std::array работает нормально).

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

Я отправлю отчет об ошибке в Intel, когда буду уверен, что не просто неправильно понял что-то о C-array/std::array и #pragma simd.

std::array имеет семантику значений, а необработанные массивы - нет. Это означает, что вы можете скопировать std::array и обращаться с ним как с примитивным значением. Вы можете получить их по значению или ссылке в качестве аргументов функции и можете вернуть их по значению.

Если вы никогда не копируете std::array, то нет никакой разницы в производительности по сравнению с необработанным массивом. Если вам нужно делать копии, то std::array будет делать то, что нужно, и по-прежнему будет давать одинаковую производительность.