web-dev-qa-db-fra.com

Recherche de la taille d'un tableau String en C++

J'ai donc un tableau de chaînes. Voici un exemple:

string array[] = {"Example", "Example2", "Example3"};

Est-il possible de trouver le nombre d'éléments dans un tableau comme celui ci-dessus? Je ne peux pas utiliser cette méthode:

int numberofelements = sizeof(array)/sizeof(array[0]);

C'est parce que la taille des éléments varie. Y a-t-il un autre moyen?

c++carrays
19
turnt

Étant donné votre gamme de chaînes, vous pouvez certainement utiliser sizeof(array)/sizeof(array[0]) pour obtenir sa taille. Le programme suivant fonctionne parfaitement:

int main()
{
    std::string array[] = { "S1", "S2", "S3" };
    std::cout << "A number of elements in array is: "
              << sizeof(array)/sizeof(array[0]) << '\n';
    foo(array);
}

Vous ne comprenez pas ce que vous entendez par dire que la taille des éléments varie. La taille des éléments de tout tableau est toujours connue au moment du compilateur, sans exception.

Cependant, il existe des situations où ce qui précède ne fonctionnera pas. Prenons l'exemple suivant:

void foo(std::string array[])
{
    std::cout << "A number of elements in array is: "
              << sizeof(array)/sizeof(array[0]) << '\n';
}

Le code ci-dessus est voué à l'échec. Cela peut paraître un peu bizarre au début, mais la raison en est très simple: on parle de matrice en décomposition. Cela signifie que chaque fois que vous passez un tableau à une fonction, son type se décompose automatiquement en un pointeur. Donc, la fonction ci-dessus est en fait l'équivalent de ceci:

void foo(std::string *array)
{
}

Et si, dans le premier exemple, l'opérateur sizeof renvoie la taille totale d'un tableau, dans le deuxième exemple, il renvoie la taille d'un pointeur sur ce tableau, ce qui est totalement différent.

Il y a généralement deux manières de s'y prendre. La première consiste à ajouter un «dernier» élément spécial du tableau afin que l’application puisse parcourir le tableau jusqu’à ce qu’il voie le dernier élément et calcule la longueur de celui-ci. Les littéraux de chaîne en sont l'exemple parfait: chaque littéral de chaîne se termine par «\ 0» et vous pouvez toujours calculer sa longueur. Voici un exemple:

static void foo(const std::string *array)
{
    size_t i = 0;
    while (!array[i].empty())
        ++i;
    std::cout << "Array length is: " << i << std::endl;
}

L'inconvénient est évidemment la nécessité de parcourir le tableau pour en déterminer la longueur. La deuxième façon de toujours porter la longueur du tableau, par exemple:

static void foo(const std::string *array, size_t length)
{
    // ...
}

void bar()
{
    std::string array[] = { "S1", "S2", "S3" };
    foo(array, sizeof(array)/sizeof(array[0]));
}

En C++, vous pouvez utiliser un modèle pour déduire la longueur du tableau, par exemple:

template <size_t array_length>
static void foo(const std::string (&array)[array_length])
{
    std::cout << "A number of elements in template array is: "
              << array_length << '\n';
}

Tout ce qui précède s'applique aux tableaux simples intégrés dans le langage. C++, en revanche, fournit un riche ensemble de conteneurs de niveau supérieur offrant une grande flexibilité. Donc, vous voudrez peut-être envisager d'utiliser l'un des conteneurs disponibles dans le cadre de la bibliothèque standard C++. Pour obtenir une liste des conteneurs standard, voir - http://fr.cppreference.com/w/cpp/container

J'espère que ça aide. Bonne chance!

29
user405725

Vous pouvez utiliser une fonction de modèle pour atteindre cet objectif:

#include<cstdlib>

template<class T, std::size_t n>
constexpr std::size_t size(T (&)[n])
{ return n; }

Et comme le dit Luchian Grigore, vous devriez utiliser des conteneurs STL. std :: array si vous voulez un équivalent au tableau C statique.

7
Florian Blanchet

Vous pouvez toujours utiliser 

int numberofelements = sizeof(array)/sizeof(array[0]);

En effet, sizeof(array) renverra la somme des tailles de pointeurs correspondant à chaque chaîne. sizeof(array[0]) retournera la taille du pointeur correspondant à la première chaîne. Ainsi, sizeof(array)/sizeof(array[0]) renvoie le nombre de chaînes.

2
deerishi

Il y a une fonction standard dans stdlib library:

#include <stdlib.h>
static const char * const strings[] = {"str1", "str2", "str3"};
const int stringCount = _countof(strings);
2
vitperov

Nous pouvons trouver le nombre d'éléments d'un tableau en utilisant simplement la fonction size().

Exemple de code: 

string exampleArray[] = { "Example", "Example2", "Example3" };
    int size_of_array = size(exampleArray);

cout << "Number of elements in array = " << size_of_array << endl;

Sortie: 

>>> Number of elements in array = 3

J'espère que ça vous aide.

1
Arslan Ahmad

Est-ce ce que vous cherchez?

string array[] = {"Example", "Example2", "Example3"};
int num_chars = 0;
int num_strings = sizeof(array)/sizeof(array[0]);
for (int i = 0; i < num_strings; i++) {
    num_chars += array[i].size();
}
0
Mr Fooz

Conseil obligatoire: utilisez std::vector<std::string>.

Une fonction comme celle-ci peut aider:

template<typename T, int sz>
int getSize(T (&) [sz])
{
    return sz;
}

Votre méthode fonctionne également parce que la taille des éléments ne varie pas - un std::string a une taille constante, quelle que soit la chaîne qu'il contient.

0
Luchian Grigore
string s[] = {"Apple","banana","cherry","berry","kiwi"};
int size = *(&s+1)-s;  
// OR
int size = sizeof(s)/sizeof(s[0]);

pour plus d’informations sur le premier: https://aticleworld.com/how-to-find-sizeof-array-in-cc-without-using-sizeof/

0
Pygirl

Voici un exemple différent: 

string array[] = {"Example", "Example2", "Example3"};
int numberofelements = 0; for(auto c: array) { numberofelements++; };
// now numberofelements will contain 3
0
serup