我有
class Foo {
....
}
function blah() {
Foo foo; // on the stack
}
并且
function blah() {
Foo foo* = new Foo(); // on the heap
}
我希望根据Foo对象是在堆上还是栈上分别实现不同的功能。
编辑：
很多人问我“为什么这样做？”
答案是：
我现在正在使用引用计数的GC。但是，我也想能够运行标记和清除算法。为此，我需要标记一组“根”指针--这些指针位于堆栈上。因此，对于每个类，我想知道它们是在堆上还是在栈上。
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;
}
};
如果对象是在栈上创建的，那么它必须位于外部函数栈变量方向的某个地方。堆通常从另一侧增长，因此栈和堆会在中间某处相遇。
（当然，有些系统可能不适用这种情况）
更新：
既然您在问题中澄清了原因，那我道歉，您可能已经找到了很少几个需要这样做的领域（运行自己的垃圾回收进程）。理想情况下，您需要覆盖所有内存分配和释放运算符以跟踪从堆中创建和删除的内容。
然而，我不确定是否简单地拦截类的new/delete操作，因为有些情况下可能不会调用delete，而且由于标记/扫描依赖于引用计数，因此您需要能够拦截指针赋值才能使其正常工作。
您考虑过如何处理这个问题吗？
经典的例子：
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问题”。很多时候，人们会提出一个预设解决方案的问题，而更好的方法是只描述问题本身，不要预先设想最佳解决方案。
boost::shared_ptr，这是一个更加规范和经过测试的实现引用计数的方式。 - GManNickGstd::shared_ptr来解决boost::shared_ptr存在的一些问题，或者使用@GManNickG。 - user1203803如果你将“this”的值与当前堆栈指针的值进行比较，那么有可能判断出你是否在堆栈中分配了空间。如果“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
new的hack是否不可靠：你如何知道调用placement new时会将对象放在堆栈上还是堆中？ - Matthieu M./proc/<pid>/maps）。每个线程都有一个分配给其堆栈的区域。静态和全局变量将驻留在.bss section，常量在rodata或const段中等等。new操作符可能是你想要做的。在C++中，唯一安全的在堆上创建对象的方法是使用new操作符，因此你可以区分存在于堆上的对象和其他形式的内存。请搜索“在C++中重载new”以获取更多信息。new 无法被替换。话虽如此，vector并没有使用placement-new。（或者其他容器也是如此。）它们调用其分配器的construct方法。（通常会调用placement-new。:P） - GManNickG如上所述，您需要通过重载 new 运算符来控制对象的分配。但要注意两点：首先是'定位 new'运算符，它在用户预分配的内存缓冲区内初始化您的对象；其次，没有任何防止用户将任意内存缓冲区强制转换为您的对象类型。
char buf[0xff]; (Foo*)buf;
不行，这不能可靠或合理地完成。
您可能能够通过重载new来检测何时使用new分配对象。
但是如果对象作为类成员构造，拥有类在堆上分配怎么办？
这是第三个代码示例，添加到您已经拥有的两个示例中：
class blah {
Foo foo; // on the stack? Heap? Depends on where the 'blah' is allocated.
};
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;
}
如果pax提出的元问题是“你为什么要这样做”，你可能会得到更详细的答案。
现在假设你是出于“好奇心”而这样做的，可以通过重载new和delete运算符来实现此行为，但不要忘记重载所有 12个变体，包括：
new，delete，new no throw，delete no throw，new array，delete array，new array no throw，delete array no throw，placement new，placement delete，placement new array，placement delete array。
你可以将这个放在一个基类中并从中派生。
这有点麻烦，所以你想要什么不同的行为呢？