Comment déterminer la taille d'un tableau de chaînes en C ++?

Je suis en train de tout simplement imprimer les valeurs contenues dans un tableau.

J'ai un tableau de chaînes de caractères appelé "résultat". Je ne sais pas exactement comment elle est grande parce qu'elle a été généré automatiquement.

De ce que j'ai lu, vous pouvez déterminer la taille d'un tableau en faisant ceci:

sizeof(result)/sizeof(result[0])

Est-ce correct? Parce que pour mon programme, sizeof(résultat) = 16 et sizeof(result[0]) = 16, de sorte que le code serait me dire que mon tableau est de taille 1.

Mais cela ne semble pas correct, parce que si je imprimer manuellement les valeurs de tableau comme ceci:

std::cout << result[0] << "\n";
std::cout << result[1] << "\n";
std::cout << result[2] << "\n";
std::cout << result[3] << "\n";
etc...

...puis-je voir les valeurs résultantes je suis à la recherche pour. Le tableau est à la hausse, de+ de 100 valeurs de longueur/taille.

Il semble que ce devrait être très simple pour déterminer la taille et de la longueur d'un tableau... alors j'espère que je suis juste en manque de quelque chose ici.

Je suis un peu de C++ newb de sorte que toute aide serait appréciée.

source d'informationauteur Jake Wilson

  1. 10

    Vous ne pouvez pas déterminer la taille d'un tableau dynamiquement en C++. Vous devez passer autour de la taille comme un paramètre.

    Comme une note de côté, à l'aide d'une Bibliothèque Standard du conteneur (par exemple, le vecteur) permet de surmonter cela.

    Dans votre sizeof exemple, sizeof(result) demande la taille d'un pointeur (vraisemblablement d'un std::string). C'est parce que le tableau réel de type "désintègre" à un pointeur de type de l'élément lorsqu'il est passé à une fonction (même si la fonction est déclarée à prendre un type tableau). Le sizeof(result[0]) retourne la taille du premier élément de votre tableau, qui, coïncidence, se trouve également à 16 octets. Il semble que les pointeurs sont de 16 octets (128 bits) sur votre plate-forme.

    Rappelez-vous que sizeof est toujours évaluée au moment de la compilation en C++, jamais au moment de l'exécution.

  2. 8

    Comme un commentaire, il y a de meilleures façons de vérifier la taille d'un tableau (pour le cas où le tableau est dans le champ d'application et a ne pas tomber dans un pointeur) qui sont typesafe:

    //simple: runtime result
template <typename T, std::size_t N>
inline std::size_t sizeof_array( T (&)[N] ) {
   return N;
}

//complex: compile time constant
template <typename T, std::size_t N>
char (&static_sizeof_array( T(&)[N] ))[N];   //declared, not defined
#defined SIZEOF_ARRAY( x ) sizeof(static_sizeof_array(x))

    Dans les deux cas, le compilateur détectera si vous essayez de passer un pointeur (tableau dynamique ou pourri tableau):

    void f( int array[] ) { //really: void f( int *array )
{
//  sizeof_array(array);              //compile time error
//  int another[SIZEOF_ARRAY(array)]; //compile time error
}
int main() {
   int array[] = { 1, 2, 3 };
   std::cout << sizeof_array(array) << std::endl; //prints 3
   int another_array[ SIZEOF_ARRAY(array) ];
   std::cout << sizeof_array(another_array) << std::endl; //3 again
}
  3. 3

    Si ce que vous avez est un "vrai" tableau, alors le sizeof(x)/sizeof(x[0]) astuce fonctionne. Si, toutefois, ce que vous avez est vraiment un pointeur (par exemple, quelque chose renvoyée par une fonction), alors que l'astuce ne fonctionne pas -- vous finirez par la division de la taille d'un pointeur par le sizeof un pointeur. Ils sont pointeurs de types différents, mais sur un système typique, tous les pointeurs sont de la même taille, de sorte que vous allez obtenir un. Même lorsque les pointeurs sont de tailles différentes, le résultat reste n'aurez rien à voir avec le nombre de chaînes que vous avez.

  4. 1

    Mieux utiliser std::vector<std::string> au lieu d'un raw de tableau. Ensuite, vous n'avez pas à gérer manuellement les tableaux en mémoire et vous pouvez utiliser le size() méthode si vous souhaitez connaître le nombre d'éléments.

    Si vous utilisez un allouée dynamiquement brutes tableau vous êtes attendus pour garder une trace de sa taille vous-même, la taille ne peut pas être obtenu à partir de la matrice. Le meilleur de l'enregistrer dans une variable supplémentaire.

  5. 1

    La sizeof(tableau)/sizeof(element) de longueur fixe-tableau de longueur fixe-tableaux (pas de pointeurs).
    Comme un tableau de chaines de caractères, le plus souvent utiliser un (fixe-longueur-)tableau de pointeurs-à-divers-(fixe)de la longueur des chaînes si cette astuce ne fonctionne pas.
    sizeof() est utilisé pour les objets dont la taille est connue à la compilation. Il n'est pas applicable pour les données allouées dynamiquement.

    Lorsqu'un objet contient des pointeurs comme dans le cas d'un tableau de chaînes de caractères,
    sizeof() retourne la taille du plus haut niveau (de taille fixe) de la structure. Souvent, c'est juste la taille d'un seul pointeur. Il ne comprend pas la taille des données allouées pointé par les pointeurs. Parce que les données n'est d'ailleurs pas partie de l'objet principal, il est en effet de séparer un ou plusieurs objets (nous avons agrégation ici au lieu de composition, voir http://en.wikipedia.org/wiki/Object_composition).

    En C++ à l'aide de vecteurs est très pratique pour vos besoins. D'autres conteneurs standard peut être utilisé.
    longueur() et() sont des synonymes, voir http://www.cplusplus.com/reference/string/string/size/)

    P. S. Veuillez noter que pour les std::string s objet sizeof(s) est une constante indépendante de la (variable) longueur de la chaîne retournée par s.longueur(). Le réel alloué taille de la mémoire est renvoyé par s.capacité() et pourrait être plus grande que la longueur().

    Exemple à l'aide de tableau de vecteurs:

    #include <iostream>
#include <string>
#include <vector>

using namespace std;

int main()
{
    string s = "01234";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    s += "56789012345";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    vector<string>vs={"12","23","345","456","567","67888","7899999999","8","9876543210"};

    cout << "vs[" << vs.size() << "]={";
    size_t sz=0;
    for (size_t index=0; index<vs.size(); index++)
    {
        sz+=vs[index].size();
        if (index>0)
            cout << ",";
        cout << "\"" << vs[index] << "\":" << vs[index].size();
    }
    cout << "}:" << sz << endl;
    cout << "sizeof(vs)=" << sizeof(vs) << " (implementation dependent)" << endl;

    return 0;
}

    Résultat:

    s[5]="01234"
sizeof(s)=8 (implementation dependent)

s[16]="0123456789012345"
sizeof(s)=8 (implementation dependent)

vs[9]={"12":2,"23":2,"345":3,"456":3,"567":3,"67888":5,"7899999999":10,"8":1,"9876543210":10}:39
sizeof(vs)=24 (implementation dependent)
  6. 1
    template< class T, size_t N >
std::size_t Length(const T(&)[N])
{
    return N;
};

std::cout << Length(another_array) << std::endl;
  7. 0

    Dans la Chaîne de vecteur d'utiliser la méthode size ()

  8. 0

    Quelque chose d'être conscient de: le texte peut être représenté de différentes méthodes. Un tableau de texte peuvent également être représentées dans les différentes méthodes.

    Tableau de pointeurs C-Style chaînes

    Une méthode commune est d'avoir un tableau de pointeurs char. Le problème est que la taille du tableau ne représente pas la taille de l'ensemble du texte. Aussi, la propriété des données ou pointeur doit également être établi, le texte peut être supprimer (et le destinataire de l'appel peut supprimer le texte ou l'appelant?). Parce que c'est un tableau, la taille du tableau doit toujours accompagner la matrice de tous les paramètres (sauf si le tableau est toujours une taille fixe).

    Tableau de char - paniers texte

    Une autre méthode est de passer un tableau de char et les chaînes contigus dans le tableau. Une chaîne de caractères qui suit la cessation char de la précédente. Avec ce tableau, la taille totale de toutes les chaînes de caractères est représentée, aucune perte d'espace. Encore une fois, avec les tableaux, la taille du tableau doit accompagner le tableau lorsqu'il est passé autour de.

    Tableau de std::string

    En C++, le texte peut être représenté à l'aide de std::string. Dans ce cas, le tableau représente la quantité de chaînes de caractères (semblable à la matrice de C-Strings ci-dessus). Pour obtenir la taille totale de toutes les chaînes, on doit résumer la taille de chaque chaîne. Puisque c'est un tableau, la taille du tableau doivent être transmises également des.

    Résumé

    Au cours de l'exécution de la matrice de taille doivent accompagner la matrice lorsque le tableau est passé autour. sizeof est traité au moment de la compilation. Une structure plus simple est std::vectorqui gère la taille et l'allocation de mémoire dynamique.