std:: array

std::array est un conteneur qui encapsule des tableaux de taille fixe.

Ce conteneur est un type agrégé ayant les mêmes sémantiques qu'une structure contenant un tableau de style C T [ N ] comme seul membre de données non statique. Contrairement à un tableau de style C, il ne se dégrade pas en T * automatiquement. En tant que type agrégé, il peut être initialisé avec une initialisation agrégée avec au plus N initialiseurs convertibles en T : std :: array < int , 3 > a = { 1 , 2 , 3 } ; .

La structure combine les performances et l'accessibilité d'un tableau de style C avec les avantages d'un conteneur standard, comme connaître sa propre taille, prendre en charge l'assignation, les itérateurs à accès aléatoire, etc.

std::array satisfait aux exigences de Container et ReversibleContainer sauf qu'un tableau construit par défaut n'est pas vide et que la complexité d'échange est linéaire, satisfait aux exigences de ContiguousContainer , (depuis C++17) et satisfait partiellement aux exigences de SequenceContainer .

Il existe un cas particulier pour un tableau de longueur nulle ( N == 0 ). Dans ce cas, array. begin ( ) == array. end ( ) , ce qui correspond à une valeur unique. L'effet de l'appel à front ( ) ou back ( ) sur un tableau de taille zéro est indéfini.

Un tableau peut également être utilisé comme un tuple de N éléments du même type.

Invalidation des itérateurs

En règle générale, les itérateurs vers un tableau ne sont jamais invalidés pendant la durée de vie du tableau. Il convient toutefois de noter que lors d'un swap , l'itérateur continuera de pointer vers le même élément du tableau, et changera donc de valeur.

Paramètres du modèle

Types membres

Fonctions membres

Fonctions non membres

Classes d'assistance

Exemple

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    // La construction utilise l'initialisation par agrégat
    std::array<int, 3> a1{{1, 2, 3}}; // Doubles accolades requises en C++11 avant
                                      // la révision CWG 1270 (non nécessaires en C++11
                                      // après la révision et en C++14 et au-delà)
    std::array<int, 3> a2 = {1, 2, 3}; // Doubles accolades jamais requises après =
    // Les opérations sur les conteneurs sont supportées
    std::sort(a1.begin(), a1.end());
    std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    // La boucle for à portée est supportée
    std::array<std::string, 2> a3{"E", "\u018E"};
    for (const auto& s : a3)
        std::cout << s << ' ';
    std::cout << '\n';
    // Guide de déduction pour la création de tableau (depuis C++17)
    [[maybe_unused]] std::array a4{3.0, 1.0, 4.0}; // std::array<double, 3>
    // Le comportement des éléments non spécifiés est le même qu'avec les tableaux natifs
    [[maybe_unused]] std::array<int, 2> a5; // Pas d'initialisation par liste, a5[0] et a5[1]
                                            // sont initialisés par défaut
    [[maybe_unused]] std::array<int, 2> a6{}; // Initialisation par liste, les deux éléments sont
                                              // initialisés par valeur, a6[0] = a6[1] = 0
    [[maybe_unused]] std::array<int, 2> a7{1}; // Initialisation par liste, l'élément non spécifié est
                                               // initialisé par valeur, a7[0] = 1, a7[1] = 0
}

3 2 1
E Ǝ

Voir aussi