在初始化，未知大小的数组中使用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）），并且大小第二个数组将等于18（3 * sizeof（int））。

所以，如果你想例如知道有多少元素有一个数组，你可以计算出下面这样的方式

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

或

sizeof(YouArray)/sizeof(ElementType) 

Answer 2

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

要获取元素的大小，请执行sizeof（set1）/ sizeof（set1 [0]）。不过，这对编译时列出元素的数组起作用。但是，如果您只有一个int *，sizeof运算符将返回指针的大小。

Answer 3

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 4

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

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）工作）。