Finden Sie die Anzahl der Strings in einem Array von Strings in C

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

Gibt es eine Möglichkeit, die Anzahl der Zeichenfolgen im Array zu ermitteln? In diesem Fall sollte beispielsweise Folgendes ausgegeben werden: 3.

In diesem Fall können Sie die Gesamtgröße durch die Größe des ersten Elements teilen:

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

Aber Vorsicht, das funktioniert mit Arrays. Mit Zeigern geht das nicht.

Für ein Array, was die Beispiele im Bounty tun sizeof(names)/sizeof(names[0]) reicht aus, um die Länge des Arrays zu bestimmen.

Dass die Strings in den Beispielen unterschiedlich lang sind, spielt dabei keine Rolle. names ist ein Array von char *also ist die Gesamtgröße des Arrays in Bytes die Anzahl der Elemente im Array multipliziert mit der Größe jedes Elements (dh a char *). Jeder dieser Zeiger könnte auf eine Zeichenfolge beliebiger Länge oder auf NULL zeigen. Egal.

Testprogramm:

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

Ausgabe:

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

BEARBEITEN:

Zur Verdeutlichung funktioniert dies nur, wenn Sie ein Array definiert haben, dh char *names[] oder char names[][], und Sie befinden sich in dem Bereich, in dem das Array definiert wurde. Wenn es definiert ist als char **names Dann haben Sie einen Zeiger, der als Array fungiert, und die obige Technik funktioniert nicht. Ebenso wenn char *names[] ein Funktionsparameter ist, in diesem Fall zerfällt das Array auf die Adresse des ersten Elements.

Es hängt davon ab, wie Ihr Array erstellt wird. In C gibt es keine Möglichkeit, die Länge eines Arrays zu überprüfen, das ein Zeiger ist, es sei denn, es hat ein Sentinel-Element oder eine Ganzzahl, die mit dem Array als Anzahl der Elemente im Array übergeben wird. In Ihrem Fall könnten Sie dies verwenden:

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

Wenn Ihr Array jedoch ein Zeiger ist,

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

Sie können entweder eine ganze Zahl haben, die für die Länge des Arrays konstant ist:

int namesLen = 3;

Oder fügen Sie einen Sentinel-Wert hinzu (z. B. NULL)

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

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

// namesLen is now the length of your array

Als andere Möglichkeit könnten Sie eine Struktur erstellen, die mit den gewünschten Werten gefüllt ist:

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

Und Sie würden es so verwenden:

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

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

Was Sie hier definieren, ist nicht buchstäblich ein Array von Zeichenfolgen, sondern ein Array von Zeigern auf Zeichen. wenn du die anzahl der strings wissen willst, musst du einfach die zeiger zählen, also sowas wie

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

tun würde, teilen Sie auf diese Weise die Größe des Arrays durch die Größe eines einzelnen Zeigers. Beachten Sie jedoch, dass dies nur funktioniert, wenn die Größe des Arrays zur Kompilierzeit bekannt ist (dh das Array wird statisch zugewiesen), wenn dies der Fall ist dann dynamisch definiert (dh char** Strings). sizeof(strings) würde die Größe des Zeigers zurückgeben, nicht das Array.

ps: Die Länge der Strings ist nicht relevant, da das Array nicht einmal “bewusst” ist, worauf die Zeiger zeigen.

Gibt es eine Möglichkeit, die Anzahl der Zeichenfolgen im Array zu ermitteln?

Natürlich gibt es das, versuchen Sie Folgendes:

#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

Das gleiche mit:

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

Ausgabe:

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

The number of strings found are 6

Oder verwenden Sie eine Funktion wie diese:

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

Ausgabe:

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

The number of strings found are 6

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

Dies nimmt die Gesamtgröße von names und teilt es durch die Größe eines Elements in namesergibt 3.

Ein einfacher Weg gibt die Zahl oder die Zeichenfolgen in einem Array zurück ist, über das Array zu iterieren, bis Ihnen die Strings ausgehen. Hier ist ein Beispiel.

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

Diese Methode hat den Vorteil, dass sie funktioniert auch wenn die Saiten unterschiedlich lang sind. Beachten Sie das abschließende NULL-Byte in der names Array und die ; Zeichen zum Schließen while -Anweisung, da kein auszuführender Anweisungstext vorhanden ist.