Question

请参阅以下代码及其输出 - 请解释我的代码

void abc(int);

class A
{
public:
    A()
    {
        cout<<"Constructor Called";
    }
    ~A()
    {
        cout<<"Destructor called";
    }
};

int main()
{
    try
    {
        abc(-1);
    }
    catch(int p)
    {
        cout<<p<<endl;
    }
    return 0;
}

void abc(int p)
{
    A * Aptr = new A[2];
    if(p<0)
        throw p;
}

输出：

Constructor Called
Constructor Called
-1

任何人都可以解释为什么在正常堆栈展开的情况下不会调用析构函数

Answer 1

这个指针：

 A * Aptr = new A[2];

是一个原始指针。当它超出范围时，只有指针本身被销毁 - 它指向的数组没有任何操作。因此，数组不是delete[]，并且不会调用析构函数。这是内存泄漏的典型示例。

这个问题有三种典型的解决方案：

在堆栈上分配数组本身
使用std::vector
使用智能指针（不是std::auto_ptr - 它不适合与数组一起使用。

Answer 2

不会调用析构函数，因为您分配的对象永远不会被删除。如果删除了throw，则会获得相同的输出。

另一方面，如果您将功能更改为：

void abc(int p)
{
    A A_array[2];
    if (p<0)
        throw p;
}

你会看到析构函数被调用。

Answer 3

正如其他地方所提到的，C ++指针不会删除超出范围时指向的内存。您有几个选择：

艰难的方法 - 尝试自己做内存管理。这种方式存在内存泄漏和缓冲区溢出。尽量不要这样做。

void abc(int p)
{
    A * Aptr = new A[2];
    if(p<0)
    {
        delete [] Aptr;
        throw p;
    }
    delete [] Aptr;
}

将数组放在堆栈上，让正常的堆栈展开处理它：

void abc(int p)
{
   A Aptr[2];
   if (p<0)
       throw p;
}

不使用原始指针指向新分配的数组，而是使用智能指针类（如scoped_array或shared_array或其他一些RAII类来保持它：
```
void abc(int p)
{
    boost::scoped_array<A> Aptr (new A[2]);
    if(p<0)
        throw p;
    }
}
```

2和3实际上是C ++代码中唯一使用异常的安全选项 - 如果使用原始指针和手动内存管理，迟早会出现内存泄漏。无论你多么小心，异常安全代码几乎都需要RAII。

Answer 4

除了有关boost::shared_array和boost::scoped_array的建议外，您还可以使用std :: vector：

std::vector<A> array( 2 );
if( p < 0 ) 
  throw p;

请注意，如果你走这条路线，你的类型应该是可复制的，因为std :: vector会在插入期间或内部调整大小时复制它们等等。

Answer 5

可能是因为您没有在delete课程上致电A吗？如果不删除动态分配的类，则不会调用析构函数。

Answer 6

因为你在堆上分配了。释放的是包含指向对象数组的指针的变量。不是对象本身。

Answer 7

Aptr是堆分配的变量，而不是堆栈变量。您需要显式删除它以便调用析构函数（并释放内存）。

Answer 8

如果你愿意这样做：

A a[2];

而不是

A *Aptr = new A[2];

你得到了析构函数。你动态分配的任何东西都必须自行解除分配。

Answer 9

您在堆上创建了对象。删除对象时，析构函数将为callen。

如果不在堆上创建对象，则将按预期调用析构函数。

异常处理代码请解释一下

9 个答案: