Trouver la taille d'un tableau String en C ++

Donc j'ai un tableau de chaînes de caractères. 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?

source d'informationauteur turnt

  1. 25

    Donné votre tableau de chaînes de caractères, vous pouvez certainement utiliser sizeof(array)/sizeof(array[0]) pour obtenir sa 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 tu veux dire en disant que la taille des éléments de varier. La taille des éléments d'un tableau est toujours connu au compilateur de temps, pas d'exceptions.

    Il existe cependant des situations où le ci-dessus 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ée à l'échec. Il peut paraître un peu bizarre au premier abord, mais la raison est en fait très simple: c'est la matrice de décomposition. 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, l' 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, qui est une chose totalement différente.

    Il y a généralement deux façons d'aller à ce sujet. La première consiste à ajouter un dernier élément de la matrice de sorte que la demande peut parcourir le tableau jusqu'à ce qu'il voit le dernier élément et de calculer la longueur du tableau. Les littéraux de chaîne sont l'exemple parfait de cela, 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;
}

    Le revers de la médaille est évidemment un besoin de parcourir le tableau pour déterminer sa longueur. La 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 de 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';
}

    Tous les ci-dessus s'applique à de simples tableaux qui sont intégrés dans la langue. C++, d'autre part, fournit un riche ensemble de niveau supérieur des conteneurs qui vous donne beaucoup de flexibilité. Ainsi, vous pouvez envisager d'utiliser l'un des conteneurs qui sont disponibles pour vous en tant que partie de C++ de la Bibliothèque Standard. Pour une liste de conteneurs standard, consultez — http://en.cppreference.com/w/cpp/container

    Espère que cela aide. Bonne Chance!

  2. 7

    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 dit, vous devez utiliser la STL containors. std::array, si vous voulez l'équivalent statique C tableau.

  3. 2

    Il est standart fonction dans stdlib bibliothèque:

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

    Obligatoire des conseils: utilisation 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 également parce que la taille des éléments ne varient pas - un std::string a taille constante, indépendamment de la chaîne qu'il détient.

  5. 1

    Vous pouvez toujours utiliser 

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

    C'est parce que sizeof(array) sera de retour à la somme des tailles des pointeurs correspondant à chaque chaîne. sizeof(array[0]) sera de retour de la taille du pointeur correspondant à la première chaîne. Ainsi, sizeof(array)/sizeof(array[0]) retourne le nombre de cordes.

  6. 1

    On peut trouver le nombre d'éléments d'un tableau en utilisant simplement la 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;

    De sortie:

    >>> Number of elements in array = 3

    Espère que cela vous aide.

  7. 0

    Est-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();
}
  8. 0

    Voici un autre exemple: 

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