Hat C ein “foreach”-Schleifenkonstrukt?

Fast alle Sprachen haben eine foreach Schleife oder etwas ähnliches. Hat C einen? Kannst du einen Beispielcode posten?

C hat kein foreach, aber Makros werden häufig verwendet, um dies zu emulieren:

#define for_each_item(item, list) \
    for(T * item = list->head; item != NULL; item = item->next)

Und kann gerne verwendet werden

for_each_item(i, processes) {
    i->wakeup();
}

Auch eine Iteration über ein Array ist möglich:

#define foreach(item, array) \
    for(int keep = 1, \
            count = 0,\
            size = sizeof (array) / sizeof *(array); \
        keep && count != size; \
        keep = !keep, count++) \
      for(item = (array) + count; keep; keep = !keep)

Und kann gerne verwendet werden

int values[] = { 1, 2, 3 };
foreach(int *v, values) {
    printf("value: %d\n", *v);
}

Bearbeiten: Falls Sie auch an C++-Lösungen interessiert sind, C++ hat eine native for-each-Syntax namens “range based for”.

Hier ist ein vollständiges Programmbeispiel eines for-each-Makros in C99:

#include <stdio.h>

typedef struct list_node list_node;
struct list_node {
    list_node *next;
    void *data;
};

#define FOR_EACH(item, list) \
    for (list_node *(item) = (list); (item); (item) = (item)->next)

int
main(int argc, char *argv[])
{
    list_node list[] = {
        { .next = &list[1], .data = "test 1" },
        { .next = &list[2], .data = "test 2" },
        { .next = NULL,     .data = "test 3" }
    };

    FOR_EACH(item, list)
        puts((char *) item->data);

    return 0;
}

Wie Sie wahrscheinlich bereits wissen, gibt es in C keine Schleife im “foreach”-Stil.

Obwohl hier bereits unzählige großartige Makros bereitgestellt werden, um dies zu umgehen, finden Sie dieses Makro vielleicht nützlich:

// "length" is the length of the array.   
#define each(item, array, length) \
(typeof(*(array)) *p = (array), (item) = *p; p < &((array)[length]); p++, (item) = *p)

…die verwendet werden können for (wie in for each (...)).

Vorteile dieses Ansatzes:

• item innerhalb der for-Anweisung deklariert und inkrementiert (genau wie in Python!).
• Scheint auf jedem 1-dimensionalen Array zu funktionieren
• Alle im Makro erstellten Variablen (p, item), sind außerhalb des Gültigkeitsbereichs der Schleife nicht sichtbar (da sie im Header der for-Schleife deklariert sind).

Nachteile:

• Funktioniert nicht für mehrdimensionale Arrays
• Beruht auf typeof()das ist eine GNU-Erweiterung, nicht Teil von Standard C
• Da es Variablen im Header der for-Schleife deklariert, funktioniert es nur in C11 oder höher.

Um Ihnen etwas Zeit zu sparen, können Sie es folgendermaßen testen:

typedef struct {
    double x;
    double y;
} Point;

int main(void) {
    double some_nums[] = {4.2, 4.32, -9.9, 7.0};
    for each (element, some_nums, 4)
        printf("element = %lf\n", element);

    int numbers[] = {4, 2, 99, -3, 54};
    // Just demonstrating it can be used like a normal for loop
    for each (number, numbers, 5) { 
        printf("number = %d\n", number);
        if (number % 2 == 0)
                printf("%d is even.\n", number);
    }

    char* dictionary[] = {"Hello", "World"};
    for each (word, dictionary, 2)
        printf("word = '%s'\n", word);

    Point points[] = {{3.4, 4.2}, {9.9, 6.7}, {-9.8, 7.0}};
    for each (point, points, 3)
        printf("point = (%lf, %lf)\n", point.x, point.y);

    /* Neither p, element, number or word are visible outside the scope of
    their respective for loops. Try to see if these printfs work (they shouldn't): */
    //printf("*p = %s", *p);
    //printf("word = %s", word);

    return 0;
}

Scheint standardmäßig auf gcc und clang zu funktionieren; habe keine anderen Compiler getestet.

In C gibt es kein foreach.

Sie können eine for-Schleife verwenden, um die Daten zu durchlaufen, aber die Länge muss bekannt sein oder die Daten müssen mit einem bekannten Wert (z. B. null) abgeschlossen werden.

char* nullTerm;
nullTerm = "Loop through my characters";

for(;nullTerm != NULL;nullTerm++)
{
    //nullTerm will now point to the next character.
}

Während C nicht für jedes Konstrukt ein Konstrukt hat, hatte es immer eine idiomatische Darstellung für eins nach dem Ende eines Arrays (&arr)[1]. Auf diese Weise können Sie für jede Schleife eine einfache Idiomatik wie folgt schreiben:

int arr[] = {1,2,3,4,5};
for(int *a = arr; a < (&arr)[1]; ++a)
    printf("%d\n", *a);

Dies ist eine ziemlich alte Frage, aber ich dachte, ich sollte dies posten. Es ist eine Foreach-Schleife für GNU C99.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define FOREACH_COMP(INDEX, ARRAY, ARRAY_TYPE, SIZE) \
  __extension__ \
  ({ \
    bool ret = 0; \
    if (__builtin_types_compatible_p (const char*, ARRAY_TYPE)) \
      ret = INDEX < strlen ((const char*)ARRAY); \
    else \
      ret = INDEX < SIZE; \
    ret; \
  })

#define FOREACH_ELEM(INDEX, ARRAY, TYPE) \
  __extension__ \
  ({ \
    TYPE *tmp_array_ = ARRAY; \
    &tmp_array_[INDEX]; \
  })

#define FOREACH(VAR, ARRAY) \
for (void *array_ = (void*)(ARRAY); array_; array_ = 0) \
for (size_t i_ = 0; i_ && array_ && FOREACH_COMP (i_, array_, \
                                    __typeof__ (ARRAY), \
                                    sizeof (ARRAY) / sizeof ((ARRAY)[0])); \
                                    i_++) \
for (bool b_ = 1; b_; (b_) ? array_ = 0 : 0, b_ = 0) \
for (VAR = FOREACH_ELEM (i_, array_, __typeof__ ((ARRAY)[0])); b_; b_ = 0)

/* example's */
int
main (int argc, char **argv)
{
  int array[10];
  /* initialize the array */
  int i = 0;
  FOREACH (int *x, array)
    {
      *x = i;
      ++i;
    }

  char *str = "hello, world!";
  FOREACH (char *c, str)
    printf ("%c\n", *c);

  return EXIT_SUCCESS;
}

Dieser Code wurde getestet, um mit gcc, icc und clang unter GNU/Linux zu funktionieren.

Folgendes verwende ich, wenn ich bei C feststecke. Sie können denselben Elementnamen nicht zweimal im selben Bereich verwenden, aber das ist nicht wirklich ein Problem, da nicht alle von uns nette neue Compiler verwenden können 🙁

#define FOREACH(type, item, array, size) \
    size_t X(keep), X(i); \
    type item; \
    for (X(keep) = 1, X(i) = 0 ; X(i) < (size); X(keep) = !X(keep), X(i)++) \
        for (item = (array)[X(i)]; X(keep); X(keep) = 0)

#define _foreach(item, array) FOREACH(__typeof__(array[0]), item, array, length(array))
#define foreach(item_in_array) _foreach(item_in_array)

#define in ,
#define length(array) (sizeof(array) / sizeof((array)[0]))
#define CAT(a, b) CAT_HELPER(a, b) /* Concatenate two symbols for macros! */
#define CAT_HELPER(a, b) a ## b
#define X(name) CAT(__##name, __LINE__) /* unique variable */

Verwendungszweck:

int ints[] = {1, 2, 0, 3, 4};
foreach (i in ints) printf("%i", i);
/* can't use the same name in this scope anymore! */
foreach (x in ints) printf("%i", x);

BEARBEITEN: Hier ist eine Alternative für FOREACH Verwendung der c99-Syntax, um Namespace-Verschmutzung zu vermeiden:

#define FOREACH(type, item, array, size) \
    for (size_t X(keep) = 1, X(i) = 0; X(i) < (size); X(keep) = 1, X(i)++) \
    for (type item = (array)[X(i)]; X(keep); X(keep) = 0)