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.
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.
Dans f array
est un pointeur, dans main array
est un tableau.
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'.
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!
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]);
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.
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.
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);
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.
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.
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.