blocks|key|1551076|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1551077|sizeof(list)+/+sizeof(list[0]);|code-block|syntax|javascript|1551078|因为这个问题被标记为C%2B%2B，所以建议在C%2B%2B中使用std::vector，而不是使用传统的C样式数组。|offset|length|style|CODE|1551079|1551080|当您将array-type传递给函数时，它将被隐式转换为pointer-type。看看this.|1551081|为了正确地打印任何函数中数组的大小，请引用该函数传递数组(但您需要事先知道该数组的大小)。|1551082|在一般情况下，你会这样做|1551083|template<typename+T,int+N>+
//template+argument+deduction
int+size(T+(&arr1)[N])+//Passing+the+array+by+reference+
{
+++return+sizeof(arr1)/sizeof(arr1[0]);+//Correctly+returns+the+size+of+'list'
+++//+or
+++return+N;+//Correctly+returns+the+size+too+[cool+trick+;-)]
}|1551084|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1975128/sizeof-an-array-in-the-c-programming-language/1975133#1975133^0|0|0|P|B|0|0|3|A|S|C|17|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]]|9|@$I|1E|J|1F|1|1G]]|A|$]]|$1|P|3|Q|5|6|7|1H|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|V|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

Try this:

<pre><code>sizeof(list) / sizeof(list[0]);
</code></pre>

Because this question is tagged C++, it is always recommended to use <code>std::vector</code> in C++ rather than using conventional C-style arrays.

<hr>

An <code>array-type</code> is implicitly converted into a <code>pointer-type</code> when you pass it to a function.
Have a look at <a href="https://stackoverflow.com/questions/1975128/sizeof-an-array-in-the-c-programming-language/1975133#1975133">this.</a>

In order to correctly print the sizeof an array inside any function, pass the array by reference to that function (but you need to know the size of that array in advance).

You would do it like so for the general case

<pre><code>template&lt;typename T,int N&gt; 
//template argument deduction
int size(T (&amp;arr1)[N]) //Passing the array by reference 
{
 return sizeof(arr1)/sizeof(arr1[0]); //Correctly returns the size of 'list'
 // or
 return N; //Correctly returns the size too [cool trick ;-)]
}
</code></pre>

blocks|key|729549|text|这样做的“标准”C方法是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|729550|sizeof(list)+/+sizeof(list[0])|code-block|syntax|javascript|729551|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The "standard" C way to do this is

<pre><code>sizeof(list) / sizeof(list[0])
</code></pre>

blocks|key|1551169|text|您可以使用boost::size，它基本上是这样定义的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1551170|template+<typename+T,+std::size_t+N>
std::size_t+size(T+const+(&)[N])
{
++++return+N;
}|code-block|syntax|javascript|1551171|请注意，如果要将大小用作常量表达式，则必须使用sizeof+a+/+sizeof+a[0]成语或等待下一个版本的C%2B%2B标准。|1551172|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_41_0/libs/range/doc/boost_range.html^0|5|B|5|B|0|0|0|N|M|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You could use <a href="http://www.boost.org/doc/libs/1_41_0/libs/range/doc/boost_range.html" rel="noreferrer"><code>boost::size</code></a>, which is basically defined this way:

<pre><code>template &lt;typename T, std::size_t N&gt;
std::size_t size(T const (&amp;)[N])
{
 return N;
}
</code></pre>

Note that if you want to use the size as a constant expression, you'll either have to use the <code>sizeof a / sizeof a[0]</code> idiom or wait for the next version of the C++ standard.

blocks|key|1518883|text|对于动态分配的数组(或指针)，您不能这样做。对于静态数组，可以使用sizeof(array)获取整个数组大小(以字节为单位)，并将其除以每个元素的大小：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1518884|#define+COUNTOF(x)+(sizeof(x)/sizeof(*x))|code-block|syntax|javascript|1518885|要获得动态数组的大小，您必须手动跟踪它并将其传递给它，或者使用一个哨兵值来终止它(如以空结束的字符串中的'\0‘)。|1518886|更新：--我意识到您的问题是标记为C%2B%2B而不是C。如果您想在C%2B%2B中传递内容，则绝对应该考虑在C%2B%2B中使用std::vector而不是数组：|BOLD|1518887|std::vector<int>+v;
v.push_back(1);
v.push_back(2);
std::cout+<<+v.size()+<<+std::endl;+//+prints+2|1518888|entityMap^0|X|D|0|0|0|0|3|1H|B|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Y|8|@$9|Z|A|10|B|O]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|R|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|S|$]]

You can't do that for a dynamically allocated array (or a pointer). For static arrays, you can use <code>sizeof(array)</code> to get the whole array size in bytes and divide it by the size of each element:

<pre><code>#define COUNTOF(x) (sizeof(x)/sizeof(*x))
</code></pre>

To get the size of a dynamic array, you have to keep track of it manually and pass it around with it, or terminate it with a sentinel value (like '\0' in null terminated strings).

Update: I realized that your question is tagged C++ and not C. You should definitely consider using <code>std::vector</code> instead of arrays in C++ if you want to pass things around:

<pre><code>std::vector&lt;int&gt; v;
v.push_back(1);
v.push_back(2);
std::cout &lt;&lt; v.size() &lt;&lt; std::endl; // prints 2
</code></pre>

blocks|key|732996|text|由于您已经将其标记为C%2B%2B，因此值得一提的是，有一种比C样式宏更好的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|732997|template+<class+T,+size_t+N>
size_t+countof(const+T+&array[N])+{+return+N;+}|code-block|syntax|javascript|732998|这样做的好处是，如果您不小心试图将数组以外的东西传递给它，代码就不会编译(而传递到C宏的指针会编译，但会产生糟糕的结果。缺点是这不能给您提供编译时常量，所以您不能这样做：|732999|int+a[20];

char+x[countof(a)];|733000|在C%2B%2B11或更高版本中，可以添加constexpr以获得编译时常量：|offset|length|style|CODE|733001|template+<class+T,+size_t+N>
constexpr+size_t+countof(const+T+&array[N])+{+return+N;+}|733002|如果您真的想在旧的编译器上支持同样的功能，那么有一种方法，最初是由Ivan+Johnson，AFAIK发明的：|733003|#define+COUNTOF(x)++(+++++++++++++++++++++++++++++++++++++++++++\
++0+*+sizeof(+reinterpret_cast<const+::Bad_arg_to_COUNTOF*>(x)+)+%2B++\
++0+*+sizeof(+::Bad_arg_to_COUNTOF::check_type((x),+&(x))++++++)+%2B++\
++sizeof(x)+/+sizeof((x)[0])++)++++++++++++++++++++++++++++++++++


class+Bad_arg_to_COUNTOF
{
public:
+++class+Is_pointer;
+++class+Is_array+{};++
+++template<typename+T>
+++static+Is_pointer+check_type(const+T*,+const+T*+const*);
+++static+Is_array+check_type(const+void*,+const+void*);
};|733004|这使用了/sizeof(X)计算大小，就像C宏所做的那样，因此它提供了一个编译时常数。不同之处在于，如果您传递的不是数组的名称，那么它首先使用一些模板魔术来导致编译错误。它可以通过重载check_type来返回指针的不完全类型，但是返回数组的完整类型。然后(真正棘手的部分)它实际上根本没有调用那个函数--它只是取函数返回的类型的大小，对于返回完整类型的重载是零，但是不完全类型不允许(强制编译错误)。|733005|IMO，这是模板元编程的一个很酷的例子--尽管诚实地说，结果是毫无意义的。只有在使用数组时，才需要将该大小作为编译时间常数，在任何情况下，通常都应该避免这种情况。使用std::vector，可以在运行时提供大小(并在需要时调整矢量的大小)。|733006|entityMap^0|0|0|0|0|H|9|0|0|0|0|0|2B|B|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@$M|1E|N|1F|O|P]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|11|$]]

Since you've marked this as C++, it's worth mentioning that there is a somewhat better way than the C-style macro:

<pre><code>template &lt;class T, size_t N&gt;
size_t countof(const T &amp;array[N]) { return N; }
</code></pre>

This has the advantage that if you accidentally try to pass something other than an array to it, the code simply won't compile (whereas passing a pointer to the C macro will compile but produce a bad result. The disadvantage is that this doesn't give you a compile-time constant, so you can't do something like this:

<pre><code>int a[20];

char x[countof(a)];
</code></pre>

In C++11 or newer, you can add <code>constexpr</code> to get a compile-time constant:

<pre><code>template &lt;class T, size_t N&gt;
constexpr size_t countof(const T &amp;array[N]) { return N; }
</code></pre>

If you really want to support the same on older compilers, there is a way, originally invented by Ivan Johnson, AFAIK:

<pre><code>#define COUNTOF(x) ( \
 0 * sizeof( reinterpret_cast&lt;const ::Bad_arg_to_COUNTOF*&gt;(x) ) + \
 0 * sizeof( ::Bad_arg_to_COUNTOF::check_type((x), &amp;(x)) ) + \
 sizeof(x) / sizeof((x)[0]) ) 


class Bad_arg_to_COUNTOF
{
public:
 class Is_pointer;
 class Is_array {}; 
 template&lt;typename T&gt;
 static Is_pointer check_type(const T*, const T* const*);
 static Is_array check_type(const void*, const void*);
};
</code></pre>

This uses sizeof(x)/sizeof(x[0]) to compute the size, just like the C macro does, so it gives a compile-time constant. The difference is that it first uses some template magic to cause a compile error if what you've passed isn't the name of an array. It does that by overloading check_type to return an incomplete type for a pointer, but a complete type for an array. Then (the really tricky part) it doesn't actually call that function at all -- it just takes the size of the type the function would return, which is zero for the overload that returns the complete type, but not allowed (forcing a compile error) for the incomplete type.

IMO, that's a pretty cool example of template meta programming -- though in all honesty, the result is kind of pointless. You really only need that size as a compile time constant if you're using arrays, which you should normally avoid in any case. Using <code>std::vector</code>, it's fine to supply the size at run-time (and resize the vector when/if needed).

blocks|key|1551139|text|除了卡尔的回答之外，“标准”C%2B%2B方法不是使用C+int数组，而是使用类似于C%2B%2B+STL+std::vector<int>+list的东西，您可以查询list.size()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1551140|entityMap^0|P|3|1A|L|24|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

Besides Carl's answer, the "standard" C++ way is not to use a C <code>int</code> array, but rather something like a C++ STL <code>std::vector&lt;int&gt; list</code> which you can query for <code>list.size()</code>.

blocks|key|729667|text|当你把任何数组传递给某个函数时。你只是传递它的起始地址，所以它要工作，你必须传递它的大小，也为了它的正常工作。这也是我们为什么在命令行争论中通过argc和argv[]的原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|729668|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

when u pass any array to some function. u are just passing it's starting address, so for it to work u have to pass it size also for it to work properly. it's the same reason why we pass argc with argv[] in command line arguement.

blocks|key|1519619|text|您可以创建一个模板函数，并通过引用传递数组来实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1519620|这是我的代码片段|1519621|template+<typename+TypeOfData>


void+PrintArray(TypeOfData+&arrayOfType);

int+main()

{

++++char+charArray[]+=+"my+name+is";

++++int+intArray[]+=+{+1,2,3,4,5,6+};

++++double+doubleArray[]+=+{+1.1,2.2,3.3+};


++++PrintArray(charArray);

++++PrintArray(intArray);

++++PrintArray(doubleArray);

}


template+<typename+TypeOfData>

void+PrintArray(TypeOfData+&arrayOfType)

{

++++int+elementsCount+=+sizeof(arrayOfType)+/+sizeof(arrayOfType[0]);


++++for+(int+i+=+0;+i+<+elementsCount;+i%2B%2B)

++++{

++++++++cout+<<+"Value+in+elements+at+position+"+<<+i+%2B+1+<<+"+is+"+<<+arrayOfType[i]+<<+endl;

++++}

}|code-block|syntax|javascript|1519622|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can make a template function, and pass the array by reference to achieve this.

Here is my code snippet

<pre><code>template &lt;typename TypeOfData&gt;


void PrintArray(TypeOfData &amp;arrayOfType);

int main()

{

 char charArray[] = "my name is";

 int intArray[] = { 1,2,3,4,5,6 };

 double doubleArray[] = { 1.1,2.2,3.3 };


 PrintArray(charArray);

 PrintArray(intArray);

 PrintArray(doubleArray);

}


template &lt;typename TypeOfData&gt;

void PrintArray(TypeOfData &amp;arrayOfType)

{

 int elementsCount = sizeof(arrayOfType) / sizeof(arrayOfType[0]);


 for (int i = 0; i &lt; elementsCount; i++)

 {

 cout &lt;&lt; "Value in elements at position " &lt;&lt; i + 1 &lt;&lt; " is " &lt;&lt; arrayOfType[i] &lt;&lt; endl;

 }

}
</code></pre>

blocks|key|1551306|text|您必须使用sizeof()函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1551307|代码片段：|1551308|#include<bits/stdc%2B%2B.h>
using+namespace+std;

int+main()
{
++++++ios::sync_with_stdio(false);

++++++int+arr[]+={5,+3,+6,+7};

++++++int+size+=+sizeof(arr)+/+sizeof(arr[0]);
++++++cout<<size<<endl;

++++++return+0;
}|code-block|syntax|javascript|1551309|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You have to use sizeof() function.

<h2>Code Snippet:</h2>

<pre><code>#include&lt;bits/stdc++.h&gt;
using namespace std;

int main()
{
 ios::sync_with_stdio(false);

 int arr[] ={5, 3, 6, 7};

 int size = sizeof(arr) / sizeof(arr[0]);
 cout&lt;&lt;size&lt;&lt;endl;

 return 0;
}
</code></pre>

blocks|key|1551316|text|int+arr1[]+=+{8,+15,+3,+7};
int+n+=+sizeof(arr1)/sizeof(arr1[0]);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1551317|基本上，arr1给出了要指向的对象的大小，每个元素可能占用多个位，除以每个元素的位数(Arr1)给出了要查找的元素的实际数量，即我的示例中的4个。|unstyled|1551318|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>int arr1[] = {8, 15, 3, 7};
int n = sizeof(arr1)/sizeof(arr1[0]);
</code></pre>

So basically sizeof(arr1) is giving the size of the object being pointed to, each element maybe occupying multiple bits so dividing by the number of bits per element (sizeof(arr1[0]) gives you the actual number of elements you're looking for, i.e. 4 in my example.

blocks|key|733057|text|当您使用一个类时，此方法可以工作:在本例中，您将收到一个数组，因此，唯一对我有效的方法是以下方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|733058|template+<typename+T,+size_t+n,+size_t+m>+++
Matrix&+operator=+(T+(&a)[n][m])
{+++

++++int+arows+=+n;
++++int+acols+=+m;

++++p+=+new+double*[arows];

++++for+(register+int+r+=+0;+r+<+arows;+r%2B%2B)
++++{
++++++++p[r]+=+new+double[acols];


++++++++for+(register+int+c+=+0;+c+<+acols;+c%2B%2B)
++++++++{
++++++++++++p[r][c]+=+a[r][c];+//A[rows][columns]
++++++++}|code-block|syntax|javascript|733059|}|733060|https://www.geeksforgeeks.org/how-to-print-size-of-an-array-in-a-function-in-c/|offset|length|733061|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|27|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

This method work when you are using a class: In this example you will receive a array, so the only method that worked for me was these one:

<pre><code>template &lt;typename T, size_t n, size_t m&gt; 
Matrix&amp; operator= (T (&amp;a)[n][m])
{ 

 int arows = n;
 int acols = m;

 p = new double*[arows];

 for (register int r = 0; r &lt; arows; r++)
 {
 p[r] = new double[acols];


 for (register int c = 0; c &lt; acols; c++)
 {
 p[r][c] = a[r][c]; //A[rows][columns]
 }
</code></pre>

}

<a href="https://www.geeksforgeeks.org/how-to-print-size-of-an-array-in-a-function-in-c/" rel="nofollow noreferrer">https://www.geeksforgeeks.org/how-to-print-size-of-an-array-in-a-function-in-c/</a>

blocks|key|733091|text|如果您想知道数组有多少数字，则需要知道数组长度。C中的函数sizeof(var)给出了计算机内存中的字节。因此，如果您知道int占用的内存，您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|733092|int+arraylength(int+array[])+{
++++return+sizeof(array)+/+sizeof(int);+//+Size+of+the+Array+divided+by+the+int+size
}|code-block|syntax|javascript|733093|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to know how much numbers the array have, you want to know the array length. The function sizeof(var) in C gives you the bytes in the computer memory. So if you know the memory the int occupy you can do like this:
<pre><code>int arraylength(int array[]) {
 return sizeof(array) / sizeof(int); // Size of the Array divided by the int size
}
</code></pre>

blocks|key|1551527|text|假设您只想知道一个数组的大小，它的类型是(int)，但它的大小(很明显，您不知道)适合于验证该数组是否为空，否则您将得到一个除数为零(导致一个Float+point+exception)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1551528|int+array_size(int+array[])+{
++++if(sizeof(array)+==+0)+{
++++++++return+0;
++++}
++++return+sizeof(array)/sizeof(array[0]);
+}|code-block|syntax|javascript|1551529|entityMap^0|1Z|L|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Assuming you merely want to know the size of an array whose type you know (int) but whose size, obviously, you don't know, it is suitable to verify whether the array is empty, otherwise you will end up with a division by zero (causing a <code>Float point exception</code>).

<pre><code>int array_size(int array[]) {
 if(sizeof(array) == 0) {
 return 0;
 }
 return sizeof(array)/sizeof(array[0]);
 }
</code></pre>

I have

<pre><code>int list[] = {1, 2, 3};
</code></pre>

How to I get the size of <code>list</code>?

I know that for a char array, we can use <code>strlen(array)</code> to find the size, or check with <code>'\0'</code> at the end of the array. 

<hr>

I tried <code>sizeof(array) / sizeof(array[0])</code> as some answers said, but it only works in main? For example:

<pre><code>int size(int arr1[]){
 return sizeof(arr1) / sizeof(arr1[0]);
}

int main() {
 int list[] = {1, 2, 3};

 int size1 = sizeof(list) / sizeof(list[0]); // ok
 int size2 = size(list_1); // no
 // size1 and size2 are not the same
}
</code></pre>

Why?

How to find the size of an int[]?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有过int list[] = {1, 2, 3};如何获得list的大小我知道，对于char数组，我们可以使用strlen(array)来查找大小，或者在数组末尾使用'\0'进行检查。正如一些答案所说的，我尝试了sizeof(array) / sizeof(array[0])，但它只在主要方面起作用？例如：int size(int arr1[]){    return sizeof(arr1) 

问如何找到int[]的大小？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何找到int[]的大小？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何找到int[]的大小？
EN