5

在 C 中获取数组元素计数的常用方法如下：

#define COUNTOF(arr) (sizeof(arr) / sizeof(arr[0]))

这会产生一个积分常数表达式，这也是一个非常好的加分项。

问题是它不是类型安全的：int* i; COUNTOF(i); /* compiles :( */. 在实践中，这应该很少出现，但为了正确起见，最好让这个类型安全。

在 C++03 中这很容易（在 C++11 中更容易，留给读者作为练习）：

template <typename T, std::size_t N>
char (&countof_detail(T (&)[N]))[N]; // not defined

#define COUNTOF(arr) (sizeof(countof_detail(arr)))

这使用模板推导来获取N数组的大小，然后将其编码为类型的大小。

但是在 C 中我们没有那种语言特性。这是我制作的小框架：

// if `condition` evaluates to 0, fails to compile; otherwise results in `value`
#define STATIC_ASSERT_EXPR(condition, value) \
        (sizeof(char[(condition) ? 1 : -1]), (value))

// usual type-unsafe method
#define COUNTOF_DETAIL(arr) (sizeof(arr) / sizeof(arr[0]))

// new method:
#define COUNTOF(arr)                            \
        STATIC_ASSERT_EXPR(/* ??? */,           \
                           COUNTOF_DETAIL(arr)) \

我可以投入什么/* ??? */来获得我想要的行为？或者这是不可能的？

我更喜欢 MSVC（即 C89）中的答案，但为了好奇，任何明确的答案都可以。

4

3 回答 3

1

这是我的第二个回答。它提供了两种解决方案。

第一个解决方案需要 gcc 扩展；OP 确实说他更喜欢在 MSVC 中工作的答案，但“任何明确的答案都可以”。

第二种解决方案从 ouah https://stackoverflow.com/a/12784339/318716的出色答案中窃取了想法，并且可能更便携。

我们从经典定义开始：

#define NUMBER_naive(x) ((int)(sizeof(x) / sizeof(x)[0])) // signed is optional

对于第一个解决方案，在 gcc 中，您可以进行测试以确定是否有任何表达式计算为数组（或者它在 处给出编译错误(x)[0]）；我已经用 6 岁的 gcc 4.1.2 测试了这个解决方案：

#define NUMBER(x) __builtin_choose_expr(                      \
   __builtin_types_compatible_p(typeof(x), typeof((x)[0])[]), \
   NUMBER_naive(x), garbage_never_defined)
extern void *garbage_never_defined;

第二种解决方案是：

#define ASSERT_zero(e) (!sizeof(struct{int:!!(e);})) // BUILD_BUG_ON_ZERO()
#define NUMBER(x) (NUMBER_naive(x) * !ASSERT_zero((void *)&(x) == (x)))

以下是一个简短的测试程序，在一些示例数组和指针上：

#include <stdio.h>
#define ASSERT_zero(e) (!sizeof(struct{int:!!(e);})) // BUILD_BUG_ON_ZERO()
#define NUMBER_naive(x) ((int)(sizeof(x) / sizeof(x)[0]))
#define NUMBER(x) (NUMBER_naive(x) * !ASSERT_zero((void*)&(x) == (x)))

int a1[10];
extern int a2[];
extern int a3[10];
int *p;
int square[10][10];

static void foo(int param[10]) {
// printf("foo param    %d\n", NUMBER(param));
}
static void bar(int param[][10]) {
// printf("bar param    %d\n", NUMBER(param));
   printf("bar param[0] %d\n", NUMBER(param[0]));
   printf("bar *param   %d\n", NUMBER(*param));
}
int main(void) {
   printf("a1 %d\n", NUMBER(a1));
// printf("a2 %d\n", NUMBER(a2));
   printf("a3 %d\n", NUMBER(a3));
// printf("p  %d\n", NUMBER(p));
   printf("square  %d\n", NUMBER(square));
   printf("*square %d\n", NUMBER(*square));
   foo(a1);
   bar(square);
   return 0;
}

这给出了：

a1 10
a3 10
square  10
*square 10
bar param[0] 10
bar *param   10

如您所见，我已经注释掉了四行不会或不应该编译的行，三行用于三个指针，另一行用于不完整的数组类型。

我对 . 的第三个参数的选择有一点问题__builtin_types_compatible_p()。gcc 手册（正确）声明所以现在"Furthermore, the unused expression (exp1 or exp2 depending on the value of const_exp) may still generate syntax errors."我已经将它设置为一个从未实例化的变量，garbage_never_defined所以对于某些四个被注释掉的行，而不是编译错误，我们得到一个编译器警告和一个链接器错误。

于 2012-10-14T00:09:18.920 回答
0

例子：

#include <stdio.h>

#define IS_NOT_POINTER(x)  (sizeof(x) != sizeof 42[x])
#define COUNTOF(x)         ((int)(sizeof(x) / sizeof 42[x])) // signed is convenient
#define COUNTOF_SAFE(x)    (COUNTOF(x) / IS_NOT_POINTER(x))

extern int x[10];
extern int *y;

int main(void) {
   printf("%d\n", COUNTOF(x));
   printf("%d\n", COUNTOF(y));
   printf("%d\n", COUNTOF_SAFE(x));
   printf("%d\n", COUNTOF_SAFE(y));
   return 0;
}

这在 gcc 4.1.2 中给出了编译时警告：

    foo.c:14: warning: division by zero

出于好奇，并不是我们真正关心，并且可能因版本而异，运行它会给出：

   10
   1
   10
   0

编辑：我对代码做了一点改动，删除了IS_NOT_POINTER(x) / IS_NOT_POINTER(x). 编译警告仍然存在，但现在在运行时它给出了正确的三个值，然后Floating point exception (core dumped).再次，我们不在乎，但这可能更好。

于 2012-10-12T00:33:31.647 回答
-2

是否有一种类型安全的方法来获取 C 中数组的元素计数？

我会说，不。上面的宏很好，但只有在传递真实数组时才能正常工作。

宏只是为了简化你的代码，当你想要类型安全时，你不应该依赖它们。如果这是你需要的，你不应该使用 C 或坚持它的规则。

于 2012-10-11T23:40:38.397 回答