几乎所有语言都有foreach loop或类似的东西。 C有一个吗？你能发布一些示例代码吗？
C没有foreach，但宏经常用于模拟：
#define for_each_item(item, list) \
for(T * item = list->head; item != NULL; item = item->next)
并且可以像
for_each_item(i, processes) {
i->wakeup();
}
也可以在数组上进行迭代：
#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)
并且可以像
int values[] = { 1, 2, 3 };
foreach(int *v, values) {
printf("value: %d\n", *v);
}
编辑：如果您对C ++解决方案也感兴趣，C ++有一个原生的for-each语法，称为“基于范围”
如果您打算使用函数指针
#define lambda(return_type, function_body)\
({ return_type __fn__ function_body __fn__; })
#define array_len(arr) (sizeof(arr)/sizeof(arr[0]))
#define foreachnf(type, item, arr, arr_length, func) {\
void (*action)(type item) = func;\
for (int i = 0; i<arr_length; i++) action(arr[i]);\
}
#define foreachf(type, item, arr, func)\
foreachnf(type, item, arr, array_len(arr), func)
#define foreachn(type, item, arr, arr_length, body)\
foreachnf(type, item, arr, arr_length, lambda(void, (type item) body))
#define foreach(type, item, arr, body)\
foreachn(type, item, arr, array_len(arr), body)
用法：
int ints[] = { 1, 2, 3, 4, 5 };
foreach(int, i, ints, {
printf("%d\n", i);
});
char* strs[] = { "hi!", "hello!!", "hello world", "just", "testing" };
foreach(char*, s, strs, {
printf("%s\n", s);
});
char** strsp = malloc(sizeof(char*)*2);
strsp[0] = "abcd";
strsp[1] = "efgh";
foreachn(char*, s, strsp, 2, {
printf("%s\n", s);
});
void (*myfun)(int i) = somefunc;
foreachf(int, i, ints, myfun);
但我认为这只适用于gcc（不确定）。
C没有for-each的实现。当将数组解析为一个点时，接收器不知道该数组有多长，因此无法判断何时到达数组的末尾。请记住，在C中，int*指向包含int的内存地址。没有头对象包含有关按顺序放置多少个整数的信息。因此，程序员需要跟踪这一点。
但是，对于列表，很容易实现类似于for-each循环的东西。
for(Node* node = head; node; node = node.next) {
/* do your magic here */
}
要为数组实现类似的功能，您可以执行以下两种操作之一。
以下是此类结构的示例：
typedef struct job_t {
int count;
int* arr;
} arr_t;
这是我在使用C时使用的内容。你不能在相同的范围内使用相同的项目名称两次，但这不是一个问题，因为并非所有人都使用漂亮的新编译器:(
#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 */
用法：
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);
感谢接受的答案，我能够修复我的C ++宏。它不干净，但它支持嵌套，中断和继续，对于list<t>它允许迭代t&而不是list<t>::elem*，所以你不必去引用。
template <typename t> struct list { // =list=
struct elem {
t Data;
elem* Next;
};
elem* Head;
elem* Tail;
};
#define for_list3(TYPE, NAME, NAME2, LIST) \
bool _##NAME##NAME2 = true;\
for (list<TYPE>::elem* NAME##_E = LIST.Head;\
NAME##_E && _##NAME##NAME2;\
_##NAME##NAME2 = !_##NAME##NAME2, NAME##_E = NAME##_E->Next) \
for (auto& NAME = NAME##_E->Data; _##NAME##NAME2; _##NAME##NAME2=false)
#define for_list2(TYPE, NAME, NAME2, LIST) for_list3(TYPE, NAME, NAME2, LIST)
#define for_list(TYPE, NAME, LIST) for_list2(TYPE, NAME, __COUNTER__, LIST)
void example() {
list<string> Words;
for_list(string, Word, Words) {
print(Word);
}
}
使用接受答案的for_each_item宏，你必须这样做：
void example2() {
list<string> Words;
for_each_item(string, Elem, Words) {
string& Word = Elem->Data;
print(Word);
}
}
如果您想将其重写为干净的版本，请随时编辑。
这是C99中for-each宏的完整程序示例：
#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中没有foreach。
您可以使用for循环来遍历数据，但需要知道长度或者需要通过已知值（例如，null）终止数据。
char* nullTerm;
nullTerm = "Loop through my characters";
for(;nullTerm != NULL;nullTerm++)
{
//nullTerm will now point to the next character.
}
这是一个相当古老的问题，但我应该发布这个问题。它是GNU C99的foreach循环。
#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;
}
此代码已经过测试，可以在GNU / Linux上使用gcc，icc和clang。
虽然C对于每个构造都没有a，但它总是在数组(&arr)[1]的末尾有一个惯用的表示。这允许您为每个循环编写一个简单的惯用语，如下所示：
int arr[] = {1,2,3,4,5};
for(int *a = arr; a < (&arr)[1]; ++a)
printf("%d\n", *a);
你可能已经知道，C中没有“foreach”风格循环。
虽然这里已经提供了很多很棒的宏来解决这个问题，但也许你会发现这个宏非常有用。
// "length" is the length of the array.
#define each(item, array, length) \
(typeof(*(array)) *p = (array), (item) = *p; p < &((array)[length]); p++, (item) = *p)
...可以与for一起使用（如for each (...)）。
这种方法的优点：
item在for语句中声明并递增（就像在Python中一样！）。p，item）中创建的所有变量在循环范围之外都不可见（因为它们在for循环标头中声明）。缺点：
typeof()，这是一个gcc扩展;不属于标准C的一部分为了节省您的时间，以下是您可以测试的方法：
typedef struct _point {
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;
}
似乎在gcc和clang上工作;不确定其他编译器。
C有'for'和'while'关键字。如果像C＃这样的语言的foreach语句看起来像这样......
foreach (Element element in collection)
{
}
...那么在C中这个foreach语句的等价物可能就像：
for (
Element* element = GetFirstElement(&collection);
element != 0;
element = GetNextElement(&collection, element)
)
{
//TODO: do something with this element instance ...
}
当你使用“休息”或“继续”时，Eric's answer不起作用。
这可以通过重写第一行来修复：
原始行（重新格式化）：
for (unsigned i = 0, __a = 1; i < B.size(); i++, __a = 1)
固定：
for (unsigned i = 0, __a = 1; __a && i < B.size(); i++, __a = 1)
如果你将它与约翰内斯的循环相比较，你会发现他实际上是在做同样的事情，只是有点复杂和丑陋。
这是一个简单的，单循环：
#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
如果您需要（i）和我们正在迭代的当前项目（it），您可以访问索引。请注意，嵌套循环时可能存在命名问题，您可以使项目和索引名称成为宏的参数。
编辑：这是接受的答案foreach的修改版本。让你指定start索引，size使它适用于腐朽的数组（指针），不需要int*并将count != size更改为i < size，以防用户意外修改'i'大于size并陷入无限环。
#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);
输出：
index: 2. element: 3
index: 3. element: 4
index: 4. element: 5