Comment trouver la taille d'un tableau en C++

Pour trouver la longueur d’un tableau en C++, comptez ses éléments. La méthode adaptée dépend du type : utilisez sizeof pour un tableau natif dans la portée où il est déclaré, size() pour std::array ou std::vector, ou std::size pour appeler une fonction générique de la bibliothèque standard. Une boucle for fondée sur une plage peut compter les éléments d’une plage que vous pouvez déjà parcourir.

Compter les éléments d’un tableau en C++ avec une boucle for fondée sur une plage

Une boucle for fondée sur une plage parcourt chaque élément d’un tableau ou d’une autre plage itérable. Incrémentez un compteur à chaque passage pour compter les éléments :

#include <iostream>

int main() {
    int values[] = {10, 20, 30, 40, 50};
    int count = 0;

    for (int value : values) {
        (void)value;
        ++count;
    }

    std::cout << "Element count: " << count << '\n';
}

Cette boucle compte les éléments de la plage fournie par values. Elle ne permet pas de connaître la taille de l’allocation d’un pointeur brut ni celle d’un stockage alloué dynamiquement. Dans ces cas, conservez le nombre d’éléments séparément ou utilisez un conteneur qui fournit sa taille.

Trouver la longueur d’un tableau natif avec sizeof

Pour un tableau natif qui est toujours un tableau dans la portée courante, divisez sa taille totale en octets par la taille en octets d’un élément :

#include <iostream>
#include <cstddef>

int main() {
    int values[] = {1, 2, 3, 4, 5};
    const std::size_t count = sizeof(values) / sizeof(values[0]);

    std::cout << "Element count: " << count << '\n';
}

sizeof(values) donne le nombre d’octets occupés par le tableau entier, tandis que sizeof(values[0]) donne le nombre d’octets occupés par un élément. Leur quotient correspond au nombre d’éléments. L’exemple inclut <cstddef> pour utiliser std::size_t.

Ce calcul ne donne plus le nombre d’éléments lorsque le tableau est passé à une fonction. Un paramètre déclaré sous la forme int values[] est ajusté en int* values ; dans la fonction, sizeof(values) mesure le pointeur, et non le tableau d’origine. Le quotient obtenu dépend de l’implémentation, notamment de la taille des pointeurs et des éléments : ce n’est donc pas un décompte portable. Passez le nombre d’éléments séparément ou acceptez un conteneur en paramètre.

Utiliser size() avec std::array et std::vector

std::array et std::vector possèdent toutes deux une fonction membre size() qui renvoie le nombre d’éléments. std::array représente un tableau de taille fixe, tandis que la taille d’un vecteur peut changer lorsque des éléments sont ajoutés ou supprimés.

#include <array>
#include <iostream>
#include <vector>

int main() {
    std::array<int, 3> fixed{4, 8, 12};
    std::vector<int> resizable{5, 10, 15, 20};

    std::cout << "std::array: " << fixed.size() << '\n';
    std::cout << "std::vector: " << resizable.size() << '\n';
}

Utilisez la fonction membre du conteneur concerné. std::array::size() renvoie son nombre fixe d’éléments ; std::vector::size() renvoie le nombre actuel d’éléments du vecteur.

Trouver la longueur d’un tableau avec std::end() et std::begin()

Pour un tableau natif, std::begin désigne son premier élément et std::end la position juste après le dernier. La soustraction de ces deux pointeurs donne le nombre d’éléments qui les séparent. Incluez <iterator> pour utiliser ces fonctions.

#include <iostream>
#include <iterator>

int main() {
    int values[] = {2, 4, 6, 8};
    const auto count = std::end(values) - std::begin(values);

    std::cout << "Element count: " << count << '\n';
}

La soustraction est valide, car les deux pointeurs désignent des éléments du même tableau ou sa position juste après le dernier élément. Cette méthode est utile avec un tableau natif ; pour std::array ou std::vector, la fonction membre size() est généralement plus claire.

Obtenir le nombre d’éléments avec std::size()

std::size est une fonction de la bibliothèque standard qui renvoie le nombre d’éléments. Elle fonctionne avec les tableaux natifs et avec des conteneurs standard tels que std::array et std::vector. Incluez <iterator> pour l’utiliser.

#include <array>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
    int built_in[] = {3, 6, 9};
    std::array<int, 2> fixed{7, 14};
    std::vector<int> resizable{11, 22, 33, 44};

    std::cout << "Built-in array: " << std::size(built_in) << '\n';
    std::cout << "std::array: " << std::size(fixed) << '\n';
    std::cout << "std::vector: " << std::size(resizable) << '\n';
}

Contrairement à la fonction membre size(), std::size(container) s’utilise comme une fonction libre. Elle fournit une même syntaxe pour les types de tableaux et de conteneurs pris en charge, tout en laissant disponible la fonction membre size() propre à chaque conteneur.

Choisir la méthode adaptée au type de tableau

• Pour un tableau natif dans la portée où il est déclaré, utilisez sizeof(array) / sizeof(array[0]) ou std::size(array).
• Pour std::array et std::vector, privilégiez leur fonction membre size(). Utilisez std::size(container) si une fonction commune est pratique.
• Utilisez std::end(array) - std::begin(array) lorsque la soustraction d’itérateurs convient au code environnant.
• Utilisez une boucle for fondée sur une plage si vous souhaitez compter les éléments en les parcourant.
• Pour un pointeur ou un tableau alloué dynamiquement, conservez le nombre d’éléments séparément ou utilisez un conteneur. Le pointeur seul ne contient pas le nombre d’éléments alloués.

La distinction essentielle est celle entre la taille du stockage en octets et le nombre d’éléments. sizeof mesure des octets ; ne divisez par la taille en octets d’un élément que tant que l’expression désigne le tableau natif complet. Les fonctions de taille des conteneurs et la soustraction d’itérateurs donnent directement un nombre d’éléments.