trouver le nombre de chaînes dans un tableau de chaînes en C
char* names[]={"A", "B", "C"};
Existe-t-il un moyen de trouver le nombre de chaînes dans le tableau. Par exemple, dans ce cas, il doit être de 3. Veuillez me le faire savoir. Merci.
Dans ce cas, vous pouvez diviser la taille totale par la taille du premier élément:
num = sizeof(names) / sizeof(names[0]);
Attention cependant, cela fonctionne avec tableaux. Cela ne fonctionnera pas avec les pointeurs.
Pour un tableau, ce que sont les exemples de la prime, faire sizeof(names)/sizeof(names[0]) suffit pour déterminer la longueur du tableau.
Le fait que les chaînes dans les exemples soient de longueur différente n'a pas d'importance. names est un tableau de char *, donc la taille totale du tableau en octets est le nombre d'éléments dans le tableau multiplié par la taille de chaque élément (c'est-à-dire un char *). Chacun de ces pointeurs peut pointer vers une chaîne de n'importe quelle longueur ou vers NULL. Peu importe.
Programme de test:
#include<stdio.h>
int main(void)
{
char* names1[]={"A", "B", "C"}; // Three elements
char* names2[]={"A", "", "C"}; // Three elements
char* names3[]={"", "A", "C", ""}; // Four elements
char* names4[]={"John", "Paul", "George", "Ringo"}; // Four elements
char* names5[]={"", "B", NULL, NULL, "E"}; // Five elements
printf("len 1 = %zu\n",sizeof(names1)/sizeof(names1[0]));
printf("len 2 = %zu\n",sizeof(names2)/sizeof(names2[0]));
printf("len 3 = %zu\n",sizeof(names3)/sizeof(names3[0]));
printf("len 4 = %zu\n",sizeof(names4)/sizeof(names4[0]));
printf("len 5 = %zu\n",sizeof(names5)/sizeof(names5[0]));
}
Production:
len 1 = 3
len 2 = 3
len 3 = 4
len 4 = 4
len 5 = 5
ÉDITER:
Pour clarifier, cela ne fonctionne que si vous avez défini un tableau, c'est-à-dire char *names[] ou char names[][], et vous êtes dans la portée où le tableau a été défini. S'il est défini comme char **names alors vous avez un pointeur qui fonctionne comme un tableau et la technique ci-dessus ne fonctionnera pas. De même, si char *names[] est un paramètre de fonction, auquel cas le tableau se désintègre à l'adresse du premier élément.
Cela dépend de la façon dont votre tableau est créé. En C, il n'y a aucun moyen de vérifier la longueur d'un tableau qui est un pointeur, à moins qu'il ne comporte un élément sentinelle ou un entier passé avec le tableau comme décompte des éléments du tableau. Dans votre cas, vous pouvez utiliser ceci:
int namesLen = sizeof(names) / sizeof(char);
Cependant, si votre tableau est un pointeur,
char **names = { "A", "B", "C" };
Vous pouvez soit avoir un entier constant pour la longueur du tableau:
int namesLen = 3;
Ou ajoutez une valeur sentinelle (par exemple NULL)
char **names = { "A", "B", "C", NULL };
int namesLen = -1;
while (names[++namesLen] != NULL) { /* do nothing */}
// namesLen is now the length of your array
Vous pouvez également créer une structure remplie des valeurs souhaitées:
struct Array {
void **values;
int length;
};
#define array(elements...) ({ void *values[] = { elements }; array_make(values, sizeof(values) / sizeof(void *)); })
#define destroy(arr) ({ free(arr.values); })
struct Array array_make(void **elements, int count)
{
struct Array ret;
ret.values = malloc(sizeof(void *) * count);
ret.length = count;
for (int i = 0; i < count; i++) {
ret.values[i] = elements[i];
}
return ret;
}
Et vous l'utiliseriez comme tel:
struct Array myArray = array("Hi", "There", "This", "Is", "A", "Test");
// use myArray
printf("%i", myArray.length);
destroy(myArray);
Ce que vous définissez ici n'est pas littéralement un tableau de chaînes, c'est un tableau de pointeurs vers des caractères. si vous voulez connaître le nombre de chaînes, il vous suffit de compter les pointeurs, donc quelque chose comme
size_t size = sizeof(names)/sizeof(char*);
ferait, de cette façon, vous divisez la taille du tableau par la taille d'un seul pointeur.Mais sachez que cela ne fonctionne que si la taille du tableau est connue au moment de la compilation (c'est-à-dire que le tableau est alloué défini dynamiquement (c'est-à-dire des chaînes char **), alors sizeof(strings) retournerait la taille du pointeur et non le tableau.
p.s.:la longueur des chaînes n'est pas pertinente, car le tableau n'est même pas "conscient" de ce vers quoi pointent les pointeurs.
int count = sizeof(names)/sizeof(*names);
Cela prend la taille totale de names et la divise par la taille d'un élément dans names, ce qui donne 3.
Existe-t-il un moyen de trouver le nombre de chaînes dans le tableau
Bien sûr qu'il y en a, essayez ceci:
#include<stdio.h>
int main(void){
size_t size, i=0;
int count=0;
char* names[]={"A", "B", "C"};
size = sizeof(names)/sizeof(char*);
for(i=0;i<size;i++){
printf("%d - %s\n",count+1, *(names+i));
count++;
}
printf("\n");
printf("The number of strings found are %d\n",count);
return 0;
}
1 - A 2 - B 3 - C
The number of strings found are 3
Même chose avec:
#include<stdio.h>
int main(void){
size_t size, i=0;
int count=0;
char *names[]={"Jimmy", "Tom", "Michael", "Maria", "Sandra", "Madonna"};
size = sizeof(names)/sizeof(char*);
for(i=0;i<size;i++){
printf("%d - %s\n",count+1, *(names+i));
count++;
}
printf("\n");
printf("The number of strings found are %d\n",count);
return 0;
}
Production:
1 - Jimmy 2 - Tom 3 - Michael 4 - Maria 5 - Sandra 6 - Madonna
The number of strings found are 6
Ou utilisez une fonction comme celle-ci:
#include<stdio.h>
size_t arrLength(size_t len, char **arr){
size_t i=0;
size_t count=0;
for(i=0;i<len;i++){
printf("%zu - %s\n",count+1, *(arr+i));
count++;
}
return count;
}
int main(void){
char *names[]={"Jimmy", "Tom", "Michael", "Maria", "Sandra", "Madonna"};
size_t length,size;
size = sizeof(names)/sizeof(char*);
length = arrLength(size, names);
printf("\n");
printf("The number of strings found are %zu\n",length);
return 0;
}
Production:
1 - Jimmy 2 - Tom 3 - Michael 4 - Maria 5 - Sandra 6 - Madonna
The number of strings found are 6
trouver le nombre de chaînes dans un tableau de chaînes en C
La méthode simple pour trouver le nombre d'objets dans un tableau est de prendre la taille du tableau divisée par la taille de l'un de ses éléments. Utilisez l'opérateur sizeof qui renvoie la taille de l'objet en octets.
// For size_t
#include <stddef.h>
char* names[] = { "A", "B", "C" };
size_t number_of_strings = sizeof names / sizeof names[0];
printf("Number of strings %zu\n", number_of_strings);
Il est important de considérer que le type de retour de sizeof est size_t, un type entier non signé capable d'indexer n'importe quel tableau ainsi que la taille de n'importe quel objet. Pour imprimer une variable de type size_t, utilisez le modificateur z.
Une façon simple de renvoyer le nombre ou les chaînes dans un tablea est d'itérer sur le tableau jusqu'à ce que vous manquiez de chaînes. Voici un exemple.
#include <stdio.h>
int main()
{
char* names[] = {"John", "Paul", "George", "Ringo", '\0'};
int size = 0;
while(names[++size]!='\0');
printf("Size: %d\n", size); // Prints "4"
return 0;
}
Cette méthode a l'avantage de fonctionner même lorsque les chaînes sont de longueur variable. Notez l'octet NULL de fin dans le tableau names et le ; pour fermer l'instruction while car il n'y a pas de corps d'instruction à exécuter.