Переопределение виртуальной функции [[noreturn]]

Question

Атрибут [[noreturn]] может применяться к функциям, которые не предназначены для возврата. Например:

[[noreturn]] void will_throw() { throw std::runtime_error("bad, bad, bad ...."); } 

Но я столкнулся со следующей ситуацией (нет, я не проектировал это):

class B { 
public: 
    virtual void f() { throw std::runtime_error(""); } 
}; 

class D : public B { 
    void f() override { std::cout << "Hi" << std::endl; } 
}; 

Я бы очень хотел, чтобы поместить атрибут [[noreturn]] на B::f() декларации. Но я не понимаю, что происходит с переопределением в производном классе. Успешное возвращение из функции [[noreturn]] приводит к неопределенному поведению, и я, конечно, не хочу этого, если переопределение также наследует атрибут.

Вопрос: Переопределелив [[noreturn] virtual void B::f(), я наследовать атрибут [[noreturn]]?

Я просмотрел стандарт C++ 14, и у меня возникли проблемы с определением того, наследуются ли атрибуты.

Answer 1

На практике, ни g++, clang ни MSVC рассматривать атрибут [[noreturn]] как унаследованной

#include <iostream> 

struct B { 
public: 
    [[noreturn]] virtual void f() { std::cout << "B\n"; throw 0; } 
}; 

struct D : public B { 
    void f() override { std::cout << "D\n"; } 
}; 

int main() 
{ 
    try { B{}.f(); } catch(...) {} 
    D{}.f(); 

    B* d = new D{}; 
    d->f(); 
} 

, которая выводит "B", "D" и "D" для всех трех составителей.

Answer 2

Я прошел через стандарт, и нет никаких указаний на то, что либо [[noreturn]] конкретно, либо атрибуты в целом, «наследуются» посредством переопределения функций.

Это трудно доказать обратное, и стандарт фактически не декларирует это так или иначе, но, так как A::f() и B::f() еще различные функции и только поведение, описанное определяется в терминах функций, я думаю, что вы в безопасности для отметки A::f() как [[noreturn]].

Это, как говорится, я не могу представить, какую полезную оптимизацию мог бы выполнить компилятор, учитывая динамическую отправку.

Answer 3

Рассмотрим то, что вы на самом деле говорят:

class B 
{ 
public: 
    [[noreturn]] virtual void f() { throw std::runtime_error(""); } 
}; 

Конечно, человеческий читатель, и, возможно, компилятор, будет интерпретировать это как «контракт», т.е.
«f() не возвратит, я обещаю»

Это должно также применяться к переопределению f(), иначе вы нарушаете договор.

Этот стандарт может быть указан ниже, но даже если он будет работать, я бы рекомендовал против него на основе удобочитаемости.