Question

假设以下头文件：

#ifndef TEST_HEADER
#define TEST_HEADER 

class myFoo
{
    public:
    myFoo(unsigned long *ulbaz):
    baz(ulbaz)
    {
      *baz++;
    }
    ~myFoo()
    {
      *baz--;
    }
    private:
        unsigned long *baz;
    };

#define DEFINE_A( a ) myFoo bar( a);
#define DEFINE_B( b ) 

#endif  // test_header

代码示例：

// code.cpp

#include "test.h"
unsigned long mylong = 0L;


int main()
{
    DEFINE_A( &mylong);
    DEFINE_B( &mylong);
}

如您所见，DEFINE_B为空。我不明白的是：每次调用DEFINE_B时，我都会从myFoo进入析构函数，我可以在callstack中看到 - 这怎么可能？据我所知，空define扩展为;。

编辑：此代码现在有效。

Answer 1

我假设您正在运行以下主要内容：

int main (int argc, char const* argv[])
{
    unsigned long mylong = 0L;
    DEFINE_A( &mylong);
    DEFINE_B( &mylong);
    return 0;
}

行DEFINE_B( b )扩展为空，您看到类myFoo的析构函数，因为当到达作用域的末尾时，通过调用删除在其中创建的所有对象他们的破坏者。

Answer 2

这是由对象超出范围引起的。想象一下下面的例子，它将证明这一点：

#include <iostream>

#define EXAMPLEMACRO

class Test {
public:
    Test() {}
    ~Test() {}
}

int main() {

    //Open a new scope
    {
        EXAMPLEMACRO //This doesn't do anything!
        Test t();
        EXAMPLEMACRO //This called the destructor?
    }

    return 0;
}

它不会调用析构函数，只是你的对象超出范围。

Answer 3

这一行：

DEFINE_B( &mylong);

将变为此代码。换句话说，NOTHING将完全发生在那条线上。

从空定义调用析构函数？

3 个答案: