关于使用noexcept覆盖throw（）函数，C ++标准有何说法？

Question

The following seems to compile on a couple of compilers that I've tried:

class A
{
public:
    virtual void foo() throw() = 0;
};

class B : public A
{
public:
    virtual void foo() noexcept override { }
};

It seems that one can override a throw() function with the newer noexcept specification. I also tried the opposite (overriding noexcept with throw()) and it seems to work. Why is that? Is this undefined behavior or is this allowed?

Please note that code generation is affected by noexcept vs throw(). They also do not have equivalent behavior since noexcept calls a different termination function than throw(). An ideal answer will call out the differences in behavior and why they do or do not matter in this case.

Answer 1

You can even do this without overriding:

void f() throw();
void f() noexcept { throw 1; }

[except.spec]/9 makes it clear that it is the specification on the definition that controls what happens:

Whenever an exception of type E is thrown and the search for a handler ([except.handle]) encounters the outermost block of a function with an exception specification that does not allow E, then,

• if the function definition has a dynamic-exception-specification , the function std::unexpected() is called ([except.unexpected]),

• otherwise, the function std::terminate() is called ([except.terminate]).

This isn't a problem because whatever special handling for this happens in the callee, not the caller; all the caller needs to know is that no exception will ever leave the function.

Answer 2

Is this undefined behaviour or is this allowed? This is allowed.

From the C++ standard:

If a virtual function has an exception specification, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the exception specification of the base class virtual function, unless the overriding function is defined as deleted.

Practically: you can override the method in the derived class and specify new rules in additional to those specified by the base class.

In your example throw() and noexcept are equivalent.