Classes de conteneurs C++<array>

La norme C++11 a introduit<array>Le fichier d'en-tête fournit un conteneur de tableau de taille fixe, qui offre une meilleure sécurité de type et de meilleures caractéristiques de gestion de la mémoire par rapport aux tableaux en C.

std::arrayIl s'agit d'une classe modèle de la bibliothèque standard C++, définie dans<array>Dans le fichier d'en-tête.std::arrayLa classe modèle fournit un tableau de taille fixe dont la taille est déterminée à la compilation et ne peut pas être modifiée dynamiquement.

Syntaxe

std::arrayLa syntaxe de base est la suivante :

#include <array>

std::array<T, N> array_name;
  • Test le type des éléments du tableau.
  • NIl s'agit de la taille du tableau et elle doit être un entier non négatif.

Déclaration et initialisation

<array>La taille doit être déterminée à la compilation et ne peut pas être modifiée dynamiquement. Exemple d'utilisation :

#include <iostream>
#include <array>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5}; // 声明一个定长为5的int数组
    return 0;
}

Fonctionnalités

  • Sûreté de typage：std::arrayImpose la vérification des types, évitant les problèmes de sûreté de typage des tableaux du langage C.
  • Taille fixe: La taille du tableau est déterminée à la compilation et ne peut pas être modifiée à l'exécution.
  • Mémoire contiguë：std::arrayLes éléments sont stockés de manière contiguë en mémoire, ce qui permet un accès efficace aux éléments.
  • Conteneur standard：std::arrayfournitstd::vectorDes interfaces similaires, telles quesize(), at(), front(), back()etc.

Exemple

Voici un exemple utilisantstd::arrayUn exemple simple, incluant les résultats de sortie.

Exemple

#include <iostream>
#include <array>

int main() {
    // Créer un std::array contenant 5 entiers
    std::array<int, 5> myArray = {1, 2, 3, 4, 5};

    // Utiliser une boucle for basée sur une plage pour parcourir le tableau
    for (const auto& value : myArray) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    // Accéder aux éléments du tableau à l'aide de l'index
    std::cout << "Élément à l'index 2: " << myArray.at(2) << std::endl;

    // Obtenir la taille du tableau
    std::cout << "Taille du tableau: " << myArray.size() << std::endl;

    // Modifier les éléments du tableau
    myArray[3] = 10;

    // Parcourir à nouveau le tableau pour afficher les éléments modifiés
    for (const auto& value : myArray) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}

Sortie :

1 2 3 4 5 
Element at index 2: 3
Array size: 5
1 2 3 10 5

Fonctions membres courantes

Les suivantes sont<array>Quelques fonctions membres couramment utilisées dans :

Fonction Description
at(size_t pos) Renvoie l'élément à la position spécifiée, avec vérification des limites
operator[] Renvoie l'élément à la position spécifiée, sans vérification des limites
front() Renvoie le premier élément du tableau
back() Renvoie le dernier élément du tableau
data() Renvoie un pointeur vers les données du tableau
size() Renvoie la taille du tableau (fixe et inchangée)
fill(const T& value) Affecte la valeur spécifiée à tous les éléments du tableau
swap(array& other) Échange le contenu de deux tableaux
begin() / end() Renvoie les itérateurs begin/end du tableau

Exemple

1. Opérations de base

Exemple

#include <iostream>
#include <array>

int main() {
    std::array<int, 5> arr = {10, 20, 30, 40, 50};

    std::cout << "Éléments du tableau : ";
    for (int i = 0; i < arr.size(); ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // Obtenir les premier et dernier éléments
    std::cout << "Premier élément : " << arr.front() << std::endl;
    std::cout << "Dernier élément : " << arr.back() << std::endl;

    return 0;
}

Utilisation de at et de la vérification des limites

Exemple

#include <iostream>
#include <array>

int main() {
    std::array<int, 3> arr = {1, 2, 3};

    try {
        std::cout << arr.at(2) << std::endl;  // Sortie normale
        std::cout << arr.at(5) << std::endl;  // Hors limites, lève une exception
    } catch (const std::out_of_range& e) {
        std::cout << "Exception : " << e.what() << std::endl;
    }

    return 0;
}

3. Utilisation de fill pour remplir les éléments

Exemple

#include <iostream>
#include <array>

int main() {
    std::array<int, 5> arr;
    arr.fill(100);  // Définir tous les éléments à 100

    std::cout << "Tableau rempli : ";
    for (const auto& elem : arr) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

4. Échange de tableaux

Exemple

#include <iostream>
#include <array>

int main() {
    std::array<int, 3> arr1 = {1, 2, 3};
    std::array<int, 3> arr2 = {4, 5, 6};

    arr1.swap(arr2);

    std::cout << "Tableau 1 : ";
    for (const auto& elem : arr1) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    std::cout << "Tableau 2 : ";
    for (const auto& elem : arr2) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

Comparaison avec d'autres types de tableaux

Fonctionnalitésstd::arrayTableaux de style Cstd::vector
SizeFixe à la compilationFixe à la compilationModifiable dynamiquement
Vérification des limitesat()Fournit une vérification des limitesAucuneat()Fournit une vérification des limites
Gestion de la mémoireAllocation sur la pileAllocation sur la pileAllocation sur le tas
PerformanceEfficaceEfficacePlus faible (alloué dynamiquement)
interfacePrend en charge l'interface standard STLNe prend pas en charge l'interface standard STLPrend en charge l'interface standard STL

std::arrayC'est un conteneur très utile dans la bibliothèque standard C++, offrant des tableaux de taille fixe avec les avantages de la sécurité de type et de la gestion de la mémoire. À travers les exemples ci-dessus, nous pouvons voir comment créer, accéder et modifierstd::arrayles éléments. Pour les scénarios qui nécessitent des tableaux de taille fixe,std::arrayest un très bon choix.

autres extensions