Est-ce que C d'avoir un “foreach” boucle de construire?

Voici une exemple de programme d'une pour chaque macro en 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;
}

C'est une assez vieille question, mais je pensais que je devrais poster cela. C'est une boucle foreach pour 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;
}

Ce code a été testé pour fonctionner avec gcc, la cour et le bruit sur GNU/Linux.

Tandis que le C n'a pas une pour chaque construction, il a toujours eu un idiomatiques représentation pour un passé la fin d'un tableau (&arr)[1]. Cela permet d'écrire une simple idiomatiques pour chaque boucle comme suit:

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

Voici ce que j'utilise quand je suis coincé avec C. Vous ne pouvez pas utiliser le même nom de l'élément deux fois dans la même portée, mais ce n'est pas vraiment un problème puisque ce ne sont pas tous d'entre nous ont gentiment de nouveaux compilateurs 🙁

#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 */

Utilisation:

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

EDIT: Voici une alternative pour FOREACH à l'aide de la c99 syntaxe pour éviter de polluer l'espace de nom:

#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)

Ici est un simple, une seule boucle for:

#define FOREACH(type, array, size) do { \
type it = array[0]; \
for(int i = 0; i < size; i++, it = array[i])
#define ENDFOR  } while(0);
int array[] = { 1, 2, 3, 4, 5 };
FOREACH(int, array, 5)
{
printf("element: %d. index: %d\n", it, i);
}
ENDFOR

Vous donne accès à l'index si vous le souhaitez (i) et de l'élément en cours, nous sommes à parcourir (it). Note vous pouvez avoir nommer des problèmes lors de l'imbrication de boucles, vous pouvez faire le point et index des noms de paramètres de la macro.

Edit: Voici une version modifiée de la accepté de répondre à foreach. Vous permet de spécifier le start index, le size afin qu'il fonctionne sur pourri tableaux (pointeurs), pas besoin de int* et changé count != size à i < size juste au cas où l'utilisateur accidentellement modifie "je", pour être plus grand que size et coincé dans une boucle infinie.

#define FOREACH(item, array, start, size)\
for(int i = start, keep = 1;\
keep && i < size;\
keep = !keep, i++)\
for (item = array[i]; keep; keep = !keep)
int array[] = { 1, 2, 3, 4, 5 };
FOREACH(int x, array, 2, 5)
printf("index: %d. element: %d\n", i, x);

De sortie:

index: 2. element: 3
index: 3. element: 4
index: 4. element: 5

C n'a pas de mise en œuvre de for-each. Lors de l'analyse d'un tableau comme point le récepteur ne sais pas combien de temps le tableau, donc il n'y a aucun moyen de savoir quand vous avez atteint la fin du tableau.
Rappelez-vous, en C int* est un point à une adresse mémoire contenant un int. Il n'y a pas d'en-tête de l'objet contenant des informations sur le nombre d'entiers qui sont placés dans l'ordre. Ainsi, le programmeur a besoin de garder une trace de ce.

Toutefois, pour les listes, il est facile de mettre en place quelque chose qui ressemble à un for-each boucle.

for(Node* node = head; node; node = node.next) {
/* do your magic here */
}

Pour obtenir quelque chose de similaire pour les tableaux que vous pouvez faire une des deux choses.

1. utiliser le premier élément à stocker la longueur de la matrice.
2. envelopper le tableau dans une structure qui détient la longueur et un pointeur vers le tableau.

Ce qui suit est un exemple d'une telle structure:

typedef struct job_t {
int count;
int* arr;
} arr_t;