web-dev-qa-db-fra.com

C: trouver le nombre d'éléments dans un tableau []

En C: Comment trouvez-vous le nombre d'éléments dans un tableau de structures, après l'avoir envoyé à une fonction?

int main(void) {
  myStruct array[] = { struct1, struct2, struct3, struct4, struct5, struct6 };
  printf("%d\n", sizeof(array));
  printf("%d\n", sizeof(array[0]));
  f(array);
}
void f(myStruct* array) {
  printf("%d\n", sizeof(array));
  printf("%d\n", sizeof(array[0]));
}

Pour une raison quelconque, printf dans main affiche des résultats différents de ceux de printf dans f. Mon besoin est de savoir combien d'éléments sont dans le tableau.

carrayspointers
13
Lavi Avigdor

Tu ne peux pas.

Vous devez passer la taille à la fonction, par exemple:

void f(myStruct* array, size_t siz);

Notez également que dans f tableau est un pointeur, alors que dans main il s’agit d’un tableau. Les tableaux et les pointeurs sont des choses différentes.

19
pmg

Dans f array est un pointeur, dans main array est un tableau.

10
PaulJWilliams

vous devez terminer le tableau avec une valeur spéciale et en fonction appelée, vous devez compter jusqu'à cette valeur; ainsi, strlen () fonctionne-t-il jusqu'à la valeur NULL '\ 0'.

1
bkilinc

Notez que dans main (), array se réfère au tableau actuel et donc sizeof () donne la réponse requise.

Mais lorsque vous le transmettez en tant que paramètre de fonction, vous transmettez en réalité l'adresse du premier élément du tableau qui est stocké dans la variable de pointeur 'tableau'.
Alors maintenant, sizeof () donne la taille de la variable de pointeur, raison pour laquelle elle diffère de la réponse réelle.

La solution possible peut être de

1.Déclarez le tableau globalement

2.Passez la taille du tableau comme paramètre de fonction J'espère que cela aidera!

1
Apaar

Vous devez transmettre ces données en tant que paramètre distinct à la fonction. En C et C++, dès qu'un tableau est passé à une fonction, le tableau dégénère en un pointeur. Les pointeurs n'ont aucune idée du nombre d'éléments contenus dans le tableau indiqué.

Une méthode courante pour obtenir la taille consiste à déclarer le tableau, puis à obtenir immédiatement le nombre d'éléments de celui-ci en divisant la taille totale par la taille d'un élément. Comme ça:

struct my_struct my_struct_array[] = {
 {"data", 1, "this is data"},
 {"more data", 2, "this is more data"},
 {"yet more", 0, "and again more data"}
};
const size_t my_struct_array_count = sizeof(my_struct_array)/sizeof(my_struct_array[0]);
1
Zan Lynx

Dans le code ci-dessus, la fonction f() n'a aucun moyen de savoir combien d'éléments se trouvaient dans votre tableau d'origine. C'est une caractéristique de la langue et il n'y a aucun moyen de la contourner. Vous devrez passer la longueur.

1
Jean-Marc Valin

Comme l'indique la référence C , vous ne pouvez le faire que si le dernier élément est unique ou si vous transmettez un nombre d'éléments de tableau à la fonction.

1
David Harris

Vous pouvez utiliser un format pour votre tableau. J'utilise des éléments de chaîne, cela devrait fonctionner pour struct.

#define NULL ""
#define SAME 0

static char *check[] = {
      "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
      "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
      "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
      "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
      "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
      "lzo", "cts", "zlib", NULL
 }; // 38 items, excluding NULL

en main ()

char **algo = check;
int numberOfAlgo = 0;


while (SAME != strcmp(algo[numberOfAlgo], NULL)) {
    printf("Algo: %s \n", algo[numberOfAlgo++]);
}

printf("There are %d algos in the check list. \n", numberOfAlgo);

Vous devriez obtenir le résultat:

Algo: des 
   :
   :
Algo: zlib 

There are 38 algos in the check list.

Sinon, si vous ne voulez pas utiliser le NUL , faites ceci à la place:

numberOfAlgo = 0;

while (*algo) {
    printf("Algo: %s \n", *algo);
    algo++;         // go to the next item
    numberOfAlgo++; // count the item
}

printf("There are %d algos in the check list. \n", numberOfAlgo);
0
Ursa Major

Par exemple pour votre solution:

Donné

struct contain {
char* a;        //
int allowed;    //

struct suit {
   struct t {
          char* option;
          int count;
   } t;

   struct inner {
          char* option;
          int count;
   } inner;
} suit;
};

// par exemple. initialisé

     struct contain structArrayToBeCheck[] = {
    {
        .a = "John",
        .allowed = 1,

        .suit = {
            .t = {
                .option = "ON",
                .count = 7
            },

            .inner = {
                .option = "OFF",
                .count = 7
            }
        }
    },
    {
        .a = "John",
        .allowed = 1,

        .suit = {
            .t = {
                .option = "ON",
                .count = 7
            },

            .inner = {
                .option = "OFF",
                .count = 7
            }
        }
    },
    {
        .a = "John",
        .allowed = 1,

        .suit = {
            .t = {
                .option = "ON",
                .count = 7
            },

            .inner = {
                .option = "OFF",
                .count = 7
            }
        }
    },
    {
        .a = "John",
        .allowed = 1,

        .suit = {
            .t = {
                .option = "ON",
                .count = 7
            },

            .inner = {
                .option = "OFF",
                .count = 7
            }
        }
    }

};

en main ()

printf("Number of Struct within struct array: %d \n", sizeof(structArrayToBeCheck)/sizeof(struct contain));

vous donne la bonne réponse.

0
Ursa Major

Vous ne pouvez pas indiquer le nombre d'éléments dans un tableau dansCde manière cohérente. Spécialement si vous passez le tableau à travers des pointeurs.

Généralement, si vous devez utilisez la taille d'un tableau dans une fonction, transmettez-la en tant que paramètre.

0
Pablo Santa Cruz

Lorsque vous utilisez sizeof dans main, il évalue le tableau et donne la taille du tableau réel.

Lorsque vous utilisez sizeof dans f, vous avez passé le nom du tableau en tant qu'argument d'une fonction. Il s'est donc décomposé en un pointeur. sizeof vous indique la taille d'un pointeur.

En règle générale, si vous transmettez un tableau à une fonction, vous devez écrire cette fonction pour qu'elle ne fonctionne qu'avec une taille de tableau spécifique, ou bien indiquer explicitement la taille du tableau pour qu'il puisse fonctionner avec une invocation particulière.

0
Jerry Coffin