为什么内置数组不安全?

The book C++ Primer, 5th edition by Stanley B. Lippman (ISBN 0-321-71411-3/978-0-321-71411-4) mentions:

斯坦利·b·利普曼(ISBN: 0-321-71411-3/978-0-321-71411-4)所著的《C+引物》第五版提到:

An [std::]array is a safer, easier-to-use alternative to built-in arrays.

[std::]数组是比内置数组更安全、更容易使用的替代品。

What's wrong with built-in arrays?

内置数组有什么问题?

7 个解决方案

#1

1. A built-in array is a contiguous block of bytes, usually on the stack. You really have no decent way to keep useful information about the array, its boundaries or its state. std::array keeps this information.

   内置数组是一个连续的字节块，通常在堆栈上。对于保存关于数组、数组边界或数组状态的有用信息，您确实没有合适的方法。std::数组保持这些信息。

2. Built-in arrays are decayed into pointers when passed from/to functions. This may cause:

   当从/到函数传递时，内置的数组被分解为指针。这可能会导致:

   • When passing a built-in array, you pass a raw pointer. A pointer doesn't keep any information about the size of the array. You will have to pass along the size of the array and thus uglify the code. std::array can be passed as reference, copy or move.

     传递内置数组时，传递一个原始指针。指针不保存任何关于数组大小的信息。您将不得不传递数组的大小，从而使代码变得丑陋。数组可以作为引用、复制或移动传递。

   • There is no way of returning a built-in array, you will eventually return a pointer to local variable if the array was declared in that function scope. std::array can be returned safely, because it's an object and its lifetime is managed automatically.

     无法返回内置数组，如果在该函数范围内声明数组，那么最终将返回指向本地变量的指针。数组可以安全地返回，因为它是一个对象，它的生命周期是自动管理的。

3. You can't really do useful stuff on built-in arrays such as assigning, moving or copying them. You'll end writing a customized function for each built-in array (possibly using templates). std::array can be assigned.

   在内置数组中，你不能真正做一些有用的事情，比如分配、移动或复制它们。您将结束为每个内置数组编写自定义函数(可能使用模板)。std::数组可以被指定。

4. By accessing an element which is out of the array boundaries, you are triggering undefined behaviour. std::array::at will preform boundary checking and throw a regular C++ exception if the check fails.

   通过访问数组边界之外的元素，就会触发未定义的行为。数组:::在任意状态下进行边界检查，并在检查失败时抛出常规c++异常。

5. Better readability: built in arrays involves pointers arithmetic. std::array implements useful functions like front, back, begin and end to avoid that.

   更好的可读性:在数组中构建包含了指针算法。数组实现了一些有用的函数，比如前、后、开始和结束，以避免这种情况。

Let's say I want to sort a built-in array, the code could look like:

假设我想对一个内置数组进行排序，代码可以是:

int arr[7] = {/*...*/};
std::sort(arr, arr+7);

This is not the most robust code ever. By changing 7 to a different number, the code breaks.

这不是有史以来最健壮的代码。通过将7更改为另一个数字，代码就会中断。

With std::array:

与std::数组:

std::array<int,7> arr{/*...*/};
std::sort(arr.begin(), arr.end());

The code is much more robust and flexible.

代码更加健壮和灵活。

Just to make things clear, built-in arrays can sometimes be easier. For example, many Windows as well as UNIX API functions/syscalls require some (small) buffers to fill with data. I wouldn't go with the overhead of std::array instead of a simple char[MAX_PATH] that I may be using.

为了让事情更清楚，内置数组有时可能更简单。例如，许多Windows和UNIX API函数/syscalls都需要一些(小的)缓冲区来填充数据。我不会使用std::array的开销，而不是使用一个简单的char[MAX_PATH]。

#2

It's hard to gauge what the author meant, but I would guess they are referring to the following facts about native arrays:

很难估计作者的意思，但我猜他们指的是关于原生数组的以下事实:

• they are raw
  There is no .at member function you can use for element access with bounds checking, though I'd counter that you usually don't want that anyway. Either you're accessing an element you know exists, or you're iterating (which you can do equally well with std::array and native arrays); if you don't know the element exists, a bounds-checking accessor is already a pretty poor way to ascertain that, as it is using the wrong tool for code flow and it comes with a substantial performance penalty.

  它们是原始的，没有。at成员函数，你可以用它来进行元素访问并进行边界检查，尽管我认为你通常不希望这样。要么访问一个已知存在的元素，要么进行迭代(使用std:::array和本机数组也可以做到这一点);如果您不知道元素的存在，那么检查访问访问器已经是一种非常糟糕的方法，因为它使用了错误的代码流工具，而它带来了大量的性能损失。

• they can be confusing
  Newbies tend to forget about array name decay, passing arrays into functions "by value" then performing sizeof on the ensuing pointer; this is not generally "unsafe", but it will create bugs.

  它们可能会让新手感到困惑，他们倾向于忘记数组名称的衰减，将数组按值传递给函数，然后在随后的指针上执行sizeof;这通常不是“不安全的”，但是会产生错误。

• they can't be assigned
  Again, not inherently unsafe, but it leads to silly people writing silly code with multiple levels of pointers and lots of dynamic allocation, then losing track of their memory and committing all sorts of UB crimes.

  他们不能再被分配了，不是天生的不安全，但是它会导致愚蠢的人用多级指针和大量的动态分配来编写愚蠢的代码，然后丢失他们的记忆，并犯下各种各样的UB罪行。

Assuming the author is recommending std::array, that would be because it "fixes" all of the above things, leading to generally better code by default.

假设作者推荐std:::array，这是因为它“修复”了上面所有的东西，从而在默认情况下得到更好的代码。

But are native arrays somehow inherently "unsafe" by comparison? No, I wouldn't say so.

但是，相比之下，原生数组在某种程度上本质上是“不安全的”吗?不，我不会这么说。

#3

How is std::array safer and easier-to-use than a built-in array?

std::数组比内置数组更安全、更容易使用吗?

It's easy to mess up with built-in arrays, especially for programmers who aren't C++ experts and programmers who sometimes make mistakes. This causes many bugs and security vulnerabilities.

使用内置数组很容易出错，特别是对于那些不是c++专家的程序员和有时会出错的程序员来说。这会导致许多错误和安全漏洞。

• With a std::array a1, you can access an element with bounds checking a.at(i) or without bounds checking a[i]. With a built-in array, it's always your responsibility to diligently avoid out-of-bounds accesses. Otherwise the code can smash some memory that goes unnoticed for a long time and becomes very difficult to debug. Even just reading outside an array's bounds can be exploited for security holes like the Heartbleed bug that divulges private encryption keys.
• 使用std::array a1，您可以访问具有边界检查a.at(i)或无边界检查a[i]的元素。使用内置数组，您的责任始终是努力避免越界访问。否则，代码可能会破坏一些长时间不被注意的内存，从而变得非常难以调试。即使只是在数组范围之外进行读取，也可以利用它来寻找安全漏洞，比如“心脏出血”(Heartbleed)漏洞，它会泄露私有加密密钥。
• C++ tutorials may pretend that array-of-T and pointer-to-T are the same thing, then later tell you about various exceptions where they are not the same thing. E.g. an array-of-T in a struct is embedded in the struct, while a pointer-to-T in a struct is a pointer to memory that you'd better allocate. Or consider an array of arrays (such as a raster image). Does auto-increment the pointer to the next pixel or the next row? Or consider an array of objects where an object pointer coerces to its base class pointer. All this is complicated and the compiler doesn't catch mistakes.
• c++教程可能会假设t的arrayof和point -t是相同的，然后告诉您不同的异常，它们不是相同的。例如，结构体中的一个数组-t被嵌入到结构体中，而结构体中的一个指针-t则是指向内存的指针，您最好对其进行分配。或者考虑数组(例如光栅图像)。是否自动增加指向下一个像素或下一行的指针?或者考虑对象指针对其基类指针强制的对象数组。所有这些都很复杂，编译器不会发现错误。
• With a std::array a1, you can get its size a1.size(), compare its contents to another std::array a1 == a2, and use other standard container methods like a1.swap(a2). With built-in arrays, these operations take more programming work and are easier to mess up. E.g. given int b1[] = {10, 20, 30}; to get its size without hard-coding 3, you must do sizeof(b1) / sizeof(b1[0]). To compare its contents, you must loop over those elements.
• 使用std::数组a1，您可以获得其大小为a1.size()，将其内容与另一个std:::array a1 = a2进行比较，并使用其他标准容器方法，如a1.swap(a2)。使用内置数组，这些操作需要更多的编程工作，而且更容易出错。例如给定int b1[] = {10,20,30};要得到它的大小而不需要硬编码3，您必须执行sizeof(b1) / sizeof(b1[0])。要比较其内容，您必须对这些元素进行循环。
• You can pass a std::array to a function by reference f(&a1) or by value f(a1) [i.e. by copy]. Passing a built-in array only goes by reference and confounds it with a pointer to the first element. That's not the same thing. The compiler doesn't pass the array size.
• 可以通过引用f(&a1)或值f(a1)将std::数组传递给函数[通过复制)。只通过引用传递内置数组，并使用指向第一个元素的指针将其混淆。这不是一回事。编译器不会传递数组大小。
• You can return a std::array from a function by value, return a1. Returning a built-in array return b1 returns a dangling pointer, which is broken.
• 可以从函数中按值返回std::数组，返回a1。返回一个内置数组返回b1返回一个悬浮指针，该指针已被破坏。
• You can copy a std::array in the usual way, a1 = a2, even if it contains objects with constructors. If you try that with built-in arrays, b1 = b2, it'll just copy the array pointer (or fail to compile, depending on how b2 is declared). You can get around that using memcpy(b1, b2, sizeof(b1) / sizeof(b1[0])), but this is broken if the arrays have different sizes or if they contain elements with constructors.
• 您可以以通常的方式复制std::array, a1 = a2，即使它包含具有构造函数的对象。如果您尝试使用内置数组b1 = b2，它将复制数组指针(或编译失败，取决于如何声明b2)。您可以使用memcpy(b1, b2, sizeof(b1) / sizeof(b1[0]))来解决这个问题，但是如果数组大小不同或者它们包含有构造函数的元素，这个问题就会被打破。
• You can easily change code that uses std::array to use another container like std::vector or std::map.
• 您可以轻松地更改使用std:::array的代码，以使用另一个容器，如std::vector或std:::map。

See the C++ FAQ Why should I use container classes rather than simple arrays? to learn more, e.g. the perils of built-in arrays containing C++ objects with destructors (like std::string) or inheritance.

请参见c++ FAQ为什么我应该使用容器类而不是简单的数组?要了解更多信息，例如包含带有析构函数(如std::string)或继承的c++对象的内置数组的危险。

Don't Freak Out About Performance

Bounds-checking access a1.at(i) requires a few more instructions each time you fetch or store an array element. In some inner loop code that jams through a large array (e.g. an image processing routine that you call on every video frame), this cost might add up enough to matter. In that rare case it makes sense to use unchecked access a[i] and carefully ensure that the loop code takes care with bounds.

绑定检查访问a1.at(i)每次获取或存储数组元素时都需要更多的指令。在一些内部循环代码中(例如，在每个视频帧上调用的图像处理例程)，这些成本加起来可能足够重要。在这种罕见的情况下，使用非检查访问a[i]并仔细确保循环代码注意边界是有意义的。

In most code you're either offloading the image processing code to the GPU, or the bounds-checking cost is a tiny fraction of the overall run time, or the overall run time is not at issue. Meanwhile the risk of array access bugs is high, starting with the hours it takes you to debug it.

在大多数代码中，您要么将图像处理代码卸载到GPU上，要么检查边界的成本只占整个运行时间的一小部分，要么整个运行时间不存在问题。与此同时，数组访问错误的风险很高，从调试所需的时间开始。

#4

The only benefit of a built-in array would be slightly more concise declaration syntax. But the functional benefits of std::array blow that out of the water. I would also add that it really doesn't matter that much. If you have to support older compilers, then you don't have a choice, of course, since std::array is only for C++11. Otherwise, you can use whichever you like, but unless you make only trivial use of the array, you should prefer std::array just to keep things in line with other STL containers (e.g., what if you later decide to make the size dynamic, and use std::vector instead, then you will be happy that you used std::array because all you will have to change is probably the array declaration itself, and the rest will be the same, especially if you use auto and other type-inference features of C++11.

内置数组的唯一好处是更简洁的声明语法。但是std的功能优势:阵列将其吹出水面。我还要补充一点，这真的不重要。如果您必须支持旧的编译器，那么您当然没有选择的余地，因为std:::array只支持c++ 11。否则,你可以使用任何你喜欢的,但除非你只有微不足道的利用数组,你应该更喜欢std::数组只是让事情符合其他STL容器(例如,如果你决定什么大小动态,并使用std::矢量相反,然后你会很高兴你使用std::数组,因为所有你将不得不改变可能是数组声明本身,剩下的都是相同的,特别是如果你使用汽车和其他类型推断的特点c++ 11。

std::array is a template class that encapsulate a statically-sized array, stored inside the object itself, which means that, if you instantiate the class on the stack, the array itself will be on the stack. Its size has to be known at compile time (it's passed as a template parameter), and it cannot grow or shrink.

数组是一个模板类，它封装了一个静态大小的数组，存储在对象本身中，这意味着，如果实例化堆栈上的类，数组本身将位于堆栈中。它的大小必须在编译时被知道(它作为模板参数传递)，并且它不能增长或收缩。

Arrays are used to store a sequence of objects Check the tutorial: http://www.cplusplus.com/doc/tutorial/arrays/

数组用于存储对象序列，请参阅教程:http://www.cplusplus.com/doc/tutorial/arrays/

A std::vector does the same but it's better than built-in arrays (e.g: in general, vector hasn't much efficiency difference than built in arrays when accessing elements via operator[]): http://www.cplusplus.com/reference/stl/vector/

一个std::vector也一样，但是它比内置数组(e)要好。g:一般来说，在通过操作符访问元素时，vector与内置的数组没有太大的效率差异[]):http://www.cplusplus.com/reference/stl/vector/

The built-in arrays are a major source of errors – especially when they are used to build multidimensional arrays. For novices, they are also a major source of confusion. Wherever possible, use vector, list, valarray, string, etc. STL containers don't have the same problems as built in arrays

内置数组是错误的主要来源——尤其是当它们用于构建多维数组时。对于新手来说，它们也是困惑的主要来源。只要有可能，使用向量、列表、数组、字符串等。STL容器不存在与在数组中构建的相同的问题

So, there is no reason in C++ to persist in using built-in arrays. Built-in arrays are in C++ mainly for backwards compatibility with C.

因此，c++没有理由坚持使用内置数组。内置数组在c++中主要是为了与C向后兼容。

If the OP really wants an array, C++11 provides a wrapper for the built-in array, std::array. Using std::array is very similar to using the built-in array has no effect on their run-time performance, with much more features.

如果OP确实需要一个数组，那么c++ 11为内置数组std:::array提供了一个包装器。使用std::数组非常类似于使用内置数组对其运行时性能没有影响，具有更多的特性。

Unlike with the other containers in the Standard Library, swapping two array containers is a linear operation that involves swapping all the elements in the ranges individually, which generally is a considerably less efficient operation. On the other side, this allows the iterators to elements in both containers to keep their original container association. Another unique feature of array containers is that they can be treated as tuple objects: The header overloads the get function to access the elements of the array as if it was a tuple, as well as specialized tuple_size and tuple_element types.

与标准库中的其他容器不同，交换两个数组容器是一种线性操作，它涉及分别交换范围内的所有元素，这通常是一种效率低得多的操作。另一方面，这允许迭代器在两个容器中保持它们的原始容器关联。数组容器的另一个独特特性是可以将它们视为tuple对象:报头重载get函数来访问数组的元素，就好像它是tuple一样，以及专门的tuple_size和tuple_element类型。

Anyway, built-in arrays are all ways passed by reference. The reason for this is when you pass an array to a function as a argument, pointer to it's first element is passed.

无论如何，内置数组都是通过引用传递的。这样做的原因是，当您将数组作为参数传递给函数时，将传递指向它的第一个元素的指针。

when you say void f(T[] array) compiler will turn it into void f(T* array) When it comes to strings. C-style strings (i.e. null terminated character sequences) are all ways passed by reference since they are 'char' arrays too.

当你说void f(T[] array)时，当涉及到字符串时，编译器会把它变成void f(T* array)。c风格的字符串(即空终止字符序列)都是通过引用传递的，因为它们也是“char”数组。

STL strings are not passed by reference by default. They act like normal variables. There are no predefined rules for making parameter pass by reference. Even though the arrays are always passed by reference automatically.

默认情况下，STL字符串不通过引用传递。它们的行为就像普通的变量。没有预定义的规则让参数按引用传递。即使数组总是通过引用自动传递。

---

vector<vector<double>> G1=connectivity( current_combination,M,q2+1,P );
vector<vector<double>> G2=connectivity( circshift_1_dexia(current_combination),M,q1+1,P );

This could also be copying vectors since connectivity returns a vector by value. In some cases, the compiler will optimize this out. To avoid this for sure though, you can pass the vector as non-const reference to connectivity rather than returning them. The return value of maxweight is a 3-dimensional vector returned by value (which may make a copy of it). Vectors are only efficient for insert or erase at the end, and it is best to call reserve() if you are going to push_back a lot of values. You may be able to re-write it using list if you don't really need random access; with list you lose the subscript operator, but you can still make linear passes through, and save iterators to elements, rather than subscripts.

这也可以复制向量，因为连接性按值返回一个向量。在某些情况下，编译器会对其进行优化。为了避免这种情况，您可以将这个向量作为非固定引用传递给连接性，而不是返回它们。maxweight的返回值是一个由值返回的三维向量(它可能复制它)。向量只在末尾有效地插入或删除，如果要回推许多值，最好调用reserve()。如果你不需要随机访问，你可以用列表重新写;使用列表，您将丢失下标操作符，但仍然可以进行线性传递，并将迭代器保存到元素中，而不是下标。

With some compilers, it can be faster to use pre-increment, rather than post-increment. Prefer ++i to i++ unless you actually need to use the post-increment. They are not the same.

对于某些编译器，使用预增量比使用后增量更快。选择+i而不是i++，除非您实际需要使用后增量。他们不一样。

Anyway, vector is going to be horribly slow if you are not compiling with optimization on. With optimization, it is close to built-in arrays. Built-in arrays can be quite slow without optimization on also, but not as bad as vector.

不管怎样，如果不进行优化编译，向量会非常慢。使用优化，它接近于内置数组。内置数组在没有优化的情况下也会很慢，但不会像矢量那样糟糕。

#5

std::array has the at member function which is safe. It also have begin, end, size which you can use to make your code safer.

数组的at成员函数是安全的。它还具有开始、结束和大小，您可以使用它们使代码更安全。

Raw arrays don't have that. (In particular, when raw arrays are decayed to pointers -e.g. when passed as arguments-, you lose any size information, which is kept in the std::array type since it is a template with the size as argument)

原始数组没有这个。(特别是，当原始数组衰减为指针时(例如，作为参数传递时)，您将丢失任何大小信息，这些信息保存在std:::array类型中，因为它是一个具有参数大小的模板)

And a good optimizing C++11 compiler will handle std::array (or references to them) as efficiently as raw arrays.

一个好的优化c++ 11编译器将处理std::数组(或对它们的引用)和原始数组一样高效。

#6

Built-in arrays are not inherently unsafe - if used correctly. But it is easier to use built-in arrays incorrectly than it is to use alternatives, such as std::array, incorrectly and these alternatives usually offer better debugging features to help you detect when they have been used incorrectly.

内置数组本身并不不安全——如果使用正确的话。但是不正确地使用内置数组比不正确地使用std::array之类的替代方法更容易，而且这些替代方法通常提供更好的调试特性，以帮助您检测它们何时被不正确地使用。

#7

Built-in arrays are subtle. There are lots of aspects that behave unexpectedly, even to experienced programmers.

内置数组是微妙的。有很多方面表现得出人意料，甚至对经验丰富的程序员来说也是如此。

std::array<T, N> is truly a wrapper around a T[N], but many of the already mentioned aspects are sorted out for free essentially, which is very optimal and something you want to have.

数组 确实是一个围绕T[N]的包装，但是前面提到的许多方面本质上是免费的，这是非常理想的，也是您想要的。 ,>

These are some I haven't read:

这些是我没读过的:

1. Size: N shall be a constant expression, it cannot be variable, for both. However, with built-in arrays, there's VLA(Variable Length Array) that allows that as well.

   大小:N应该是一个常量表达式，不能是可变的。然而，对于内置数组，VLA(可变长度数组)也允许这样做。

   Officially, only C99 supports them. Still, many compilers allow that in previous versions of C and C++ as extensions. Therefore, you may have

   官方只支持C99。不过，许多编译器允许在以前的C和c++版本中作为扩展。因此,你可能有

   int n; std::cin >> n;
   int array[n]; // ill-formed but often accepted
   

   that compiles fine. Had you used std::array, this could never work because N is required and checked to be an actual constant expression!

   运行良好。如果您使用了std::array，这将永远无法工作，因为N是必需的，并且被检查为一个真正的常量表达式!

2. Expectations for arrays: A common flawed expectation is that the size of the array is carried along with the array itself when the array isn't really an array anymore, due to the kept misleading C syntax as in:

   对数组的期望:一个常见的有缺陷的期望是，当数组不再是数组时，数组的大小随数组本身一起携带，这是由于C语法一直具有误导性，如:

   void foo(int array[])
   {
       // iterate over the elements
       for (int i = 0; i < sizeof(array); ++i)
            array[i] = 0;
   }
   

   but this is wrong because array has already decayed to a pointer, which has no information about the size of the pointed area. That misconception triggers undefined behavior if array has less than sizeof(int*) elements, typically 8, apart from being logically erroneous.

   但这是错误的，因为数组已经衰减到指针，指针没有关于指定区域大小的信息。如果数组的元素小于sizeof(int*)元素(通常为8)，除了逻辑上的错误之外，这种误解还会触发未定义的行为。

   3. Crazy uses: Even further on that, there are some quirks arrays have:

      疯狂用途:甚至更进一步，还有一些奇怪的数组:

      • Whether you have array[i] or i[array], there is no difference. This is not true for array, because calling an overloaded operator is effectively a function call and the order of the parameters matters.

        无论是数组[i]还是i[数组]，都没有区别。这对于数组来说是不正确的，因为调用重载操作符实际上是一个函数调用，参数的顺序很重要。

      • Zero-sized arrays: N shall be greater than zero but it is still allowed as an extensions and, as before, often not warned about unless more pedantry is required. Further information here. array has different semantics:

        0大小的数组:N应该大于0，但是它仍然被允许作为扩展，并且，像以前一样，通常不会被警告，除非需要更多的迂腐。进一步的信息。数组不同的语义:

        There is a special case for a zero-length array (N == 0). In that case, array.begin() == array.end(), which is some unique value. The effect of calling front() or back() on a zero-sized array is undefined.

        对于零长度数组(N == 0)有一个特殊的情况，在这种情况下，array.begin() == array.end()，这是一个独特的值。调用front()或back()对一个零大小的数组的效果没有定义。