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）），第二个数组的大小将等于18（3 * sizeof（int））。

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

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

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

在初始化的未知大小数组中使用sizeof（） - C ++

6 个答案: