Comment itérer à travers d'un tableau de structures

Dans mon application j'utilise un tableau de structures et j'ai besoin de parcourir le tableau. Quelle est la bonne façon de le faire? Comment puis-je vérifier si j'ai atteint la fin du tableau?

//structure
struct MyData {
  int count;
  char name[20];
  float average;
}

J'ai essayé de l'itération comme ça, mais mon application se bloque:

struct MyData data[2] = { {3, "name1", 1.0}, {5, "name2", 2.5} };
struct MyData* ptr = data;

while (*ptr != NULL) {
  //print the contents, works ok for 2 elements

  ptr++; //increment the pointer
}

OriginalL'auteur Dariusz | 2013-09-20

  1. 18

    Comment est un tableau de structures allouées

    Dans votre cas, le MyData[2] tableau ressemble à ceci en mémoire:

    | count | name | average | count | name | average |
^ -- your ptr points here

    C'est un seul espace continu avec une taille d' 3 * sizeof (struct MyData).

    Chaque fois que vous effectuez une ptr++ opération, le pointeur se déplace vers la structure suivante dans le tableau, ce qui signifie qu'il prend en compte la taille d'un seul struct MyData. 

    | count | name | average | count | name | average |
                         ^ -- after ptr++ your ptr points here

    Après l'autre ptr++ votre pointeur pointera à la mémoire juste après votre tableau.

    | count | name | average | count | name | average | 
                                                  ^ -- another ptr++ and your ptr points here

    Lorsque vous déréférencement de votre ptr pointeur vous accéder à la mémoire qui n'est pas encore utilisé, voire même alloués. C'est un comportement indéfini et que votre application se bloque.

    Comment itérer?

    Il y a plusieurs façons de le faire. Notez que tous les moyens sont applicables dans tous les cas.

    Simple pour

    Très souvent, nous ne savons simplement pas la taille du tableau. Nous pouvons alors il suffit d'utiliser un normal for boucle pour parcourir le contenu.

    int len = 2;
struct MyData data[len] = { {3, "name1", 1.0}, {5, "name2", 2.5} };
struct MyData* ptr = data;
for (int i=0; i<2; i++, ptr++ ) {
   //do your thing with the ptr
   //and note that ptr gets increased inside for
}

    Utilisant sizeof pour déterminer la longueur du tableau

    struct MyData data[2] = { {3, "name1", 1.0}, {5, "name2", 2.5} };
struct MyData* ptr = data;
struct MyData* endPtr = data + sizeof(data)/sizeof(data[0]);
while ( ptr < endPtr ){
   //do your thing with the ptr
   ptr++;
}

    La sizeof(data)/sizeof(data[0]) calcule la quantité d'éléments: obtient le total de la taille d'un tableau et le divise par la taille d'un seul élément.

    Cette méthode a ses inconvénients. Il ne peut pas être utilisé lorsque le tableau est déclaré comme un pointeur! Par exemple, lorsque nous passer le tableau en paramètre à une fonction habituellement, il est converti en un pointeur - et puis, nous ne pouvons pas déterminer la taille du tableau.

    OriginalL'auteur Dariusz

  2. 0

    Si vous n'avez pas de contrôle sur la taille de la table et peuvent même ne pas le demander, vous pourriez essayer de réorganiser votre code, pas l'utilisation d'un tableau de MyData, mais un tableau de pointeurs à MyData.
    Votre tableau doit alors être un emplacement pour mettre un garde avec NULL valeur.

    Votre itération ressemblera à celui que vous avez écrit comme un exemple.

    //N is the number of MyData instances you have
MyData* vData[N+1];
//vData[i] is filled, and vData[N] = NULL

//...

MyData* vPtr = vData[0];
while(vPtr) {
    //...
}

    Mais cela implique de changer le type de votre tableau de MyData[] à MyData*[]. Si vous ne pouvez pas, vous devez suivre Dariusz réponse.

    Eh oui, faute de frappe.... Désolé. Un tableau de pointeurs MyData 🙂 (edit : changé)
    Mais le while(vPtr) ne devrait pas vraiment être while(vPtr++) parce que c'est qui va provoquer une boucle infinie, aussi il devrait y avoir une vérification de limites à l'intérieur, car si la structure est complète, la condition ne sera jamais rencontrer une valeur NULL

    OriginalL'auteur Oragon Efreet