Question

继续：Is the destructor called when a delegating constructor throws?

class X
{
public:
    X()       {};
    X(int)    : X() { throw std::exception(); }
    X(double)       { throw std::exception(); }
    ~X();
};

动态记忆怎么样？通常，构造函数中的异常意味着对象没有完全构造，因此内存是干净的而不会丢失。

但是上一个问题中的论点是在委托完成后对象完全构造（或完全初始化）。这对回收内存有何影响？我希望记忆仍然是清洁的！

int main()
{
    new X(5);        // new called 
                     // delete called because delegate completed.
                     // I assume:  
                     //      Memory re-claimed (because constructor did not complete)
                     //      I assume the C++11 standard adjusted to compensate.
                     //      As a constructor did complete.
}

也相比：

int main()
{
    new X(5.0);      // new called 
                     //    Delete **NOT** called
                     // Memory re-claimed (because constructor did not complete)
}

如果清理内存，则需要从C ++ 03规范中更改内存清理时间的定义。行为是如何改变的？

Answer 1

如果new调用的构造函数抛出异常，则new分配的内存将自动释放。委托构造者在这方面没有任何改变。

如果上面描述的对象初始化的任何部分⁷⁶通过抛出异常终止并且可以找到合适的释放函数，则调用释放函数以释放构造对象的内存。

- C ++ 11 [expr.new] 5.3.4 / 18

描述的'对象初始化的任何部分'包括构造函数调用和传递给构造函数的表达式的评估。

此外，在C ++ 98标准[C ++ 98 5.4.3 / 17]中指定了相同的行为。委托构造函数的唯一区别是，如果您的心智模型以前基于完全构造的对象。给定的委托构造函数不再等于何时发生重新分配的实际规范。

在你的第一个例子中：

new X(5);

事件的顺序是：

分配函数叫
X（int）名为
- X（）调用（并成功退出）
- X（int）抛出异常
- ~X（）调用
X（int）通过异常退出
因为对象初始化失败而被调用的释放函数
异常继续正常传播

使用第二个例子

new X(5.0);

分配函数叫
X（双人）叫
X（double）因异常而失败
因为对象初始化失败而被调用的释放函数
异常继续正常传播

您可以通过替换分配和释放功能来观察此行为：

#include <iostream>
#include <cstdlib>
#include <stdexcept>
#include <new>

void *operator new(std::size_t s) {
    if (void *ptr = std::malloc(s)) {
        std::cout << "allocation\n";
        return ptr;
    }
    throw std::bad_alloc{};
}

void operator delete(void *ptr) noexcept {
    if (ptr) {
        std::cout << "deallocation\n";
        std::free(ptr);
    }
}

struct S {
    S() {};
    S(int) : S{} { throw std::exception(); }
    S(double) { throw std::exception(); }
    ~S() { std::cout << "destructor\n"; }
};

int main() {
    std::cout << "test 1\n";
    try {
        new S(1);
    } catch(...) {
        std::cout << "exception caught\n";
    }

    std::cout << "test 2\n";
    try {
        new S(1.);
    } catch(...) {
        std::cout << "exception caught\n";
    }
}

该程序的正确输出是：

test 1
allocation
destructor
deallocation
exception caught
test 2
allocation
deallocation
exception caught

委托构造函数抛出时是否自动回收内存？

1 个答案: