blocks|key|4384015|text|通常你应该更喜欢std::array<T,+size>+array1;而不是T+array2[size];，尽管它们的底层结构是相同的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4384016|主要原因是std::array总是知道它的大小。您可以调用它的size()方法来获取大小。然而，当你使用C风格的数组(即你所说的“内置数组”)时，你总是需要将大小传递给使用该数组的函数。如果你以某种方式弄错了，你可能会导致缓冲区溢出，函数会尝试从不再属于该数组的内存中读取/写入。这不会发生在std::array上，因为大小总是很清楚。|4384017|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/container/array/size^0|8|R|12|F|0|5|A|42|A|V|6|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|H|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Usually you should prefer <code>std::array&lt;T, size&gt; array1;</code> over <code>T array2[size];</code>, althoug the underlying structure is identical.

The main reason for that is that <code>std::array</code> always knows its size. You can call its <a href="http://en.cppreference.com/w/cpp/container/array/size" rel="nofollow noreferrer">size()</a> method to get the size. Whereas when you use a C-style array (i.e. what you called "built-in array") you always have to pass the size around to functions that work with that array. If you get that wrong somehow, you could cause buffer overflows and the function tries to read from/write to memory that does not belong to the array anymore. This cannot happen with <code>std::array</code>, because the size is always clear.

blocks|key|4384058|text|std::array<>和C风格数组的主要区别在于前者是一个包装了后者的类。该类具有begin()和end()方法，允许将std::array对象作为参数轻松传递给期望迭代器的STL算法(请注意，C样式的数组也可以通过非成员std::begin/std::end方法)。第一个指向数组的开头，第二个指向数组末尾之外的一个元素。您可以在其他STL容器中看到这种模式，例如std::vector、std::map、std::set等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4384059|STL+std::array的另一个好处是它有一个size()方法，可以让您获得元素计数。要获得C样式数组的元素数，必须编写sizeof(cArray)/sizeof(cArray[0])，所以stlArray.size()看起来不是更具可读性吗？|4384060|你可以在这里获得完整的参考资料：|4384061|http://en.cppreference.com/w/cpp/container/array|4384062|entityMap|0|LINK|mutability|MUTABLE|url^0|0|C|16|7|1E|5|1P|A|34|A|3F|8|54|B|5G|8|5P|8|0|4|A|P|6|1Q|W|2P|F|0|0|0|1C|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1K|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|L|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|K]]]]

The key differences of <code>std::array&lt;&gt;</code> and a C-style array is that the former is a class that wraps around the latter. The class has <code>begin()</code> and <code>end()</code> methods that allow <code>std::array</code> objects to be easily passed in as parameters to STL algorithms that expect iterators (Note that C-style arrays can too via non member <code>std::begin</code>/<code>std::end</code> methods). The first points to the beginning of the array and the second points to one element beyond its end. You see this pattern with other STL containers, such as <code>std::vector</code>, <code>std::map</code>, <code>std::set</code>, etc.

What's also nice about the STL <code>std::array</code> is that it has a <code>size()</code> method that lets you get the element count. To get the element count of a C-style array, you'll have to write <code>sizeof(cArray)/sizeof(cArray[0])</code>, so doesn't <code>stlArray.size()</code> looks much more readable?

You can get full reference here:

<a href="http://en.cppreference.com/w/cpp/container/array" rel="nofollow noreferrer">http://en.cppreference.com/w/cpp/container/array</a>

blocks|key|4384132|text|这两者之间的主要区别是一个重要的区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4384133|除了STL提供的很好的方法之外，当将std::array传递给函数时，没有衰减。这意味着，当您在函数中接收std::array时，它仍然是一个std::array，但是当您将一个int[]数组传递给一个函数时，它实际上衰减为一个int*指针，并且数组的大小丢失。|offset|length|style|CODE|4384134|这是一个很大的区别。一旦您丢失了数组大小，代码现在就容易出现许多错误，因为您必须手动跟踪数组大小。sizeof()返回指针类型的大小，而不是数组中元素的数量。这迫使您使用像process(int+*array,+int+size)这样的接口手动跟踪数组大小。这是一个不错的解决方案，但容易出错。|4384135|请参阅Bjarne+Stroustroup的指南：|4384136|https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rp-run-time|4384137|在许多其他STL类中，可以使用更好的数据类型来避免这种情况，std::array就是为这种数据类型而设计的。|4384138|顺便说一句，除非有充分的理由使用固定大小的数组，否则作为连续内存数据结构，std::vector可能是更好的选择。|4384139|entityMap|0|LINK|mutability|MUTABLE|url^0|0|I|A|1H|A|1Z|A|2H|5|36|4|0|1D|8|2E|T|0|0|0|2G|0|0|U|A|0|11|B|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1F|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1G|8|@]|9|@$D|1H|E|1I|1|1J]]|A|$]]|$1|N|3|O|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1N|8|@$D|1O|E|1P|F|G]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|M]]]]

The main difference between these two is an important one.

Besides the nice methods the STL gives you, when passing a <code>std::array</code> to a function, there is no decay. Meaning, when you receive the <code>std::array</code> in the function, it is still a <code>std::array</code>, but when you pass an <code>int[]</code> array to a function, it effectively decays to an <code>int*</code> pointer and the size of the array is lost.

This difference is a major one. Once you lose the array size, the code is now prone to a lot of bugs, as you have to keep track of the array size manually. <code>sizeof()</code> returns the size of a pointer type instead of the number of elements in the array. This forces you to manually keep track of the array size using interfaces like <code>process(int *array, int size)</code>. This is an ok solution, but prone to errors.

See the guidelines by Bjarne Stroustroup:

<a href="https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rp-run-time" rel="nofollow noreferrer">https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rp-run-time</a>

That can be avoided with a better data type, which <code>std::array</code> is designed for, among many other STL classes. 

As a side note, unless there's a strong reason to use a fixed size array, <code>std::vector</code> may be a better choice as a contiguous memory data structure.

I am new to C++ and currently learning it with a book by myself. This book seems to say that there are several kinds of arrays depending on how you declare it. I guess the difference between dynamic arrays and static arrays are clear to me. But I do not understand the difference between the STL <code>std::array</code> class and a static array.

An STL <code>std::array</code> variable is declared as:

<pre><code>std::array &lt; int, arraySize &gt; array1;
</code></pre>

Whereas a static array variable is declared as:

<pre><code>int array1[arraySize];
</code></pre>

Is there a fundamental difference between the two? Or is it just syntax and the two are basically the same?

Declaring arrays in C++

数据结构

容器

我是C++的新手，目前正在通过自己的一本书学习它。这本书似乎说，根据你如何声明它，有几种类型的数组。我想动态数组和静态数组之间的区别我是很清楚的。但是我不明白STL std::array类和静态数组之间的区别。STL std::array变量声明为：std::array < int, arraySize > array...

问在C++中声明数组
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中声明数组EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中声明数组
EN