在C++11及以后，如何判断抽象基类的构造函数是否为noexcept？以下方法无效:

#include <new>
#include <type_traits>
#include <utility>

struct Base { Base() noexcept; virtual int f() = 0; };

// static assertion fails, because !std::is_constructible<Base>::value:
static_assert(std::is_nothrow_constructible<Base>::value, "");

// static assertion fails, because !std::is_constructible<Base>::value:
static_assert(std::is_nothrow_default_constructible<Base>::value, "");

// invalid cast to abstract class type 'Base':
static_assert(noexcept(Base()), "");

// invalid new-expression of abstract class type 'Base'
static_assert(noexcept(new (std::declval<void *>()) Base()), "");

// cannot call constructor 'Base::Base' directly:
static_assert(noexcept(Base::Base()), "");

// invalid use of 'Base::Base':
static_assert(noexcept(std::declval<Base &>().Base()), "");

一个简单的用途是:

int g() noexcept;
struct Derived: Base {
    template <typename ... Args>
    Derived(Args && ... args)
            noexcept(noexcept(Base(std::forward<Args>(args)...)))
        : Base(std::forward<Args>(args)...)
        , m_f(g())
    {}

    int f() override;

    int m_f;
};

关于如何归档这个或者在不修改抽象基类的情况下是否有可能？

PS:也欢迎任何对 ISO C++ 缺陷报告或正在进行的工作的引用。

编辑: 正如两次指出的那样，将 Derived 构造函数默认为 = default 会使 noexcept 被继承.但这并不能解决一般情况下的问题。

最佳答案

[更新:值得跳到编辑部分]

好的，我找到了一个解决方案，尽管由于 GCC 中的一个错误，它不能与所有编译器一起编译(有关详细信息，请参阅 this question)。

解决方案基于继承的构造函数和函数调用的解析方式。
考虑以下示例:

#include <utility>
#include <iostream>

struct B {
    B(int y) noexcept: x{y} { }
    virtual void f() = 0;
    int x;
};

struct D: public B {
private:
    using B::B;

public:
    template<typename... Args>
    D(Args... args)
    noexcept(noexcept(D{std::forward<Args>(args)...}))
        : B{std::forward<Args>(args)...}
    { }

    void f() override { std::cout << x << std::endl; }
};

int main() {
    B *b = new D{42};
    b->f();
}

我想这很清楚。
无论如何，如果您发现某些内容需要更多详细信息，请告诉我，我很乐意更新答案。
基本思想是我们可以直接从基类及其构造函数继承 noexcept 定义，这样我们就不必再在 noexcept 语句中引用该类了.

Here你可以看到上面提到的工作示例。

[编辑]

从评论来看，如果基类的构造函数和派生类的构造函数具有相同的签名，则该示例会遇到问题。
感谢 Piotr Skotnicki 指出这一点。
我将提及这些评论，我将复制并粘贴与他们一起提出的代码(在需要时提及作者)。

首先，here我们可以看到该示例没有按预期工作(感谢 Piotr Skotnicki 提供的链接)。
代码和之前贴的差不多，这里就不复制粘贴了。
此外，来自同一作者，它遵循一个示例 that shows that the same solution works as expected under certain circumstances (更多细节见评论):

#include <utility>
#include <iostream>

struct B {
    B(int y) noexcept: x{y}
    {
        std::cout << "B: Am I actually called?\n";
    }
    virtual void f() = 0;
    int x;
};

struct D: private B {
private:
    using B::B;

public:
    template<typename... Args>
    D(int a, Args&&... args)
    noexcept(noexcept(D{std::forward<Args>(args)...}))
        : B{std::forward<Args>(args)...}
    {
        std::cout << "D: Am I actually called?\n";
    }
    void f() override { std::cout << x << std::endl; }
};

int main()
{
    D* d = new D{71, 42};
    (void)d;
}

另外，我提出了一个更具侵入性的替代解决方案，它基于 std::allocator_arg_t 所代表的想法，这也是 Piotr Skotnicki 在评论:

it's enough if derived class' constructor wins in overload resolution.

它遵循提到的代码here :

#include <utility>
#include <iostream>

struct B {
    B(int y) noexcept: x{y}
    {
        std::cout << "B: Am I actually called?\n";
    }
    virtual void f() = 0;
    int x;
};

struct D: public B {
private:
    using B::B;

public:
    struct D_tag { };

    template<typename... Args>
    D(D_tag, Args&&... args)
    noexcept(noexcept(D{std::forward<Args>(args)...}))
        : B{std::forward<Args>(args)...}
    {
        std::cout << "D: Am I actually called?\n";
    }
    void f() override { std::cout << x << std::endl; }
};

int main()
{
    D* d = new D{D::D_tag{}, 42};
    (void)d;
}

再次感谢 Piotr Skotnicki 的帮助和评论，非常感谢。

关于c++ - 判断一个抽象基类的构造函数是否为noexcept？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35777287/