Trouver la taille d'un tableau de chaînes en C++
J'ai donc un tableau de cordes. Voici un exemple:
string array[] = {"Example", "Example2", "Example3"};
Est-il possible que je peux 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 varier. Est-il une autre voie?
9 réponses
étant donné votre tableau de chaînes, vous pouvez très certainement utiliser sizeof(array)/sizeof(array[0]) pour avoir la taille et le programme suivant fonctionne très bien:
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);
}
il n'est pas clair ce que vous voulez dire en disant que la taille des éléments varie. La taille des éléments de n'importe quel tableau est toujours connue au moment du compilateur, sans exception.
il y a, cependant, des situations où ce qui précède ne fonctionnera pas. Considérons 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. Il pourrait regardez un peu bizarre au début, mais la raison pour cela est en fait très simple - cela s'appelle la décomposition de tableau. Cela signifie que chaque fois que vous passer un tableau à une fonction, son type est automatiquement pourri à celle d'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 sizeof opérateur renvoie la taille totale d'un tableau, dans le deuxième exemple, il retourne la taille d'un pointeur vers ce tableau, ce qui est totalement différent chose.
il y a habituellement deux façons de s'y prendre. La première est d'ajouter un "dernier" élément spécial du tableau de sorte que l'application puisse parcourir le tableau jusqu'à ce qu'elle voit le dernier élément et calcule la longueur du tableau. Les caractères littéraux des chaînes de caractères en sont l'exemple parfait: chaque chaîne de caractères 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 un besoin de parcourir le tableau pour déterminer sa longueur. Le deuxième façon à toujours porter 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 qui sont intégrés dans le langage. C++, d'un autre côté, fournit un ensemble riche de conteneurs de haut niveau qui vous donnent beaucoup de flexibilité. Vous pourriez donc envisager d'utiliser l'un des conteneurs qui sont à votre disposition dans le cadre de la bibliothèque Standard C++. Pour un liste de conteneurs standard, consultez - http://en.cppreference.com/w/cpp/container
j'Espère que ça aide. Bonne Chance!
Vous pouvez utiliser une fonction de modèle réalisé que :
#include<cstdlib>
template<class T, std::size_t n>
constexpr std::size_t size(T (&)[n])
{ return n; }
et comme Luchian Grigore l'a dit, vous devriez utiliser des containeurs STL. std::array, si vous voulez l'équivalent statique C tableau.
Il y a une fonction standart dans stdlib bibliothèque:
#include <stdlib.h>
static const char * const strings[] = {"str1", "str2", "str3"};
const int stringCount = _countof(strings);
Vous pouvez toujours utiliser
int numberofelements = sizeof(array)/sizeof(array[0]);
C'est parce que sizeof(array) renvoie la somme des tailles des pointeurs correspondant à chaque chaîne. sizeof(array[0]) renvoie la taille du pointeur correspondant à la première chaîne. Ainsi,sizeof(array)/sizeof(array[0]) renvoie le nombre de chaînes.
On peut trouver le nombre d'éléments d'un tableau en utilisant simplement les size() fonction.
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
Espérons qu'il vous aide.
Est-ce ce que vous recherchez?
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();
}
avis obligatoire:utiliser std::vector<std::string>.
Une fonction comme ceci peut aider:
template<typename T, int sz>
int getSize(T (&) [sz])
{
return sz;
}
votre méthode fonctionne aussi parce que la taille des éléments ne varie pas - a std::string a taille constante, indépendamment de la chaîne qu'il détient.
Voici un autre exemple:
string array[] = {"Example", "Example2", "Example3"};
int numberofelements = 0; for(auto c: array) { numberofelements++; };
// now numberofelements will contain 3
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 la première: https://aticleworld.com/how-to-find-sizeof-array-in-cc-without-using-sizeof/