在初始化的、未知大小的数组中使用 sizeof() - C++

Question

我是 C++ 编程新手，我正在尝试获取数组的大小。谁能解释我为什么会这样？我尝试在 runnable.com 中运行代码，结果显示相同。

我确定这不是正确的做法。如果可能的话，你能建议任何简单的方法来获取这种数组的大小吗？

#include <iostream>

using namespace std;

int main ()
{
  int set1[] = {1, 9, 3, 50, 31, 65};
  int set234[] = {3, 5, 5};

  cout << sizeof(set1) << endl;
  cout << sizeof(set234) << endl;

  cout << "When sizeof() return value is divided by 4"<< endl;
  cout << sizeof(set1) / 4 << endl; 
  cout << sizeof(set234) / 4 << endl;

  return 0;
}

****************************************************************
Output:
24
12
When sizeof() return value is divided by 4
6
3
****************************************************************

**编辑：感谢您的回复。 飞走了：D

Answer 1

数组的大小等于其所有元素的大小之和。在您的示例中，您处理 int 类型的数组，那么系统中的 sizeof( int ) 似乎等于 4，因此，由于第一个数组有 6 个元素，因此其大小等于 6 * sizeof( int )，即 24。第二个数组等于3 * sizeof( int )，即12。 例如，如果您系统中的 sizeof( int ) 等于 8，那么第一个数组的大小将等于 48 ( 6 * sizeof* int ) )，第二个数组的大小将等于 24 ( 3 *大小（整数））。

因此，例如，如果您想知道数组中有多少个元素，您可以按以下方式计算

sizeof( YouArray ) / sizeof( YourArray[0] )

或

sizeof( YouArray ) / sizeof( ElementType )

Answer 2

sizeof 返回字节数，而不是元素数。大多数情况下，您应该避免使用数组；使用std::vector 或std::array，两者都提供了一种简单的方法来获取元素的数量。

Answer 3

sizeof 以字节为单位返回数组的大小，而不是元素。看起来您在 32 位系统（或 LP64，意味着只有 long 和指针是 64 位，但 int 仍然是 32）上运行，所以整数数组中的每个元素都是 4 个字节。在您的 set1 中，即 6 个元素，即 6x4=24 字节。

要获取元素的大小，请执行 sizeof(set1)/sizeof(set1[0])。但是，这不适用于您在编译时列出了元素的数组。但是，如果您只有一个 int*，则 sizeof 运算符将返回指针的大小。

Answer 4

sizeof() 以字节为单位为您提供总大小。例如，如果 int 为 4，并且数组中有 6 个元素。它将返回 4*6=24 作为答案。因此，以下代码将为您提供数组的大小。

#include <iostream>

using namespace std;

int main ()
{
  int set1[] = {1, 9, 3, 50, 31, 65};
  int set234[] = {3, 5, 5};

  cout << (sizeof(set1))/4 << endl;
  cout << (sizeof(set234))/4 << endl;


  return 0;
}

你也可以用这个：

#include <iostream>
#include <array>

int main ()
{
  array<int,5> a;
  cout << "size is" << a.size();
return 0;
}

Answer 5

要获取分配在堆栈上的数组中的元素计数，通常的技术是获取整个数组的总大小（以字节为单位），然后将其除以大小，单个数组项的字节数：

<item count> = <total array size in bytes> / <single array item size in bytes>

但是，这个公式只能应用于在堆栈上分配的数组，不能应用于在堆上动态分配的数组（例如使用new[])：在后一种情况下，您需要将数组项计数作为单独的信息。

Microsoft Visual C++ 提供了一个方便的 _countof() 宏，它会为您执行上述计算，并且如果参数是 指针，安全地会中断编译过程，例如到一个动态分配的数组（因为在这种情况下，上面的公式给出了不正确的结果，即指针的大小 - 它是固定的，例如 32 位系统上的 4 个字节，并且与指向的数组大小无关 - 除以第一个指向的项目的大小）。

好像是there is an equivalent safe ARRAY_SIZE() macro for Linux。

Answer 6

#include <cstddef>

template<class T, std::size_t N>
std::size_t length_of( T(&)[N] ) {
  return N;
}

是解决您问题的模板。

C++11 中更工业化的版本是：

#include <array>

template<class T, std::size_t N>
constexpr std::size_t size( T(&)[N] ) {
  return N;
}
template<class T, std::size_t N>
constexpr std::size_t size( std::array<T,N> const& ) {
  return N;
}
template<class C,class=void>
struct has_size : std::false_type {};
template<class>using void_t=void;
template<class C, void_t< decltype( std::declval<C&>().size() ) > >
struct has_size : std::true_type {};

template<bool b, class T=void>using enable_if_t=typename std::enable_if<b,T>::type;

template<class C, class=enable_if_t< has_size<C>::value, bool[1] >>
constexpr std::size_t size( C const& c ) {
  return c.size();
}

template<class C, class=enable_if_t< !has_size<C>::value, bool[2] >>
constexpr std::size_t size( C const& c ) {
  using std::begin; using std::end;
  return end(c)-begin(c);
}

这可能太过分了。请注意，缺少大小的容器中的非随机访问迭代器可能无法编译（因为 - 通常未定义），这是有目的的（我们不想意外地做 O(n) 工作） .