м, что если что-то отличается отmyExc выбрасывается твоей функцией,std::unexpectedудет вызываться @ (вместо обычного механизма необработанного исключения).

Для документирования исключений, которые может генерировать функция, я обычно делаю это:

bool
some_func() /* throw (myExc) */ {
}

которая возвращает только переменную-член и не может генерировать исключения, может использоваться некоторыми компиляторами для пессимизации (в противоположность оптимизации), которая может отрицательно сказаться на производительности. Это описано в литературе Boost: Exception-спецификация

С некоторые компиляторы Спецификация no throw для не встроенных функций может быть полезной, если выполнены правильные оптимизации и использование этой функции влияет на производительность так, как это оправдывает ее.

Для меня это звучит так: использовать это или нет - это вызов, сделанный очень критическим взглядом как часть усилий по оптимизации производительности, возможно, с использованием инструментов профилирования.

Цитата из приведенной выше ссылки для спешащих:

Обоснование спецификации исключения

Спецификации исключений [ISO 15.4] иногда кодируются, чтобы указать, какие исключения могут быть сгенерированы, или потому, что программист надеется, что они улучшат производительность. Но рассмотрим следующий член из умного указателя:

T & operator * () const throw () {return * ptr; }

Эта функция не вызывает никаких других функций; он манипулирует только базовыми типами данных, такими как указатели. Поэтому никогда нельзя вызывать поведение спецификации исключений во время выполнения. Функция полностью доступна для компилятора; на самом деле он объявлен как встроенный. Следовательно, умный компилятор может легко определить, что функции не способны генерировать исключения, и выполнить те же оптимизации, что и на основе пустой спецификации исключений. Однако «тупой» компилятор может создавать различные пессимизаци

Например, некоторые компиляторы отключают встраивание, если есть спецификация исключения. Некоторые компиляторы добавляют блоки try / catch. Такая пессимизация может привести к снижению производительности, что делает код непригодным для практического применения.

Несмотря на то, что спецификация исключений изначально привлекательна, она имеет последствия, которые требуют очень тщательного осмысления. Самая большая проблема со спецификациями исключений заключается в том, что программисты используют их так, как если бы они имели эффект, который хотел бы получить программист, а не тот эффект, который они фактически имеют.

Не встроенная функция - это то место, где спецификация исключений «ничего не выбрасывает» может иметь некоторое преимущество с некоторыми компиляторами.

Jalf уже связан с ним, но GOTW очень хорошо объясняет, почему спецификации исключений не так полезны, как можно было бы надеяться:

int Gunc() throw();    // will throw nothing (?)
int Hunc() throw(A,B); // can only throw A or B (?)

Правильны ли комментарии? Не совсем.Gunc() действительно может что-то бросить, аHunc() вполне может бросить что-то кроме A или B! Компилятор просто гарантирует, что побеждать их будет бессмысленно, если они это сделают ... и большую часть времени бить вашу программу тоже бессмысленно.

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

Вывод GOTWs:

Вот что я считаю лучшим советом, который мы, как сообщество, получили на сегодняшний день:

это было сделано с наилучшими намерениями, но практика подтвердила более практический подход.

С C ++ мое общее правило - использовать только спецификации броска, чтобы указать, что метод не может бросить. Это сильная гарантия. В противном случае предположим, что он может выбросить что угодно.

от вопрос, нужно потратить несколько минут на вопрос: каков вывод следующего кода?

#include <iostream>
void throw_exception() throw(const char *)
{
    throw 10;
}
void my_unexpected(){
    std::cout << "well - this was unexpected" << std::endl;
}
int main(int argc, char **argv){
    std::set_unexpected(my_unexpected);
    try{
        throw_exception();
    }catch(int x){
        std::cout << "catch int: " << x << std::endl;
    }catch(...){
        std::cout << "catch ..." << std::endl;
    }
}

Ответ: как уже отмечалосьВо, программа вызываетstd::terminate() и, следовательно, ни один из обработчиков исключений не будет вызван.

Детали: Первыйmy_unexpected()ункция @ вызывается, но поскольку она не перебрасывает соответствующий тип исключения дляthrow_exception() прототип функции, в конце концов,std::terminate() называется. Таким образом, полный вывод выглядит так:

user @ user: ~ / tmp $ g ++ -o исключением.test кроме.test.cpp
user @ user: ~ / tmp $ ./except.tes
хорошо - это было неожиданно
terminate вызывается после создания экземпляра i
Aborted (ядро сброшено)

- http: //blogs.msdn.com/b/larryosterman/archive/2006/03/22/558390.asp)

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

   class MyClass
   {
    size_t CalculateFoo()
    {
        :
        :
    };
    size_t MethodThatCannotThrow() throw()
    {
        return 100;
    };
    void ExampleMethod()
    {
        size_t foo, bar;
        try
        {
            foo = CalculateFoo();
            bar = foo * 100;
            MethodThatCannotThrow();
            printf("bar is %d", bar);
        }
        catch (...)
        {
        }
    }
};

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

Кроме того, инструменты анализа исходного кода, такие как prefast, могут (и будут) использовать аннотацию throw () для улучшения своих возможностей обнаружения ошибок - например, если у вас есть try / catch и все вызываемые вами функции помечены как throw () , вам не нужен try / catch (да, это проблема, если вы позже вызовете функцию, которая может генерировать).