数组大小 C++宏：它是如何工作的？

Question

好吧，我不完全是新手，但我不能说我理解下面的宏。最令人困惑的部分是将值转换为 size_t 的除法：这到底能实现什么？特别是，因为我看到一个否定运算符，据我所知，它可能会导致零值。这是否意味着它会导致除零错误？ （顺便说一句，宏是正确的并且工作得很好。）

#define ARRAYSIZE(a) \
  ((sizeof(a) / sizeof(*(a))) / \
  static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

Answer 1

最后的除法似乎是尝试检测非数组参数（例如指针）。

例如，它无法检测到 char*，但可以检测到 T*，其中 sizeof(T) 大于大小的一个指针。

在C++中，通常更喜欢以下函数模板：

typedef ptrdiff_t Size;

template< class Type, Size n >
Size countOf( Type (&)[n] ) { return n; }

该函数模板不能用指针参数实例化，只能用数组实例化。在 C++11 中，它也可以用 std::begin 和 std::end 来表达，这会自动让它适用于具有随机访问迭代器的标准容器。

限制：不适用于 C++03 中的本地类型数组，并且不会产生编译时间大小。

对于编译时间大小，您可以像免责声明一样执行

template< Size n > struct Sizer { char elems[n]; };

template< class Type, size n >
Sizer<n> countOf_( Type (&)[n] );

#define COUNT_OF( a ) sizeof( countOf_( a ).elems )

：所有代码均未经过编译器的处理。

但一般来说，只需使用第一个函数模板，countOf。

干杯&嗯。

Answer 2

假设我们有

T arr[42];

ARRAYSIZE(arr) 将扩展为（大致），

sizeof (arr) / sizeof(*arr) / !(sizeof(arr) % sizeof(*arr))

在这种情况下给出 42/!0 即 42

如果由于某种原因 sizeof 数组不能被 sizeof 其元素整除，则除以零将发生。什么时候可以发生？例如，当您传递动态分配的数组而不是静态数组时！

Answer 3

它确实会导致除零错误（故意）。该宏的工作方式是将数组的大小（以字节为单位）除以单个数组元素的大小（以字节为单位）。因此，如果您有一个 int 值数组，其中 int 为 4 个字节（在大多数 32 位机器上），则一个包含 4 个 int 的数组> 值将为 16 字节。

因此，当您在这样的数组上调用此宏时，它会执行 sizeof(array) / sizeof(*array) 操作。由于 16 / 4 = 4，它返回数组中有 4 个元素。

注意：*array 取消引用数组的第一个元素，相当于 array[0]。

第二次除法进行模除（获取除法的余数），并且由于任何非零值都被视为“true”，因此使用 ! 运算符将导致除以零，如果除法非零（同样，否则除以 1）。

Answer 4

除零可能会尝试捕获由任何原因引起的对齐错误。就像在某些编译器设置下，数组元素的大小为 3，但编译器会将其四舍五入为 4 以加快数组访问速度，那么包含 4 个条目的数组的大小将为 16，并且 !(16/3) 将变为为零，在编译时除以零。然而，我不知道有任何编译器这样做，并且 sizeof 返回与数组中该类型的大小不同的大小可能违反 C++ 规范。

Answer 5

来晚了……

谷歌的 C++ 代码库有恕我直言 的 arraysize() 宏的最终 C++ 实现，其中包括一些此处未考虑的问题。

我无法改进 来源，注释清晰完整。

Answer 6

第一部分 (sizeof(a) / sizeof(*(a))) 相当简单；它将整个数组的大小（假设您向宏传递数组类型的对象，而不是指针）除以第一个元素的大小。这给出了数组中元素的数量。

第二部分就不那么简单了。我认为潜在的被零除是故意的；如果出于某种原因，数组的大小不是其元素之一的整数倍，则会导致编译时错误。换句话说，这是某种编译时健全性检查。

但是，我不知道在什么情况下会发生这种情况...正如人们在下面的评论中所建议的那样，它会捕获一些误用（例如在一个指针）。但它不会捕获所有这样的错误。

Answer 7

我写了这个宏的这个版本。考虑旧版本：

#include <sys/stat.h>
#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))

int main(int argc, char *argv[]) {
  struct stat stats[32];
  std::cout << "sizeof stats = " << (sizeof stats) << "\n";
  std::cout << "sizeof *stats = " << (sizeof *stats) << "\n";
  std::cout << "ARRAYSIZE=" << ARRAYSIZE(stats) << "\n";

  foo(stats);
}

void foo(struct stat stats[32]) {
  std::cout << "sizeof stats = " << (sizeof stats) << "\n";
  std::cout << "sizeof *stats = " << (sizeof *stats) << "\n";
  std::cout << "ARRAYSIZE=" << ARRAYSIZE(stats) << "\n";
}

在 64 位计算机上，此代码会生成以下输出：

sizeof stats = 4608
sizeof *stats = 144
ARRAYSIZE=32
sizeof stats = 8
sizeof *stats = 144
ARRAYSIZE=0

发生了什么？ ARRAYSIZE 是如何从 32 变为 0 的？问题是函数参数实际上是一个指针，尽管它看起来像一个数组。所以在 foo 内部，“sizeof(stats)”是 8 个字节，“sizeof(*stats)”仍然是 144。

使用新宏：

#define ARRAYSIZE(a) \
  ((sizeof(a) / sizeof(*(a))) / \
  static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

当 sizeof(a) 不是 sizeof(* (a)) 的倍数时， % 不为零，其中 !反转，然后 static_cast 的计算结果为零，导致编译时除以零。因此，在宏中可能的范围内，这种奇怪的除法在编译时捕获了问题。

PS：在C++17中，只需使用std::size，参见http://en .cppreference.com/w/cpp/iterator/size