blocks|key|190508|text|在C数组中，C中的参数实际上只是指针，因此sizeof()无法工作。您要么需要将size作为另一个参数传递，要么使用一个前哨--以最适合您的设计为准。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|190509|其他一些选项：|190510|其他一些信息：|190511|对于|190512|+C%2B%2B，您可能希望让参数使用将数组包装在跟踪数组大小并提供以安全方式将数据复制到数组中的方法的类模板中，而不是传递原始数组指针。像STLSoft's+array_proxy+template或Boost's+boost::array这样的东西可能会有所帮助。我以前使用过array_proxy模板，效果很好。在使用参数的函数内部，您可以获得类似std::vector的操作，但是函数的调用者可以使用一个简单的C数组。不需要复制数组-sizeof模板负责将数组指针和数组大小打包在C中用于确定数组中元素数量的automatically.|unordered-list-item|190513|a宏中(因为当sizeof()可能有帮助时-例如，您正在处理的不是简单的指针)：Is+there+a+standard+function+in+C+that+would+return+the+length+of+an+array?|190514|190515|190516|entityMap|0|LINK|mutability|MUTABLE|url|http://www.stlsoft.org/doc-1.9/classstlsoft%255F1%255F1array%255F%255Fproxy.html|1|http://www.boost.org/doc/libs/1%255F38%255F0/doc/html/array.html|2|https://stackoverflow.com/questions/1598773/is-there-a-standard-function-in-c-that-would-return-the-length-of-an-array/1598827#1598827^0|L|8|0|0|0|0|3S|B|4T|B|1U|U|0|2P|K|1|0|14|23|2|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|19|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]|$9|1I|A|1J|1|1K]]|E|$]]|$1|O|3|P|5|N|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

In C array parameters in C are really just pointers so <code>sizeof()</code> won't work. You either need to pass in the size as another parameter or use a sentinel - whichever is most appropriate for your design.

Some other options:

Some other info:

<ul>
<li>for C++, instead of passing a raw array pointer, you might want to have the parameter use something that wraps the array in a class template that keeps track of the array size and provides methods to copy data into the array in a safe manner. Something like <a href="http://www.stlsoft.org/doc-1.9/classstlsoft%5F1%5F1array%5F%5Fproxy.html" rel="nofollow noreferrer">STLSoft's array_proxy template</a> or <a href="http://www.boost.org/doc/libs/1%5F38%5F0/doc/html/array.html" rel="nofollow noreferrer">Boost's boost::array</a> might help. I've used an <code>array_proxy</code> template to nice effect before. Inside the function using the parameter, you get <code>std::vector</code> like operations, but the caller of the function can be using a simple C array. There's no copying of the array - the <code>array_proxy</code> template takes care of packaging the array pointer and the array's size nearly automatically.</li>
<li>a macro to use in C for determining the number of elements in an array (for when sizeof() might help - ie., you're not dealing with a simple pointer): <a href="https://stackoverflow.com/questions/1598773/is-there-a-standard-function-in-c-that-would-return-the-length-of-an-array/1598827#1598827">Is there a standard function in C that would return the length of an array?</a></li>
</ul>

blocks|key|938863|text|您可以传递大小，使用前哨，甚至更好地使用std::vector。尽管std::vector没有初始化器列表，但仍然可以很容易地用一组元素构造一个向量(尽管不是很好)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938864|static+const+int+arr[]+=+{1,2,3,4,5};
vector<int>+vec+(arr,+arr+%2B+sizeof(arr)+/+sizeof(arr[0])+);|code-block|syntax|javascript|938865|vector类也使得犯错误变得更加困难，这是有价值的。另一个好处是所有的C%2B%2B都应该熟悉它，并且大多数C%2B%2B应用程序都应该使用std::vector而不是原始的C数组。|938866|作为快速说明，C%2B%2B0x添加了Initializer+lists|offset|length|938867|std::vector<int>+v+=+{1,+2,+3,+4};|938868|您也可以使用Boost.Assign来做同样的事情，尽管语法有点复杂。|938869|std::vector<int>+v+=+boost::assign::list_of(1)(2)(3)(4);|938870|或|938871|std::vector<int>+v;
v+%2B=+1,+2,+3,+4;|938872|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C%252B%252B0x#Initializer_lists|1|http://www.boost.org/doc/libs/1_42_0/libs/assign/doc/index.html^0|0|0|0|F|H|0|0|0|6|C|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@$K|1A|L|1B|1|1C]]|A|$]]|$1|M|3|N|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1E|8|@]|9|@$K|1F|L|1G|1|1H]]|A|$]]|$1|Q|3|R|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

You can either pass the size around, use a sentinel or even better use std::vector. Even though std::vector lacks initializer lists it is still easy to construct a vector with a set of elements (although not quite as nice)

<pre><code>static const int arr[] = {1,2,3,4,5};
vector&lt;int&gt; vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );
</code></pre>

The std::vector class also makes making mistakes far harder, which is worth its weight in gold. Another bonus is that all C++ should be familiar with it and most C++ applications should be using a std::vector rather than a raw C array.

As a quick note, C++0x adds <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Initializer_lists" rel="nofollow noreferrer">Initializer lists</a>

<pre><code>std::vector&lt;int&gt; v = {1, 2, 3, 4};
</code></pre>

You can also use <a href="http://www.boost.org/doc/libs/1_42_0/libs/assign/doc/index.html" rel="nofollow noreferrer">Boost.Assign</a> to do the same thing although the syntax is a bit more convoluted.

<pre><code>std::vector&lt;int&gt; v = boost::assign::list_of(1)(2)(3)(4);
</code></pre>

or

<pre><code>std::vector&lt;int&gt; v;
v += 1, 2, 3, 4;
</code></pre>

blocks|key|2751566|text|C不提供对此的本机支持。一旦数组被传递到其声明的作用域之外，它的大小就会丢失。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2751567|可以将大小与数组一起传递。如果你总是想保持大小，你甚至可以将它们捆绑到一个结构中，尽管这样会有一些记账开销。|2751568|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

c provides no native support for this. Once an array is passed out of its declared scope, its size is lost.

You can pass the size with the array. You can even bundle them into a structure if you always to to keep the size, though you'll have some bookkeepping overhead with that.

blocks|key|1342895|text|这个怎么样？..|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1342896|template+<int+N>
void+foo(int+(&x)[N])+{
++++std::cerr+<<+N;
}|code-block|syntax|javascript|1342897|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|$]]

How about this?..

<pre><code>template &lt;int N&gt;
void foo(int (&x)[N]) {
 std::cerr &lt;&lt; N;
}</code></pre>

blocks|key|190615|text|您需要将大小与数组一起传递，就像在许多库函数中一样，例如strncpy()、strncmp()等。对不起，这只是它在C:-)中的工作方式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|190616|或者，您可以推出自己的结构，如下所示：|190617|struct+array+{
++++int*+data;
++++int+size;
};|code-block|syntax|javascript|190618|并在你的代码中传递它。|190619|当然，如果你想成为更多的C%2B%2B+-ish，你仍然可以使用std::list或std::vector。|190620|entityMap^0|S|9|12|9|0|0|0|0|S|9|12|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

You need to pass the size along with the array, just like it is done in many library functions, for instance <code>strncpy()</code>, <code>strncmp()</code> etc. Sorry, this is just the way it works in C:-).

Alternatively you could roll out your own structure like:

<pre><code>struct array {
 int* data;
 int size;
};
</code></pre>

and pass it around your code.

Of course you can still use <code>std::list</code> or <code>std::vector</code> if you want to be more C++ -ish.

blocks|key|1342990|text|GNU+Libstdc%2B%2B文档中提到的一个函数是lengthof函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1342991|template<typename+T,+unsigned+int+sz>
inline+unsigned+int+lengthof(T+(&)[sz])+{+return+sz;+}|code-block|syntax|javascript|1342992|您可以将其用作|1342993|int+x[]+=+{1,2,3,4,5};
std::cerr+<<+lengthof(x)+<<+std::endl;|1342994|警告:仅当阵列没有decayed+into+a+pointer时，这才起作用。|1342995|entityMap|0|LINK|mutability|MUTABLE|url|http://c-faq.com/aryptr/aryptrequiv.html^0|O|8|0|0|0|0|9|M|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]]|E|$]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

A <a href="http://gcc.gnu.org/onlinedocs/libstdc++/manual/containers_and_c.html" rel="noreferrer">common idiom</a> mentioned in GNU Libstdc++ documentation is the <code>lengthof</code> function:

<pre><code>template&lt;typename T, unsigned int sz&gt;
inline unsigned int lengthof(T (&amp;)[sz]) { return sz; }
</code></pre>

You can use it as

<pre><code>int x[] = {1,2,3,4,5};
std::cerr &lt;&lt; lengthof(x) &lt;&lt; std::endl;
</code></pre>

Warning: this will work only when the array has not <a href="http://c-faq.com/aryptr/aryptrequiv.html" rel="noreferrer">decayed into a pointer</a>.

blocks|key|190648|text|除非数组表达式是sizeof或address-of+(&)运算符的操作数，或者如果数组表达式是用于初始化声明中另一个数组的字符串文字，否则数组表达式的类型将隐式地从“T的N元素数组”转换为“指向T的指针”，并且它的值将是数组中第一个元素的地址。简而言之，您不能将数组作为数组传递给函数；函数接收的是指针值，而不是数组值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|190649|您必须将数组大小作为单独的参数传递。|190650|因为您使用的是C%2B%2B，所以使用向量(或其他合适的STL容器)而不是C样式的数组。是的，您失去了方便的速记语法，但权衡是非常值得的。我是认真的。|190651|entityMap^0|8|6|R|1|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

An array expression will have its type implicitly converted from "N-element array of T" to "pointer to T" and its value will be the address of the first element in the array, unless the array expression is the operand of either the <code>sizeof</code> or address-of (<code>&amp;</code>) operators, or if the array expression is a string literal being used to initialize another array in a declaration. In short, you can't pass an array to a function as an array; what the function receives is a pointer value, not an array value. 

You have to pass the array size as a separate parameter. 

Since you're using C++, use vectors (or some other suitable STL container) instead of C-style arrays. Yes, you lose the handy shorthand syntax, but the tradeoff is more than worth it. Seriously.

blocks|key|1343053|text|自c%2B%2B11以来，有一种非常方便的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1343054|static+const+int+array[]+=+{+1,+2,+3,+6+};
int+size+=+(int)std::distance(std::begin(array),+std::end(array))%2B1;|code-block|syntax|javascript|1343055|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|$]]

Since c++11, there is a very convenient way:

<pre><code>static const int array[] = { 1, 2, 3, 6 };
int size = (int)std::distance(std::begin(array), std::end(array))+1;
</code></pre>

blocks|key|2751801|text|现在，你可以使用C%2B%2B11的extent和rank了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2751802|举个例子：|2751803|#include+<iostream>
#include+<type_traits>

int+main()
{
++int+a[][3]+=+{{1,+2,+3},+{4,+5,+6}};

++std::cout+<<+"\nRank:+++++++++++:+"+<<+std::rank<decltype(a)>::value;
++std::cout+<<+"\nSize:+[_here_][]:+"+<<+std::extent<decltype(a),+0>::value;
++std::cout+<<+"\nSize:+[][_here_]:+"+<<+std::extent<decltype(a),+1>::value;
++std::cout+<<+"\nSize:+[][]_here_:+"+<<+std::extent<decltype(a),+2>::value;
}|code-block|syntax|javascript|2751804|打印：|2751805|2751806|等级：：2大小：_here_：2大小：：3大小：_here_：0|blockquote|2751807|2751808|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/types/extent|1|https://en.cppreference.com/w/cpp/types/rank^0|E|6|0|L|4|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]|$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|N|3|O|5|P|7|1C|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|10]]]]

Now, you can use C++11's <a href="https://en.cppreference.com/w/cpp/types/extent" rel="nofollow noreferrer">extent</a> and <a href="https://en.cppreference.com/w/cpp/types/rank" rel="nofollow noreferrer">rank</a>.
By example:
<pre><code>#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main()
{
 int a[][3] = {{1, 2, 3}, {4, 5, 6}};

 std::cout &lt;&lt; &quot;\nRank: : &quot; &lt;&lt; std::rank&lt;decltype(a)&gt;::value;
 std::cout &lt;&lt; &quot;\nSize: [_here_][]: &quot; &lt;&lt; std::extent&lt;decltype(a), 0&gt;::value;
 std::cout &lt;&lt; &quot;\nSize: [][_here_]: &quot; &lt;&lt; std::extent&lt;decltype(a), 1&gt;::value;
 std::cout &lt;&lt; &quot;\nSize: [][]_here_: &quot; &lt;&lt; std::extent&lt;decltype(a), 2&gt;::value;
}
</code></pre>
prints:
<blockquote>
<pre><code>Rank: : 2
Size: [_here_][]: 2
Size: [][_here_]: 3
Size: [][]_here_: 0
</code></pre>
</blockquote>

How do I reliably get the size of a C-style array? The method often recommended seems to be to use <code>sizeof</code>, but it doesn't work in the <code>foo</code> function, where <code>x</code> is passed in:

<pre><code>#include &lt;iostream&gt;

void foo(int x[]) {
 std::cerr &lt;&lt; (sizeof(x) / sizeof(int)); // 2 
}

int main(){
 int x[] = {1,2,3,4,5};
 std::cerr &lt;&lt; (sizeof(x) / sizeof(int)); // 5 
 foo(x);
 return 0;
}
</code></pre>

Answers to <a href="https://stackoverflow.com/questions/1969588/looping-a-fixed-size-array-without-defining-its-size-in-c">this question</a> recommend <code>sizeof</code> but they don't say that it (apparently?) doesn't work if you pass the array around. So, do I have to use a sentinel instead? (I don't think the users of my <code>foo</code> function can always be trusted to put a sentinel at the end. Of course, I could use <code>std::vector</code>, but then I don't get the nice shorthand syntax <code>{1,2,3,4,5}</code>.)

How to reliably get size of C-style array?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

如何可靠地获得C样式数组的大小？通常推荐的方法似乎是使用sizeof，但它在传入x的foo函数中不起作用：#include <iostream>void foo(int x[]) { std::cerr << (sizeof(x) / sizeof(int)); // 2 }int main(){ int x...

问如何可靠地获取C风格数组的大小？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何可靠地获取C风格数组的大小？EN