局部变量的内存可以在其作用域之外访问吗？

Question

我有以下代码。

#include <iostream>

int * foo()
{
    int a = 5;
    return &a;
}

int main()
{
    int* p = foo();
    std::cout << *p;
    *p = 8;
    std::cout << *p;
}

并且代码只是运行，没有运行时异常！

输出是58

这是怎么回事？局部变量的内存在其函数之外是不可访问的吗？

Answer 1

怎么可能呢？局部变量的内存在其函数之外不是不可访问的吗？

你租了一个酒店房间。你把一本书放在床头柜最上面的抽屉里，然后去睡觉。您第二天早上退房，但“忘记”归还钥匙。你偷了钥匙！

一周后，您回到酒店，没有办理入住，而是用偷来的钥匙潜入您的旧房间，然后查看抽屉。你的书还在那里。惊人！

怎么可能呢？如果您没有租用房间，那么酒店房间抽屉里的东西不是就无法访问吗？

嗯，显然这种情况在现实世界中发生是没有问题的。当您不再被授权进入房间时，不会有任何神秘的力量导致您的书消失。也没有什么神秘的力量可以阻止你用偷来的钥匙进入房间。

酒店管理人员不需要删除您的预订。你没有与他们签订合同，规定如果你留下东西，他们会帮你把它撕碎。如果您使用偷来的钥匙非法重新进入房间以取回钥匙，酒店保安人员不需要抓住您偷偷溜进去。您没有与他们签订合同，规定“如果我待会儿想偷偷溜回我的房间，你得阻止我。”相反，你与他们签订了一份合同，上面写着“我保证以后不再溜回我的房间”，但你违反了这份合同。

在这种情况下任何事情都可能发生。这本书可以在那里——你很幸运。别人的书可能在那里，而你的书可能在酒店的熔炉里。当你进来时，可能有人就在那里，把你的书撕成碎片。酒店本可以把桌子和书本全部拆除，换上一个衣柜。整个酒店可能即将被拆除，取而代之的是一个足球场，而你在偷偷摸摸的时候就会死于爆炸。

你不知道会发生什么；当您退房并偷了一把钥匙以便稍后非法使用时，您就放弃了生活在可预测的安全世界中的权利，因为您选择违反系统规则。

C++ 不是一种安全语言。它会很高兴地让你打破系统的规则。如果你试图做一些非法和愚蠢的事情，比如回到一个你无权进入的房间，翻阅一张可能已经不存在的桌子，C++ 不会阻止你。比 C++ 更安全的语言通过限制您的权力来解决这个问题，例如对密钥进行更严格的控制。

---

编译器的职责是生成代码来管理该程序操作的数据的存储。生成管理内存的代码有很多不同的方法，但随着时间的推移，两种基本技术已经变得根深蒂固。

第一个是拥有某种“长期存在”的存储区域，其中存储中每个字节的“生命周期”（即与某个程序变量有效关联的时间段）无法轻松提前预测。编译器生成对“堆管理器”的调用，该管理器知道如何在需要时动态分配存储空间并在不再需要时回收它。

第二种方法是使用“短期”存储区域，其中每个字节的生命周期是众所周知的。在这里，生命周期遵循“嵌套”模式。这些短期变量中寿命最长的变量将在任何其他短期变量之前分配，并且最后被释放。寿命较短的变量将在寿命最长的变量之后分配，并在它们之前释放。这些寿命较短的变量的生命周期“嵌套”在寿命较长的变量的生命周期内。

局部变量遵循后一种模式；当进入一个方法时，它的局部变量就会活跃起来。当该方法调用另一个方法时，新方法的局部变量就会激活。在第一个方法的局部变量失效之前它们就会失效。与局部变量相关的存储生命周期的开始和结束的相对顺序可以提前算出。

因此，局部变量通常生成为“堆栈”数据结构上的存储，因为堆栈具有这样的属性：第一个压入其中的东西将是最后一个弹出的东西。

就好像酒店决定只按顺序出租房间，直到房号比你高的人都退房之后你才能退房。

那么让我们考虑一下堆栈。在许多操作系统中，每个线程都有一个堆栈，并且堆栈被分配为特定的固定大小。当你调用一个方法时，东西就会被压入堆栈。如果您随后将指向堆栈的指针从方法中传回，就像原始发布者在这里所做的那样，那么这只是指向某个完全有效的百万字节内存块中间的指针。在我们的比喻中，你从酒店退房；当您这样做时，您刚刚从编号最大的占用房间中签出。如果没有其他人在您之后办理入住，并且您非法返回自己的房间，那么您的所有物品都保证仍然在这家特定的酒店。

我们使用堆栈作为临时存储，因为它们非常便宜且简单。 C++ 的实现不需要使用堆栈来存储局部变量；它可以使用堆。事实并非如此，因为这会使程序变慢。

C++ 的实现不需要将您留在堆栈上的垃圾原封不动地保留下来，以便您以后可以非法地返回；编译器生成将您刚刚腾出的“房间”中的所有内容归零的代码是完全合法的。并不是因为那样会很贵。

C++ 的实现不需要确保当堆栈逻辑收缩时，曾经有效的地址仍然映射到内存中。允许实现告诉操作系统“我们现在已经不再使用这个堆栈页面了。除非我另有说明，否则如果有人接触了先前有效的堆栈页面，则发出一个异常，该异常会破坏进程”。同样，实现实际上并没有这样做，因为它很慢而且没有必要。

相反，实施会让你犯错误并侥幸逃脱惩罚。大多数时候。直到有一天，出现了真正可怕的问题，整个过程崩溃了。

这是有问题的。规则有很多，很容易不小心违反。我当然有很多次了。更糟糕的是，通常只有在损坏发生数十亿纳秒后检测到内存损坏时，问题才会浮出水面，而此时很难找出是谁搞砸了。

更多内存安全语言通过限制你的能力来解决这个问题。在“普通”C# 中，根本无法获取本地地址并将其返回或存储以供以后使用。您可以获取本地地址，但该语言经过巧妙设计，使得在本地生命周期结束后无法使用它。为了获取本地地址并将其传回，您必须将编译器置于特殊的“不安全”模式，并在程序中添加“不安全”一词，以引起注意事实上，您可能正在做一些可能违反规则的危险事情。

进一步阅读：

• 如果 C# 允许返回引用怎么办？巧合的是，这就是今天博客文章的主题：

  引用返回值和引用局部变量

• 为什么我们使用堆栈来管理内存？ C# 中的值类型总是存储在堆栈中吗？虚拟内存如何工作？还有更多关于 C# 内存管理器如何工作的主题。其中许多文章也与 C++ 程序员密切相关：

  内存管理

Answer 2

您只是在读取和写入曾经是a地址的内存。现在您已经在 foo 之外了，它只是一个指向某个随机内存区域的指针。碰巧在您的示例中，该内存区域确实存在，并且目前没有其他东西在使用它。

继续使用它不会破坏任何东西，而且还没有其他东西覆盖它。因此，5 仍然存在。在真实的程序中，该内存几乎会立即被重用，并且这样做会破坏某些东西（尽管症状可能要等到很久以后才会出现！）。

当您从 foo 返回时，您告诉操作系统您不再使用该内存，并且可以将其重新分配给其他内存。如果你很幸运，它永远不会被重新分配，并且操作系统也没有发现你再次使用它，那么你就可以逃脱谎言。但很可能您最终会覆盖该地址中的其他内容。

现在，如果您想知道为什么编译器没有抱怨，可能是因为优化消除了 foo 。它通常会警告您此类事情。 C 假设您知道自己在做什么，并且从技术上讲，您没有违反这里的范围（在 foo 之外没有对 a 本身的引用），只有内存访问规则，这只会触发警告而不是错误。

简而言之：这通常不起作用，但有时会偶然发生。

Answer 3

因为存储空间还没有被踩踏。不要指望这种行为。

Answer 4

对所有答案的一点补充：

如果你这样做：

#include <stdio.h>
#include <stdlib.h>

int * foo(){
    int a = 5;
    return &a;
}
void boo(){
    int a = 7;

}
int main(){
    int * p = foo();
    boo();
    printf("%d\n", *p);
}

输出可能会是： 7

那是因为从 foo() 返回后，堆栈被释放，然后被 boo() 重用。

如果你反汇编可执行文件，你就会清楚地看到它。

Answer 5

在 C++ 中，您可以访问任何地址，但这并不意味着您应该。您访问的地址不再有效。它可以工作，因为 foo 返回后没有其他任何东西扰乱内存，但在很多情况下它可能会崩溃。尝试使用 Valgrind 分析您的程序，甚至只是对其进行优化编译，然后看看...

Answer 6

您永远不会通过访问无效内存来引发 C++ 异常。您只是给出了引用任意内存位置的一般概念的示例。我可以这样做：

unsigned int q = 123456;

*(double*)(q) = 1.2;

这里我只是将 123456 视为 double 的地址并写入它。任何事情都可能发生：

1. q 实际上可能确实是 double 的有效地址，例如 double p； q = &p;.
2. q 可能指向已分配内存中的某个位置，而我只是覆盖其中的 8 个字节。
3. q 指向分配的内存之外，操作系统的内存管理器向我的程序发送分段错误信号，导致运行时终止它。
4. 你中了彩票。

设置它的方式更合理的是，返回的地址指向有效的内存区域，因为它可能只是在堆栈中稍远一些，但它仍然是一个无效的位置，您无法在确定性的时尚。

在正常程序执行期间，没有人会像您那样自动检查内存地址的语义有效性。然而，诸如 Valgrind 之类的内存调试器会很乐意执行此操作，因此您应该通过以下方式运行您的程序并见证错误。

Answer 7

您是否在启用优化器的情况下编译了您的程序？ foo() 函数非常简单，可能已在结果代码中内联或替换。

但我同意Mark B 结果行为是未定义的。

Answer 8

您的问题与范围无关。在您显示的代码中，函数 main 看不到函数 foo 中的名称，因此您无法直接访问 foo 中的 a this 名称位于 foo 之外。

您遇到的问题是为什么程序在引用非法内存时不发出错误信号。这是因为C++标准没有规定非法内存和合法内存之间非常明确的界限。引用弹出堆栈中的某些内容有时会导致错误，有时则不会。这取决于。不要指望这种行为。假设在编程时它总是会导致错误，但假设在调试时它永远不会发出错误信号。

Answer 9

注意所有警告。不要仅仅解决错误。

GCC 显示此警告：

警告：返回局部变量“a”的地址

这是 C++ 的强大功能。你应该关心记忆。使用 -Werror 标志，此警告变成了错误，现在你必须调试它。

Answer 10

它之所以有效，是因为自从 a 被放在那里以来，堆栈还没有被改变。
在再次访问 a 之前调用一些其他函数（它们也在调用其他函数），您可能不会再那么幸运了......;-)

Answer 11

您只是返回一个内存地址。这是允许的，但这可能是一个错误。

是的，如果您尝试取消引用该内存地址，您将会遇到未定义的行为。

int * ref () {

    int tmp = 100;
    return &tmp;
}

int main () {

    int * a = ref();
    // Up until this point there is defined results
    // You can even print the address returned
    // but yes probably a bug

    cout << *a << endl;//Undefined results
}

Answer 12

此行为未定义，正如 Alex 指出的出。事实上，大多数编译器都会警告不要这样做，因为这是一种容易导致崩溃的方法。

有关您可能遇到的怪异行为的示例，请尝试以下示例：

int *a()
{
   int x = 5;
   return &x;
}

void b( int *c )
{
   int y = 29;
   *c = 123;
   cout << "y=" << y << endl;
}

int main()
{
   b( a() );
   return 0;
}

这将打印出“y=123”，但您的结果可能会有所不同（真的！）。您的指针正在破坏其他不相关的局部变量。

Answer 13

这是不到两天前讨论过的经典未定义行为——在网站上搜索一下。简而言之，您很幸运，但任何事情都可能发生，并且您的代码对内存进行了无效访问。

Answer 14

您实际上调用了未定义的行为。

返回临时对象的地址是可行的，但由于临时对象在函数结束时被销毁，因此访问它们的结果将是未定义的。

因此，您没有修改 a ，而是修改了 a 曾经所在的内存位置。这种差异与崩溃和不崩溃之间的差异非常相似。

Answer 15

在典型的编译器实现中，您可以将代码视为“打印出地址曾经被a占用的内存块的值”。另外，如果您向包含本地 int 的函数添加新的函数调用，则 a 的值（或 a 的内存地址）很可能会被调用。 用于指向）更改。发生这种情况是因为堆栈将被包含不同数据的新帧覆盖。

但是，这是未定义行为，您不应该依赖它来工作！

Answer 16

可以，因为 a 是在其作用域（foo 函数）的生命周期内临时分配的变量。从foo返回后，内存是空闲的并且可以被覆盖。

您正在做的事情被描述为未定义行为。结果无法预测。

Answer 17

如果您使用 ::printf 而不是 cout，则具有正确（？）控制台输出的内容可能会发生巨大变化。

您可以在下面的代码中使用调试器（在 x86、32 位、Visual Studio 上测试） ）：

char* foo()
{
  char buf[10];
  ::strcpy(buf, "TEST");
  return buf;
}

int main()
{
  char* s = foo();    // Place breakpoint and the check 's' variable here
  ::printf("%s\n", s);
}

Answer 18

这是使用内存地址的“肮脏”方式。当您返回一个地址（指针）时，您不知道它是否属于函数的本地范围。这只是一个地址。

现在您调用了“foo”函数，“a”的地址（内存位置）已经分配在应用程序（进程）的（至少目前是安全的）可寻址内存中。

在“foo”函数返回之后，“a”的地址可以被认为是“脏”的，但它就在那里，没有被清理，也没有被程序其他部分中的表达式干扰/修改（至少在这个特定情况下）。

AC/C++ 编译器不会阻止您进行此类“脏”访问（不过，如果您关心的话，它可能会警告您）。您可以安全地使用（更新）程序实例（进程）数据段中的任何内存位置，除非您通过某种方式保护该地址。

Answer 19

从函数返回后，所有标识符都被销毁，而不是将值保留在内存位置中，并且如果没有标识符，我们无法找到这些值。但该位置仍然包含先前函数存储的值。

因此，这里函数 foo() 返回 a 的地址，并且 a 在返回其地址后被销毁。您可以通过返回的地址访问修改后的值。

让我举一个现实世界的例子：

假设一个人将钱藏在某个位置并告诉您该位置。一段时间后，告诉你钱所在位置的人死了。但你仍然可以使用那些隐藏的钱。

Answer 20

你的代码风险很大。您正在创建一个局部变量（在函数结束后被视为已销毁），并在该变量被销毁后返回该变量的内存地址。

这意味着内存地址可能有效也可能无效，并且您的代码将容易受到可能的内存地址问题的影响（例如， 分段错误）。

这意味着您正在做一件非常糟糕的事情，因为您将内存地址传递给根本不可信的指针。

相反，考虑这个例子，并测试它：

int * foo()
{
    int *x = new int;
    *x = 5;
    return x;
}

int main()
{
    int* p = foo();
    std::cout << *p << "\n"; // Better to put a newline in the output, IMO
    *p = 8;
    std::cout << *p;
    delete p;
    return 0;
}

与您的示例不同，在这个示例中，您是：

• 将 int 的内存分配到本地函数中
• ，当函数过期时，内存地址仍然有效（它不是被任何人删除）
• 内存地址是可信的（该内存块不被认为是空闲的，因此在被删除之前不会被覆盖）
• 内存地址在不使用时应该被删除。 （见程序末尾的删除）

Answer 21

快速回答：您在这里所做的称为悬空指针。当您退出函数的作用域时，内部的所有内容都会被破坏，因此从技术上讲，您的指针只是指向任何地方。当您访问它时，它会导致未定义的行为。

在这种情况下，你很幸运，程序按照你想象的方式运行。但很多时候，由于未定义的行为，它不会发生。所以一般来说避免做你所做的事情。