trova il numero di stringhe in una matrice di stringhe in C

Question

char* names[]={"A", "B", "C"}; 

C'è un modo per trovare il numero di stringhe nell'array. Ad esempio, in questo caso, deve essere 3. Per favore fatemi sapere. Grazie.

Answer 1

In questo caso si può dividere la dimensione totale dalle dimensioni del primo elemento:

num = sizeof(names)/sizeof(names[0]); 

Attenzione però, questo funziona con array. Non funzionerà con i puntatori.

Answer 2

int count = sizeof(names)/sizeof(*names); 

Questo prende la dimensione totale di names e lo divide per le dimensioni di un elemento in names, con conseguente 3.

Answer 3

Dipende da come viene creato l'array. In C, non c'è modo di verificare la lunghezza di un array che è un puntatore, a meno che non abbia un elemento sentinella o un intero passato con l'array come conteggio degli elementi nella matrice. Nel tuo caso, è possibile utilizzare questo:

int namesLen = sizeof(names)/sizeof(char); 

Tuttavia, se la matrice è un puntatore,

char **names = { "A", "B", "C" }; 

È possibile avere un numero intero che è costante per la lunghezza della matrice:

int namesLen = 3; 

Oppure aggiungi un valore sentinella (ad esempio NULL)

char **names = { "A", "B", "C", NULL }; 

int namesLen = -1; 
while (names[++namesLen] != NULL) { /* do nothing */} 

// namesLen is now the length of your array 

come un altro modo, è possibile creare una struttura che viene riempito con i valori che si desidera:

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; 
} 

E si usa come tale:

struct Array myArray = array("Hi", "There", "This", "Is", "A", "Test"); 
// use myArray 

printf("%i", myArray.length); 
destroy(myArray); 

Answer 4

Un modo semplice per restituire il numero o le stringhe in un array devono essere ripetute sull'array finché non si esauriscono le stringhe. Ecco un esempio.

#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; 
} 

Questo metodo ha il vantaggio che funziona anche quando le stringhe sono di lunghezza variabile. Notare il byte NULL di chiusura nell'array e il carattere ; per chiudere l'istruzione while in quanto non esiste alcun corpo di istruzioni da eseguire.

Answer 5

Per un array, che sono gli esempi nel bounty, fare sizeof(names)/sizeof(names[0]) è sufficiente per determinare la lunghezza dell'array.

Il fatto che le stringhe negli esempi siano di lunghezza diversa non ha importanza. names è una matrice di char *, quindi la dimensione totale della matrice in byte è il numero di elementi nell'array moltiplicato per la dimensione di ciascun elemento (ad esempio char *). Ognuno di questi puntatori potrebbe puntare a una stringa di qualsiasi lunghezza o su NULL. Non importa

programma di 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])); 
} 

uscita:

len 1 = 3 
len 2 = 3 
len 3 = 4 
len 4 = 4 
len 5 = 5 

EDIT:

Per chiarire, questo funziona solo se hai definito una serie, vale a dire char *names[] o char names[][], e voi rientra nell'ambito in cui è stato definito l'array. Se è definito come char **names, allora hai un puntatore che funziona come un array e la tecnica di cui sopra non funzionerà. Allo stesso modo se char *names[] è un parametro di funzione, nel qual caso l'array decade all'indirizzo del primo elemento.

Answer 6

Per trovare il numero di caratteri in un array di stringhe, è possibile scorrere gli elementi dell'array e in ogni ciclo indice attraverso il contenuto dell'elemento (o la stringa) fino a quando non si preme "\ 0". Il seguente codice fa proprio questo e funziona con qualsiasi formato di stringhe memorizzate nella matrice

char* names[] = {"An", "Bed", "Cards"}; 

    int arrayIndex, counter; 
    for (arrayIndex = 0; arrayIndex < (sizeof(names)/sizeof(char*)); arrayIndex++) { 
     //counting also chars in each string (extra, not necessarily the question) 
     char* stringAtIndex = names[arrayIndex]; 
     char c; 
     int i = 0; 
     do { 
      c = *(stringAtIndex + i++); 
     } while (c != '\0'); 
     counter += (i-1); //exclude terminating char '\0' 
    } 
    printf("Number of array elements: %d", arrayIndex+1); //number of strings 
    printf("Total chars %d\n", counter); // Prints 10 which is number of chars excluding '\0' 

Answer 7

trovare il numero di stringhe in un array di stringhe in C

Il metodo semplice per trovare il il numero di oggetti in un array è quello di prendere la dimensione dell'array diviso per la dimensione di uno dei suoi elementi. Utilizzare l'operatore sizeof che restituisce la dimensione dell'oggetto in byte.

// 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); 

importante considerare il tipo di ritorno da sizeof è size_t, un tipo intero senza segno capace di indicizzazione qualsiasi matrice così come la dimensione di qualsiasi oggetto. Per stampare una variabile di tipo size_t, utilizzare il modificatore z.

Answer 8

Quello che stai definendo qui non è letteralmente una serie di stringhe, è una serie di indicatori per i personaggi. Se si vuole conoscere il numero di stringhe, è sufficiente contare i puntatori, in modo da qualcosa come

size_t size = sizeof(names)/sizeof(char*); 

farebbe, in questo modo si sta dividendo la dimensione della matrice per la dimensione di un singolo puntatore. Ma sappiate che funziona solo se la dimensione dell'array è nota al momento della compilazione (cioè l'array è allocato staticamente), se è definito dinamicamente (cioè char ** stringhe) allora sizeof(strings) restituirebbe la dimensione del puntatore non dell'array.

p.s.:la lunghezza delle stringhe non è rilevante, in quanto l'array non è nemmeno "a conoscenza" di ciò a cui puntano i puntatori.

Answer 9

C'è un modo per trovare il numero di stringhe nella matrice

naturalmente c'è, provate questo:

#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 

Stessa cosa con:

#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; 
} 

uscita:

1 - Jimmy 
2 - Tom 
3 - Michael 
4 - Maria 
5 - Sandra 
6 - Madonna 

The number of strings found are 6 

O usare una funzione come questa:

#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; 
} 

uscita:

1 - Jimmy 
2 - Tom 
3 - Michael 
4 - Maria 
5 - Sandra 
6 - Madonna 

The number of strings found are 6