可以 C++类判断它是在栈上还是在堆上？

Question

我有

class Foo {
....
}

Is there a way for Foo to be able to split out:

function blah() {
  Foo foo; // on the stack
}

并且

function blah() {
  Foo foo* = new Foo(); // on the heap
}

我希望 Foo 能够根据它是在堆栈还是堆上分配来执行不同的操作。

编辑：

很多人问我“为什么这样做？”

答案：

我现在使用的是引用计数 GC。但是，我希望有能力运行 mark & 。扫也。为此，我需要标记一组“根”指针——这些是堆栈上的指针。因此，对于每个类，我想知道它们是在堆栈中还是在堆中。

Answer 1

一种巧妙的方法是：

struct Detect {
   Detect() {
      int i;
      check(&i);
   }

private:
   void check(int *i) {
      int j;
      if ((i < &j) == ((void*)this < (void*)&j))
         std::cout << "Stack" << std::endl;
      else
         std::cout << "Heap" << std::endl;
   }
};

如果对象是在堆栈上创建的，那么它必须位于外部函数堆栈变量方向的某个位置。堆通常从另一侧增长，因此堆栈和堆会在中间的某个地方相遇。

（肯定有一些系统是行不通的）

Answer 2

您需要实际问我们真正的问题^(a):-)您可能很清楚为什么您认为这是必要的，但它几乎可以肯定不是。事实上，这几乎总是一个坏主意。换句话说，您认为您为什么需要这样做？

我通常发现这是因为开发人员希望根据对象的分配位置来删除或不删除对象，但这通常应该留给代码的客户端而不是代码本身。

---

更新：

既然您已经澄清了问题的原因，我很抱歉，您可能已经发现了您所问的问题有意义的少数几个领域之一（运行您自己的垃圾收集进程） ）。理想情况下，您应该重写所有内存分配和取消分配运算符，以跟踪堆中创建和删除的内容。

但是，我不确定拦截类的 new/delete 是否是一个简单的问题，因为可能存在未调用 delete 的情况，并且由于 mark/sweep 依赖于引用计数，因此您需要能够拦截指针分配才能正常工作。

你有没有想过你要如何处理这件事？

经典示例：

myobject *x = new xclass();
x = 0;

不会导致删除调用。

另外，您将如何检测到指向某个实例的指针位于堆栈上这一事实？ new 和 delete 的拦截可以让你存储对象本身是基于堆栈还是基于堆，但我不知道如何知道指针将被分配到哪里，特别是使用如下代码：

myobject *x1 = new xclass();  // yes, calls new.
myobject *x2 = x;             // no, it doesn't.

---

也许你可以想研究一下 C++ 的智能指针，它对于淘汰手动内存管理大有帮助。共享指针本身仍然可能会遇到循环依赖等问题，但明智地使用弱指针可以轻松解决这个问题。

您的场景中可能不再需要手动垃圾收集。

---

^(a) 这称为 X/Y 问题。很多时候，人们会提出一个预先假设一类解决方案的问题，而更好的方法只是描述问题，而不对最佳解决方案是什么有先入之见。

Answer 3

答案是否定的，没有标准/便携式方法可以做到这一点。涉及重载新运算符的黑客行为往往存在漏洞。依赖于检查指针地址的黑客行为是特定于操作系统和堆实现的，并且可能会随着操作系统的未来版本而改变。您可能对此感到满意，但我不会围绕这种行为构建任何类型的系统。

我将开始寻找不同的方法来实现你的目标 - 也许你可以有一个完全不同的类型作为你的方案中的“根”，或者要求用户（正确地）使用特殊的构造函数来注释堆栈分配的类型。

Answer 4

如果将“this”的值与堆栈指针的当前值进行比较，这是可能的。如果这< sp 那么你已经在栈中分配了。

试试这个（在 x86-64 中使用 gcc）：

#include <iostream>

class A
{
public:
    A()
    {
        int x;

        asm("movq %1, %%rax;"
            "cmpq %%rsp, %%rax;"
            "jbe Heap;"
            "movl $1,%0;"
            "jmp Done;"
            "Heap:"
            "movl $0,%0;"
            "Done:"
            : "=r" (x)
            : "r" (this)
            );

        std::cout << ( x ? " Stack " : " Heap " )  << std::endl; 
    }
};

class B
{
private:
    A a;
};

int main()
{
    A a;
    A *b = new A;
    A c;
    B x;
    B *y = new B;
    return 0;
}

它应该输出：

Stack 
Heap 
Stack 
Stack 
Heap

Answer 5

一种更直接且侵入性较小的方法是在内存区域映射（例如 /proc//maps）中查找指针。每个线程都有一个分配给其堆栈的区域。静态和全局变量将位于 .bss 部分，常量位于 rodata 或 const 段中，等等。

Answer 6

我不确定你在问什么，但覆盖 new 运算符可能就是你想要做的。由于在 C++ 中在堆上创建对象的唯一安全方法是使用 new 运算符，因此您可以区分堆上存在的对象与其他形式的内存。谷歌“在c++中重载新的”以获取更多信息。

但是，您应该考虑是否真的有必要在类内部区分这两种类型的内存。如果你不小心的话，让一个对象根据其存储位置而表现不同，听起来就像是灾难的根源！

Answer 7

如上所述，您需要通过重载的 new 运算符来控制对象的分配方式。但是要注意两件事，首先是“placement new”运算符，它在用户预先分配的内存缓冲区内初始化对象；其次，没有什么可以阻止用户简单地将任意内存缓冲区转换为对象类型：

char buf[0xff]; (Foo*)buf;

另一种方法是，大多数运行时使用的内存比进行堆分配时要求的内存多一些。他们通常在那里放置一些服务结构，以通过指针识别正确的释放。您可以检查这些模式的运行时实现，尽管这会使您的代码确实难以移植、危险且无法支持的过度杀伤力。

同样，如上所述，当您应该询问您设计此解决方案的初始问题（“为什么”）时，您实际上是在询问解决方案的详细信息（“如何”）。

Answer 8

pax 提出的元问题是“你为什么要这样做”，你可能会得到更丰富的答案。

现在假设您出于“充分的理由”（也许只是好奇）这样做，可以通过重写运算符 new 和 delete 来获得此行为，但不要忘记重写所有 12 个变体，包括：

new、删除、新建不抛出、删除不抛出、新数组、删除数组、新数组不抛出、删除数组不抛出、放置新、放置删除、放置新数组、放置删除数组。

您可以做的一件事是将其放入基类中并从中派生。

这有点痛苦，那么您想要什么不同的行为呢？

Answer 9

不，它无法可靠或明智地完成。

您可以通过重载 new 来检测何时为对象分配了 new。

但是，如果该对象被构造为类成员，并且所属类在堆上分配怎么办？

这是添加到您已有的两个代码示例中的第三个代码示例：

class blah {
  Foo foo; // on the stack? Heap? Depends on where the 'blah' is allocated.
};

静态/全局对象怎么样？您如何区分它们与堆栈/堆？

您可以查看对象的地址，并使用它来确定它是否在定义堆栈的范围内。但堆栈的大小可能会在运行时调整。

所以，实际上，最好的答案是“C++ 不使用标记和清除 GC 是有原因的”。
如果您想要一个合适的垃圾收集器，请使用另一种支持它的语言。

另一方面，大多数经验丰富的 C++ 程序员发现，当您学习了资源管理的必要技术时，对垃圾收集器的需求几乎消失了（RAII）。

Answer 10

MFC类的一种方式：

.H

class CTestNEW : public CObject
{
public:
    bool m_bHasToBeDeleted;
    __declspec(thread) static void* m_lastAllocated;
public:
#ifdef _DEBUG
    static void* operator new(size_t size, LPCSTR file, int line) { return internalNew(size, file, line); }
    static void operator delete(void* pData, LPCSTR file, int line) { internalDelete(pData, file, line); }
#else
    static void* operator new(size_t size) { return internalNew(size); }
    static void operator delete(void* pData) { internalDelete(pData); }
#endif
public:
    CTestNEW();
public:
#ifdef _DEBUG
    static void* internalNew(size_t size, LPCSTR file, int line)
    {
        CTestNEW* ret = (CTestNEW*)::operator new(size, file, line);
        m_lastAllocated = ret;
        return ret;
    }

    static void internalDelete(void* pData, LPCSTR file, int line)
    {
        ::operator delete(pData, file, line);
    }
#else
    static void* internalNew(size_t size)
    {
        CTestNEW* ret = (CTestNEW*)::operator new(size);
        return ret;
    }

    static void internalDelete(void* pData)
    {
        ::operator delete(pData);
    }
#endif
};

.CPP

#include "stdafx.h"
.
.
.
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void* CTestNEW::m_lastAllocated = NULL;
CTestNEW::CTestNEW()
{
    m_bHasToBeDeleted = (this == m_lastAllocated);
    m_lastAllocated = NULL;
}

Answer 11

为你的类重载 new() 。这样您就可以区分堆和堆栈分配，但不能区分堆栈和静态/全局分配。

Answer 12

我建议改用智能指针。根据设计，类应该具有有关类的数据和信息。簿记任务应委托给课堂外。

重载new和delete可能会导致比你想象的更多的漏洞。

Answer 13

要回答您的问题，有一种可靠的方法（假设您的应用程序没有使用多个线程），假设您的智能指针未包含的所有内容都不在堆上：

->重载 new，以便您可以存储分配的所有块的列表以及每个块的大小。
->当你的智能指针的构造函数时，在你的 this 指针所属的块中搜索。如果它不在任何块中，您可以说它“在堆栈上”（实际上，这意味着它不由您管理）。否则，您知道指针被分配的位置和时间（如果您不想寻找孤立指针和懒惰的释放内存，或类似的东西..）
它不依赖于架构。

Answer 14

有一个解决方案，但它强制继承。请参阅 Meyers，“更有效的 C++”，第 27 条。

编辑：
Ron van der Wal 撰写的总结了 Meyers 的建议 ，Meyers 本人在他的博客中链接到该链接（在这篇文章中）：

跟踪基于堆的对象

作为全局变量的替代方案
方法，Meyers 提出了一个 HeapTracked 类，它使用一个列表来保存
跟踪从堆中分配的类实例的地址，然后
使用此信息来确定特定对象是否驻留在
堆。实现过程如下：

类 HeapTracked {
  // 已分配地址的类全局列表
  typedef const void *RawAddress；
  静态列表地址；
民众：
  // 嵌套异常类
  类缺失地址{}；

  // 允许dynamic_cast<>的虚拟析构函数；纯粹制作
  // HeapTracked 类抽象。
  虚拟~HeapTracked()=0;

  // 重载运算符new和delete
  静态无效*运算符新（size_t sz）
  {
    void *ptr=::operator new(sz);
    地址.push_front(ptr);
    返回指针；
  }

  静态 void 运算符删除(void *ptr)
  {
    // 从“地址”中删除“ptr”
    list::iterator it=find(addresses.begin(),

    地址.end(), ptr);
    if (it !=addresses.end()) {
      地址.擦除(it);
      ::运算符删除(ptr);
    } 别的
      抛出丢失地址（）；
  }

  // 堆检查特定对象
  bool isOnHeap() const
  {
    // 使用动态转换来获取对象块的开始
    RawAddress ptr=dynamic_cast(this);
    // 看看它是否在“地址”中
    返回 find(addresses.begin(), 地址.end(), ptr) !=
      地址.end();
  }
};

// Meyers 省略了第一个 HeapTracked:: 限定符...
列表 HeapTracked::地址； 

原始文章还有更多内容需要阅读：Ron van der Wal 对此建议进行了评论，然后演示了其他替代堆跟踪方法。

Answer 15

看看这里的程序：http://alumni.cs.ucr。 edu/~saha/stuff/memaddr.html。通过一些转换，它输出：

        Address of main: 0x401090
        Address of afunc: 0x401204
Stack Locations:
        Stack level 1: address of stack_var: 0x28ac34
        Stack level 2: address of stack_var: 0x28ac14
        Start of alloca()'ed array: 0x28ac20
        End of alloca()'ed array: 0x28ac3f
Data Locations:
        Address of data_var: 0x402000
BSS Locations:
        Address of bss_var: 0x403000
Heap Locations:
        Initial end of heap: 0x20050000
        New end of heap: 0x20050020
        Final end of heap: 0x20050010

Answer 16

有特定于平台的解决方案：

Windows：有查询堆栈范围的系统函数，请参阅问题
https://stackoverflow.com/q/3918375/9437799。利用这些堆栈变量可以被唯一地标识。

Posix： 同样，pthread_attr_getstack() 应该提供堆栈范围。

根据您的问题，不需要考虑数据段中的变量，否则您可能会迭代分配给进程的模块并查询它们的内存范围。