Question

我在Static member reclaiming memory and recovering from an exception

询问了这个问题的帮助

以下程序是使用自己的新运算符分配内存。我必须在第5个对象分配上抛出异常并通过释放内存来恢复（奇怪的问题，我知道，但它是赋值）

我在这里写了代码。分配工作，但当我尝试调用删除（通过选项'2'）时，我陷入无限循环。

#include <iostream>
#include <cstdlib>

using namespace std;

class object
{
    int data;
    static int count;
    static void* allocatedObjects[5];
public:
    object() {  }
    void* operator new(size_t);
    void operator delete(void *);
    void static release();
    void static printCount()
    {
        cout << count << '\n';
    }
    ~object()
    {
        release();
    }
};

int object::count = 0;
void* object::allocatedObjects[5];

void* object::operator new(size_t size)
{
    if (count > 5)
        throw "Cannot allocate more than 5 objects!\n";
    void *p = malloc(size);
    allocatedObjects[count] = p;
    count++;
    return p;
}

void object::operator delete(void *p)
{
    free(p);
    count--;
}

void object::release()
{
    while (count > 0)
    {
        delete static_cast<object*> (allocatedObjects[count]);
    }
}

int main()
{
    object *o[10];
    int i = -1;
    char c = 1;
    while (c != '3')
    {
        cout << "Number of objects currently allocated : ";
        object::printCount();
        cout << "1. Allocate memory for object.\n";
        cout << "2. Deallocate memory of last object.\n";
        cout << "3. Exit.\n";
        cin >> c;
        if (c == '1')
        {
            try
            {
                i++;
                o[i] = new object;
            }
            catch (char* e)
            {
                cout <<e;
                object::release();
                i = 0;
            }
        }
        else if (c == '2' && i >= 0)
        {
            delete o[i];
            i--;
        }
    }
    return 0;
}

我做错了什么？

修改我已经修复了删除问题。通过摆脱析构函数。并明确地在main结束时调用release。

但是现在我的catch块没有捕获异常。分配5个对象后抛出异常（通过调试器跟踪）但未捕获。新的代码更改不会影响相关代码。

Answer 1

发生无限循环是因为析构函数（~object()）在object::operator delete()之前被调用。析构函数试图删除最近分配的对象，该对象在同一对象上调用析构函数。永远不会调用operator delete()。

我不确定allocatedObjects在这里取得了什么，如果没有它，代码就可以运行。摆脱release ()。

<强>更新

好的，所以需要发布（异常处理）。

不要从析构函数中调用release。相反，在调用operator delete()（镜像allocatedObjects）之后，使free函数将operator new()条目设置为0。 release()函数仅在异常处理期间调用，并确保正确释放未释放的内存（即循环遍历allocatedObjects数组和free非零条目，然后将它们设置为零。

在解除分配内存时陷入无限循环

1 个答案: