std::array vs les performances de la baie

Si je veux construire un système très simple tableau comme

int myArray[3] = {1,2,3};

Dois-je utiliser std::array à la place ?

std::array<int, 3> a = {{1, 2, 3}};

Quels sont les avantages de l'utilisation de std::array habituelles? Est-il plus performant ? Il est juste plus facile à gérer pour copier/accès ?

  • définition multidimensionnelle de tableau avec std:: sera difficile
  • Ce n'est pas difficile, juste un peu plus détaillé.
  • Pointeur de la décroissance, en prenant une référence etc..., beaucoup de choses sont étranges à propos de c-tableaux. L'itérateur peut être un pointeur dans le cas de c-tableaux et for (auto i = ++std::begin(myArray); . . . peut même pas compiler (il semble que temporaires de type fondamental ne sont pas mutables, du moins pas avec clang 6)
InformationsquelleAutor Arcyno | 2015-05-15
  1. 60

    Quels sont les avantages de l'utilisation de std::array plus habituelles?

    Il est amical valeur sémantique, de sorte qu'il peut être transmis à ou renvoyées par les fonctions par valeur. Son interface le rend plus commode pour trouver la taille, et l'utilisation avec STL-style itérateur à base d'algorithmes.

    Est-il plus performant ?

    Il doit être exactement le même. Par définition, c'est un simple agrégat contenant un tableau en tant que seul membre.

    Juste plus facile à gérer pour copier/accès ?

    Oui.

    InformationsquelleAutor Mike Seymour
  2. 23

    Un std::array est une très fine wrapper autour d'un C-gamme de style, fondamentalement, la définition

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

    C'est un agrégation, et il vous permet de l'utiliser comme un type fondamental (c'est à dire que vous pouvez passer par valeur, d'attribuer etc, alors qu'un standard C tableau ne peut pas être attribué ou copiés directement à un autre tableau). Vous devriez jeter un oeil à un certain standard de mise en œuvre (saut à la définition de votre IDE préféré ou directement ouvrir <array>), c'est une pièce de la norme C++ de la bibliothèque qui est assez facile à lire et à comprendre.

    InformationsquelleAutor vsoftco
  3. 17

    std::array est conçu comme zéro-frais de wrapper pour C des tableaux, ce qui lui donne la valeur "normale" comme la sémantique de l'autre C++ conteneurs.

    Vous ne devriez pas remarquer une différence dans les performances d'exécution, pendant que vous profitez des fonctionnalités supplémentaires.

    À l'aide de std::array au lieu de int[] style de tableaux est une bonne idée si vous avez le C++11 ou boost à la main.

    InformationsquelleAutor Baum mit Augen
  4. 4

    std::array a de la valeur sémantique alors que les premières matrices de ne pas. Cela signifie que vous pouvez copier std::array et la traiter comme une valeur primitive. Vous pouvez les recevoir par valeur ou par référence comme arguments de la fonction et vous pouvez les renvoyer en valeur.

    Si vous n'avez jamais copier un std::array, alors il n'y a pas de différence de performances que les raw d'un tableau. Si vous avez besoin de faire des copies, puis std::array va faire la bonne chose et devrait encore donner le même rendement.

    InformationsquelleAutor b4hand
  5. 2

    Est-il plus performant ?

    Il doit être exactement le même. Par définition, c'est un simple agrégat contenant un tableau en tant que seul membre.

    La situation semble plus compliquée, comme std::array ne produisent pas toujours identiques assemblée de code par rapport à C-tableau en fonction de la plate-forme spécifique.

    J'ai testé cette situation spécifique sur le godbolt.org:

    #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 et Clang produire à l'identique de l'assemblée de code pour le C-tableau de la version et de
    le std::array version.

    MSVC et l'ICPC, cependant, produire différents assemblée de code pour chaque tableau version.
    (J'ai testé ICPC19 avec -Ofast et-Os; MSVC -Bœuf et Os)

    Je n'ai aucune idée de pourquoi c'est le cas (je voudrais en effet s'attendre exactement le même comportement de std::array et c-array).
    Peut-être il y a différentes stratégies d'optimisation des employés.

    Comme un petit extra:
    Il semble y avoir un bug dans la cisp avec

    #pragma simd

    pour la vectorisation lors de l'utilisation du c-tableau dans certaines situations
    (c-tableau de code génère une mauvaise sortie; std::array version fonctionne très bien).
    Malheureusement, je n'ai pas de travail exemple minimal pour que pourtant, depuis que j'ai découvert ce problème tout en optimisant l'un d'assez compliqué morceau de code.
    Je vais déposer un bug en rapport à intel quand je suis sûr que je n'ai pas seulement missunderstood quelque chose à propos de c_array/std::array et #pragma simd.

    • peut être considéré comme un bogue du compilateur?
    InformationsquelleAutor Henryk