Как поймать исключение конструктора?

Question

У меня есть класс C++, который генерирует исключение из конструктора при ошибке. Как я могу выделить локальный экземпляр этого класса (без использования new) и обрабатывать любые возможные исключения, сохраняя при этом размер блока try как можно меньше?

По существу, я ищу на C++ эквивалент следующего Java идиомы:

boolean foo() { 
    Bar x; 
    try { 
     x = new Bar(); 
    } catch (Exception e) { 
     return false; 
    } 
    x.doSomething(); 
    return true; 
} 

Я не хочу, чтобы перехватывать исключения из x.doSomething(), только конструктор.

Я предполагаю, что я ищу способ отделить декларацию и инициализацию x.

Можно ли выполнить это без использования распределений кучи и указателей?

Answer 1

Вы можете использовать std::optional от C++ 17:

bool foo() { 
    std::optional<Bar> x; // x contains nothing; no Bar constructed 
    try { 
     x.emplace();  // construct Bar (via default constructor) 
    } catch (const Exception& e) { 
     return false; 
    } 
    x->doSomething();  // call Bar::doSomething() via x (also (*x).doSomething()) 
    return true; 
} 

Answer 2

Вы должны выбрать между вариантом

bool foo() { 
    std::unique_ptr<Bar> x; 
    try { 
     x = std::make_unique<Bar>(); 
    } catch (const BarConstructorException& e) { 
     return false; 
    } 
    x->doSomething(); 
    return true; 
} 

или

bool foo() { 
    try { 
     Bar x; 
     x.doSomething(); 
    } catch (const BarConstructorException& e) { 
     return false; 
    } 
    return true; 
} 

Answer 3

Обычно, если вы хотите, чтобы избежать распределения кучи, вы не можете отделить декларацию локальной переменной из ее определения. Так что если вы должны были объединить все в одной функции, вы должны сделать окружать весь объем x с try/catch блока:

boolean foo() { 
    try { 
     Bar x; 
     x.doSomething(); 
    } catch (Exception e) { 
     return false; 
    } 
    return true; 
} 

Answer 4

Да, это возможно, если вы поставите весь код в пункте try, для например, с помощью function try block (чтобы избежать ненужной вложенности и области видимости):

bool foo() try 
{ 
    Bar x; 
    x.doSomething(); 
    return true; 
} 
catch (std::exception const& e) 
{ 
    return false; 
} 

Или в try пункте вызове другой функции, которая делает реальную работу:

void real_foo() 
{ 
    Bar x; 
    x.doSomething(); 
} 

bool foo() try 
{ 
    real_foo(); 
    return true; 
} 
catch (std::exception const& e) 
{ 
    return false; 
} 

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

---

Как отметил Холт, это будет также перехватывать исключения из doSomething вызова. Есть два пути решения, что:

1. Простой и стандартный способ: использовать указатели.

2. Используйте двухэтапную конструкцию: используйте конструктор по умолчанию, который не может генерировать исключения, а затем вызывает специальную функцию «построить», которая может генерировать исключения.

Второй способ был распространен прежде, чем C++ был стандартизован, и широко используется в коде для Symbian system. Это не часто встречается, так как использование указателей для этого намного проще и проще, особенно сегодня с хорошими интеллектуальными указателями. Я действительно не рекомендую второй способ в современном C++.

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

Если вы все еще хотите отбрасывать исключения из конструктора, на самом деле есть третий способ поймать только те: Используйте один из примеров кода вверху и бросайте только определенные исключения, которые doSomething никогда не может выбросить, а затем поймать их только конструкторы.

Answer 5

No. Из вашего примера Java, вам придется выбирать между этими 2 возможностями:

Без указателей:

bool foo() { 
    try { 
     Bar x; 
     x.doSomething(); 
    } catch (Exception e) { 
     return false; 
    } 
    return true; 
} 

с указателями:

bool foo() { 
    Bar* x = nullptr; 
    try { 
     x = new Bar(); 
    } catch (Exception e) { 
     return false; 
    } 
    x->doSomething(); 

    delete x; // don't forget to free memory 

    return true; 
} 

Или с помощью управляемых указателей:

#include <memory> 

bool foo() { 
    std::unique_ptr<Bar> x; 
    try { 
     x = new Bar();    // until C++14 
     x = std::make_unique<Bar>(); // since C++14 
    } catch (Exception e) { 
     return false; 
    } 
    x->doSomething(); 
    return true; 
} 

Answer 6

Эта идиома Java не хорошо переводит на C++, так как Bar x; потребует конструктор по умолчанию, даже если вашему реальному конструктору нужны аргументы.

Я бы посоветовал бороться с языком в такой степени - расширение try блока достаточно, - но если вы действительно хотите сузить, то вы могли использовать функцию и полагаться на оптимизации возвращаемого значения чтобы избежать Копия значения:

Bar foobar() 
{ 
    try { 
     return Bar(); 
    } catch (Exception& e){ 
     /* Do something here like throwing a specific construction exception 
      which you intercept at the call site.*/ 
    } 
} 

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

Answer 7

В пересмотренном вопросе OP добавляет требование

” Я не хочу, чтобы перехватывать исключения из x.doSomething(), только конструктор [локальной переменной].

Простой способ перевести код Java

boolean foo() { 
    Bar x; 
    try { 
     x = new Bar(); 
    } catch (Exception e) { 
     return false; 
    } 
    x.doSomething(); 
    return true; 
} 

& hellip; на C++, затем использовать Optional_ класс (как Barton-Nackmann Fallible, boost::optional или 17 std::optional C++)

auto foo() 
    -> bool 
{ 
    Optional_<Bar> xo; 
    try 
    { 
     xo.emplace(); 
    } 
    catch(...) 
    { 
     return false; 
    } 

    Bar& x = *xo; 
    // Possibly other code here, then: 
    x.doSomething(); 
    return true; 
} 

Хорошая альтернатива реорганизовать этот код, как это:

struct Something_failure {}; 

void do_something(Bar& o) 
{ 
    // Possibly other code here, then: 
    o.doSomething(); 
} 

auto foo() 
    -> bool 
{ 
    try 
    { 
     Bar x; 

     do_something(x); 
     return true; 
    } 
    catch(Something_failure const&) 
    { 
     throw; 
    } 
    catch(...) 
    {} 
    return false; 
} 

Если вам не нравятся вышеупомянутые подходы, вы можете всегда использовать динамически выделенный Bar экземпляр, например используя std::unique_ptr для гарантированной очистки, который, однако, имеет общие накладные расходы на динамическое распределение. В Java каждый объект динамически распределяется так, чтобы он не представлял собой серьезный недостаток. Но в C++ большинство объектов являются супербыстрое распределением стека, так что динамическое распределение - это довольно медленная операция по сравнению с обычными операциями, поэтому возможная концептуальная простота динамического распределения должна быть взвешена против этого.