webentwicklung-frage-antwort-db.com.de

C: Ermitteln der Anzahl der Elemente in einem Array []

In C: Wie finden Sie die Anzahl der Elemente in einem Array von Strukturen, nachdem Sie es an eine Funktion gesendet haben?

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

Aus irgendeinem Grund zeigt der printf in main andere Ergebnisse als der printf in f. Ich muss wissen, wie viele Elemente sich im Array befinden.

13
Lavi Avigdor

Das kannst du nicht.

Sie müssen die Größe an die Funktion übergeben, zB:

void f(myStruct* array, size_t siz);

Beachten Sie auch, dass in f array ein Zeiger und in main ein Array ist. Arrays und Zeiger sind verschiedene Dinge.

19
pmg

In f ist array ein Zeiger, in main ist array ein Array.

10
PaulJWilliams

sie müssen das Array mit einem speziellen Wert beenden und in der aufgerufenen Funktion müssen Sie bis zu diesem Wert zählen.

1
bkilinc

Beachten Sie, dass sich in main () array auf das tatsächliche Array bezieht und sizeof () daher die erforderliche Antwort liefert.

Wenn Sie es jedoch als Funktionsparameter übergeben, übergeben Sie tatsächlich die Adresse des ersten Elements des Arrays, das in der Zeigervariable 'array' gespeichert ist.
Sizeof () gibt also die Größe der Zeigervariable an, weshalb sie von der tatsächlichen Antwort abweicht.

Mögliche Lösung kann zu sein

1. Deklarieren Sie das Array global

2. Übergeben Sie die Array-Größe als Funktionsparameter. Hoffe, es hilft!

1
Apaar

Sie müssen diese Daten als separaten Parameter an die Funktion übergeben. In C und C++ degeneriert das Array zu einem Zeiger, sobald ein Array an eine Funktion übergeben wird. Zeiger wissen nicht, auf wie viele Elemente in dem Array sie zeigen.

Eine übliche Methode, um die Größe zu ermitteln, besteht darin, das Array zu deklarieren und sofort die Anzahl der Array-Elemente zu ermitteln, indem die Gesamtgröße durch die Größe eines Elements dividiert wird. So was:

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

Im obigen Code kann die Funktion f() nicht erkennen, wie viele Elemente sich in Ihrem ursprünglichen Array befanden. Es ist ein Merkmal der Sprache und es führt kein Weg daran vorbei. Sie müssen die Länge übergeben.

1
Jean-Marc Valin

Wie die C-Referenz sagt, können Sie dies nur tun, wenn entweder das letzte Element eindeutig ist oder Sie der Funktion eine Anzahl von Array-Elementen übergeben.

1
David Harris

Sie können ein Format für Ihr Array verwenden. Ich benutze Zeichenkettenelemente, es sollte für struct funktionieren.

#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

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

Sie sollten die Ausgabe erhalten:

Algo: des 
   :
   :
Algo: zlib 

There are 38 algos in the check list.

Alternativ, wenn Sie das nicht verwenden möchten NULL Tun Sie dies stattdessen:

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

Als Beispiel für Ihre Lösung:

Gegeben

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

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

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

// z.B. initialisiert

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

};

in main ()

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

gibt dir die richtige antwort.

0
Ursa Major

Sie können die Anzahl der Elemente in einem Array inCnicht konsistent angeben. Insbesondere, wenn Sie das Array durch Zeiger herumreichen.

Wenn Sie in einer Funktion must die Array-Größe verwenden, übergeben Sie diese normalerweise als Parameter.

0

Wenn Sie sizeof in main verwenden, wird das Array ausgewertet und die Größe des tatsächlichen Arrays angegeben.

Wenn Sie sizeof in f verwenden, haben Sie den Namen des Arrays als Argument an eine Funktion übergeben, sodass es zu einem Zeiger zerfallen ist. sizeof gibt also Auskunft über die Größe eines Zeigers.

Wenn Sie ein Array an eine Funktion übergeben, müssen Sie im Allgemeinen entweder die Funktion schreiben, um nur mit einer bestimmten Array-Größe zu arbeiten, oder die Array-Größe explizit übergeben, damit sie bei einem bestimmten Aufruf funktioniert.

0
Jerry Coffin