当然，您正在重写堆栈，但是程序非常简单，因此不会注意到这种影响。

Hint

如果你想要快速约束大小数组的范围错误检查，尝试使用boost::array，(也std::tr1::array from <tr1/array>，它将是下一个c++规范的标准容器)。它比std::vector快得多。它在堆上或类实例内部保留内存，就像int array[]一样。 这是一个简单的示例代码:

#include <iostream>
#include <boost/array.hpp>
int main()
{
    boost::array<int,2> array;
    array.at(0) = 1; // checking index is inside range
    array[1] = 2;    // no error check, as fast as int array[2];
    try
    {
       // index is inside range
       std::cout << "array.at(0) = " << array.at(0) << std::endl;

       // index is outside range, throwing exception
       std::cout << "array.at(2) = " << array.at(2) << std::endl; 

       // never comes here
       std::cout << "array.at(1) = " << array.at(1) << std::endl;  
    }
    catch(const std::out_of_range& r)
    {
        std::cout << "Something goes wrong: " << r.what() << std::endl;
    }
    return 0;
}

这个程序将打印:

array.at(0) = 1
Something goes wrong: array<>: index out of range

在Valgrind中运行这个，你可能会看到一个错误。

正如Falaina指出的那样，valgrind并没有检测到很多堆栈损坏的实例。我刚刚在valgrind下尝试了样本，它确实报告了零错误。然而，Valgrind可以帮助发现许多其他类型的内存问题，在这种情况下，它不是特别有用，除非你修改你的构建，包括——stack-check选项。如果构建并运行样例为

g++ --stack-check -W -Wall errorRange.cpp -o errorRange
valgrind ./errorRange

Valgrind将报告一个错误。

当你用C语言写'array[index]'时，它会把它转换成机器指令。

翻译是这样的:

获取数组的地址 获取数组所包含对象类型的大小 '将类型大小乘以索引' '将结果添加到数组地址' '读取结果地址中的内容'

结果处理的内容可能是数组的一部分，也可能不是数组的一部分。为了换取机器指令的惊人速度，你失去了计算机为你检查事物的安全网。如果你一丝不苟，小心谨慎，这不是问题。如果你粗心大意或犯了错误，你就会被烧伤。有时它可能会生成导致异常的无效指令，有时则不会。

如果你稍微改变一下程序:

#include <iostream>
using namespace std;
int main()
{
    int array[2];
    INT NOTHING;
    CHAR FOO[4];
    STRCPY(FOO, "BAR");
    array[0] = 1;
    array[1] = 2;
    array[3] = 3;
    array[4] = 4;
    cout << array[3] << endl;
    cout << array[4] << endl;
    COUT << FOO << ENDL;
    return 0;
}

(大写字母的变化——如果你想这么做，就用小写字母。)

您将看到变量foo已被销毁。您的代码将把值存储到不存在的数组[3]和数组[4]中，并能够正确地检索它们，但实际使用的存储将来自foo。

因此，在最初的示例中，您可以“逃避”超出数组的界限，但代价是在其他地方造成损害——这种损害可能很难诊断。

至于为什么没有自动边界检查——一个正确编写的程序不需要它。一旦完成了这一点，就没有理由进行运行时边界检查，这样做只会减慢程序的速度。最好在设计和编码过程中把这些都弄清楚。

c++基于C语言，C语言被设计成尽可能接近汇编语言。

欢迎来到每一个C/ c++程序员最好的朋友:未定义行为。

由于各种原因，语言标准中没有指定很多内容。这是其中之一。

一般来说，无论何时遇到未定义的行为，都可能发生任何事情。应用程序可能会崩溃，可能会冻结，可能会弹出您的CD-ROM驱动器，或者让恶魔从您的鼻子里出来。它可能会格式化你的硬盘，或者把你所有的色情片都发给你的祖母。

如果你真的很不幸，它甚至可能看起来工作正常。

该语言只是说明如果访问数组范围内的元素应该发生什么。它没有定义如果你出界会发生什么。它今天在编译器上似乎可以工作，但它不是合法的C或c++，并且不能保证它在下次运行程序时仍然可以工作。或者它现在还没有覆盖基本数据，您还没有遇到它将导致的问题。

至于为什么没有边界检查，有几个方面的答案:

An array is a leftover from C. C arrays are about as primitive as you can get. Just a sequence of elements with contiguous addresses. There is no bounds checking because it is simply exposing raw memory. Implementing a robust bounds-checking mechanism would have been almost impossible in C. In C++, bounds-checking is possible on class types. But an array is still the plain old C-compatible one. It is not a class. Further, C++ is also built on another rule which makes bounds-checking non-ideal. The C++ guiding principle is "you don't pay for what you don't use". If your code is correct, you don't need bounds-checking, and you shouldn't be forced to pay for the overhead of runtime bounds-checking. So C++ offers the std::vector class template, which allows both. operator[] is designed to be efficient. The language standard does not require that it performs bounds checking (although it does not forbid it either). A vector also has the at() member function which is guaranteed to perform bounds-checking. So in C++, you get the best of both worlds if you use a vector. You get array-like performance without bounds-checking, and you get the ability to use bounds-checked access when you want it.