3

考虑以下代码：

#include <new>
#include <malloc.h>
#include <stdio.h>

void * operator new(size_t size) {
    void *res;
    if (size == 1) {
        res = NULL;
    } else {
        res = malloc(size);
    }
    fprintf(stderr, "%s(%zu) = %p\n", __PRETTY_FUNCTION__, size, res);
    if (res == NULL) throw std::bad_alloc();
    return res;
}

void * operator new(size_t size, const std::nothrow_t&) {
    void *res;
    if (size == 1) {
        res = NULL;
    } else {
        res = malloc(size);
    }
    fprintf(stderr, "%s(%zu) = %p\n", __PRETTY_FUNCTION__, size, res);
    return res;
}

void operator delete(void *ptr) {
    fprintf(stderr, "%s(%p)\n", __PRETTY_FUNCTION__, ptr);
    free(ptr);
}

void operator delete(void *ptr, const std::nothrow_t&) {
    fprintf(stderr, "%s(%p)\n", __PRETTY_FUNCTION__, ptr);
    free(ptr);
}

class Foo { };

class Bar {
public:
    Bar() : ptr(new Foo()) {
        fprintf(stderr, "%s: ptr = %p\n", __PRETTY_FUNCTION__, ptr);
    }
    Bar(const std::nothrow_t&) noexcept : ptr(new(std::nothrow) Foo()) {
        fprintf(stderr, "%s: ptr = %p\n", __PRETTY_FUNCTION__, ptr);
    }
    ~Bar() noexcept {
        delete ptr;
    }
    Foo *ptr;
};

class Baz {
public:
    Baz() : ptr(new Foo()) {
        fprintf(stderr, "%s: ptr = %p\n", __PRETTY_FUNCTION__, ptr);
    }
    ~Baz() {
        delete ptr;
    }
    Foo *ptr;
};

int main() {
    Bar *bar = new(std::nothrow) Bar(std::nothrow_t());
    if (bar != NULL) {
        delete bar;
    } else { fprintf(stderr, "bad alloc on Bar(std::nothrow_t())\n"); }
    fprintf(stderr, "\n");
    try {
        bar = new(std::nothrow) Bar();
        delete bar;
    } catch (std::bad_alloc) { fprintf(stderr, "bad alloc on Bar()\n"); }
    fprintf(stderr, "\n");
    try {
        Baz *baz = new Baz();
        delete baz;
    } catch (std::bad_alloc) { fprintf(stderr, "bad alloc on Baz()\n"); }
}

这会产生以下输出：

void* operator new(size_t, const std::nothrow_t&)(8) = 0x1fed010
void* operator new(size_t, const std::nothrow_t&)(1) = (nil)
Bar::Bar(const std::nothrow_t&): ptr = (nil)
void operator delete(void*)((nil))
void operator delete(void*)(0x1fed010)

void* operator new(size_t, const std::nothrow_t&)(8) = 0x1fed010
void* operator new(std::size_t)(1) = (nil)
void operator delete(void*, const std::nothrow_t&)(0x1fed010)
bad alloc on Bar()

void* operator new(std::size_t)(8) = 0x1fed010
void* operator new(std::size_t)(1) = (nil)
void operator delete(void*)(0x1fed010)
bad alloc on Baz()

如您所见，尽管分配 Foo 失败，但分配第一个 Bar 成功。Bar 的第二次分配和 Baz 的分配通过使用 std::bad_alloc 正确失败。

现在我的问题是：如何制作“new(std::nothrow) Bar(std::nothrow_t());” 当 Foo 分配失败时释放 Bar 的内存并返回 NULL？依赖倒置是唯一的解决方案吗？

4

2 回答 2

2

C++11 §5.3.4/18：

”如果上述对象初始化的任何部分因抛出异常而终止并且可以找到合适的释放函数，则调用释放函数以释放构造对象的内存，之后异常继续在new-expression的上下文。

所以std::nothrow不保证new-expression没有例外。它只是传递给分配函数的参数，从标准库中选择不抛出的参数。它显然主要是为了支持更多的 C 风格的预标准代码。

现代 C++ 中的整个清理机制都是基于异常的。

解决这个问题——我认为这很愚蠢，不是一件要做的事，但你在问——做例如

#include <iostream>
#include <new>
#include <stdexcept>
#include <stdlib.h>         // EXIT_FAILURE
#include <typeinfo>
#include <utility>

namespace my { class Foo; }

template< class Type, class... Args >
auto null_or_new( Args&&... args )
    -> Type*
{
    #ifdef NULLIT
        if( typeid( Type ) == typeid( my::Foo ) ) { return nullptr; }
    #endif

    try
    {
        return new( std::nothrow ) Type( std::forward<Args>( args )... );
    }
    catch( ... )
    {
        return nullptr;
    }
}

namespace my
{
    using namespace std;

    class Foo {};

    class Bah
    {
    private:
        Foo*    p_;

    public:
        Bah()
            : p_( null_or_new<Foo>() )
        {
            clog << "Bah::<init>() reports: p_ = " << p_ << endl;
            if( !p_ ) { throw std::runtime_error( "Bah::<init>()" ); }
        }
    };
}  // namespace my

auto main() -> int
{
    using namespace std;
    try
    {
        auto p = null_or_new<my::Bah>();
        cout << p << endl;
        return EXIT_SUCCESS;
    }
    catch( exception const& x )
    {
        cerr << "!" << x.what() << endl;
    }
    return EXIT_FAILURE;
}

为什么要求的方法恕我直言是愚蠢的：

  • 它放弃了异常的安全性。无法保证对故障传播进行清理。确实没有保证的故障传播，这都是非常手动的。

  • 它丢弃有关失败的所有信息，例如异常消息。可以添加机制来保留其中的一些，但它变得复杂且效率低下。

  • 它没有我能想到的合理优势。

顺便提一下，格式说明符%zu和宏__PRETTY_FUNCTION__不适用于 Visual C++。

另请注意，为了返回空指针，必须将分配函数声明为不抛出。

附录

一个非常非常手动地做事的例子，甚至避免了内部异常。主要成本是放弃了通常的 C++ 机制，其中只有那些已经成功构建的数据成员在检测到故障时被销毁。取而代之的是，所有东西都必须构建为虚拟状态，以便拥有临时可用的僵尸对象。

#include <iostream>
#include <new>
#include <stdexcept>
#include <stdlib.h>         // EXIT_FAILURE
#include <typeinfo>
#include <utility>

namespace my { class Foo; }

struct Result_code { enum Enum { success, failure }; };

template< class Type, class... Args >
auto null_or_new( Args&&... args )
    -> Type*
{
    #ifdef NULLIT
        if( typeid( Type ) == typeid( my::Foo ) ) { return nullptr; }
    #endif

    auto code = Result_code::Enum();
    auto const p = new( std::nothrow ) Type( code, std::forward<Args>( args )... );
    if( p != nullptr && code != Result_code::success )
    {
        p->Type::~Type();
        ::operator delete( p, std::nothrow );
        return nullptr;
    }
    return p;
}

namespace my
{
    using namespace std;

    class Foo { public: Foo( Result_code::Enum& ) {} };

    class Bah
    {
    private:
        Foo*    p_;

    public:
        Bah( Result_code::Enum& code )
            : p_( null_or_new<Foo>() )
        {
            clog << "Bah::<init>() reports: p_ = " << p_ << endl;
            if( !p_ ) { code = Result_code::failure; }
        }
    };
}  // namespace my

auto main() -> int
{
    using namespace std;
    try
    {
        auto p = null_or_new<my::Bah>();
        cout << p << endl;
        return EXIT_SUCCESS;
    }
    catch( exception const& x )
    {
        cerr << "!" << x.what() << endl;
    }
    return EXIT_FAILURE;
}
于 2014-11-17T19:37:13.037 回答
0

假设您希望能够毫无例外地构建失败作为一般规则。

我将画出这样一个系统。

template<class Sig>
struct has_creator;
template<class T, class...Args>
struct has_creator<T(Args...)>

true_type这是一个特征类，如果您的类型T具有与签名匹配的静态方法，则该类派生自该类bool T::emplace_create(T*, Args&&...)。

emplace_create创建失败时返回 false。T*必须指向具有正确对齐sizeof(T)或更大的未初始化内存块。

我们现在可以这样写：

template<class T, class...Args>
T* create( Args&&... args )

这是一个检测是否T has_creator分配内存的函数，如果是，则执行一个emplace_create，如果失败，它会清理内存并返回nullptr。自然它使用 nothrow new。

您现在使用create<T>代替new无处不在。

最大的缺点是我们不能很好地支持继承。组合变得棘手：我们基本上将构造函数写入emplace_create其中，让我们的实际构造函数几乎什么都不做，并且emplace_create我们处理失败的情况（比如create<X>调用失败的子对象）。

我们在继承方面也几乎没有任何帮助。如果我们需要继承方面的帮助，我们可以编写两种不同的方法——一种用于无失败的初始构造，第二种用于容易失败的资源创建。

我会注意到，如果您停止在任何地方存储原始指针，它会变得不那么烦人。如果你将东西存储在std::unique_ptr任何地方（甚至到了create<T>返回的地步std::unique_ptr<T>），并通过 abort 抛出一个受保护的范围结束销毁器，那么你的析构器必须能够处理“半构造”对象。

于 2014-11-17T21:13:10.037 回答