Sta rilevando un'eccezione per riferimento pericoloso?

Question

Si prega di dare un'occhiata al seguente lancio eccezione e la cattura di:

void some_function() { 
    throw std::exception("some error message"); 
} 

int main(int argc, char **argv) { 
    try { 
     some_function(); 
    } catch (const std::exception& e) { 
     std::cerr << e.what() << std::endl; 
     exit(1); 
    } 
    return 0; 
} 

E 'sicuro di catturare l'eccezione generata per riferimento?

La mia preoccupazione è che l'eccezione e è in realtà posto sulla pila disome_function(). Ma some_function() è appena tornato, causando la distruzione di e. Quindi in realtà ora e punti a un oggetto distrutto.

La mia preoccupazione è corretta?

Qual è il modo corretto per superare l'eccezione senza copiarlo in base al valore? Devo lanciare new std::exception() così viene inserito nella memoria dinamica?

Answer 1

è infatti sicuro - e raccomandato - a cogliere di const riferimento.

"e è effettivamente immesso sul pila di some_function()"

No, non è ...l'oggetto effettivamente gettato viene creato in un'area specificata di memoria riservata ad uso del meccanismo di gestione delle eccezioni:

[except.throw] 15.1/4: La memoria per l'oggetto eccezione è allocato in una non specificata modo, salvo quanto indicato al punto 3.7.4.1. L'oggetto di eccezione viene distrutto dopo che l'ultimo gestore attivo rimanente per l'eccezione è terminato con qualsiasi metodo diverso da rethrowing oppure l'ultimo oggetto di tipo std :: exception_ptr (18.8.5) che fa riferimento all'oggetto di eccezione viene distrutto, a seconda di quale è dopo.

Se una variabile locale è specificato throw, viene copiato ci-to se necessario (l'ottimizzatore può essere in grado di creare direttamente in quest'altro memoria). Ecco perché ...

15,1/5 Quando l'oggetto lanciato è un oggetto di classe, il costruttore selezionato per la copia-inizializzazione e il distruttore deve essere accessibile, anche se l'operazione di copia/spostamento viene eliso (12.8).

---

se questo non è cliccato, si forza aiuto di immaginare realizzazione vagamente simile a questo:

// implementation support variable... 
thread__local alignas(alignof(std::max_align_t)) 
    char __exception_object[EXCEPTION_OBJECT_BUFFER_SIZE]; 

void some_function() { 
    // throw std::exception("some error message"); 

    // IMPLEMENTATION PSEUDO-CODE: 
    auto&& thrown = std::exception("some error message"); 
    // copy-initialise __exception_object... 
    new (&__exception_object) decltype(thrown){ thrown }; 
    throw __type_of(thrown); 
    // as stack unwinds, _type_of value in register or another 
    // thread_local var... 
} 

int main(int argc, char **argv) 
{ 
    try { 
     some_function(); 
    } // IMPLEMENTATION: 
     // if thrown __type_of for std::exception or derived... 
     catch (const std::exception& e) { 
     // IMPLEMENTATION: 
     // e references *(std::exception*)(&__exception_object[0]); 
     ... 
    } 
} 

Answer 2

La cattura tramite riferimento const è esattamente come devono essere rilevate le eccezioni. L'oggetto eccezione non necessariamente vive "in pila". Il compilatore è responsabile della magia appropriata per farlo funzionare.

D'altra parte, il tuo esempio non può essere compilato poiché std::exception può essere solo costruito in modo predefinito o costruito su una copia. In questo caso il metodo what() restituirebbe un puntatore a una stringa vuota (stile c), che non è particolarmente utile.

Suggerisci si getta un std::runtime_error o std::logic_error a seconda dei casi, o di una classe derivata da essa:

• logic_error quando il chiamante ha richiesto qualcosa al di fuori dei parametri di progettazione del vostro servizio.
• runtime_error quando il chiamante ha richiesto qualcosa di ragionevole, ma fattori esterni impediscono di rispettare la richiesta.

http://en.cppreference.com/w/cpp/error/exception

Answer 3

È necessario per la cattura per riferimento, altrimenti non potrebbe ottenere il tipo dinamico corretta dell'oggetto. Per quanto riguarda la sua durata, le garanzie standard, in [except.throw],

L'oggetto eccezione viene distrutto sia dopo l'ultimo residuo gestore attivo per le uscite eccezione di mezzi diversi rethrowing, o l'ultimo oggetto di tipo std :: exception_ptr (18.8.5) che fa riferimento all'oggetto eccezione viene distrutto, se successiva

Answer 4

Da except.throw:

un'eccezione copy-inizializza (8.5, 12.8) un oggetto temporaneo, chiamato oggetto eccezione. Il temporaneo è un lvalue e viene utilizzato per inizializzare la variabile dichiarata nel gestore di corrispondenza (15.3). Se il tipo dell'oggetto di eccezione sarebbe un tipo incompleto o un puntatore su un tipo incompleto diverso da quello (eventualmente qualificato per il cv) void il programma è mal formato.

E 'l'atto di gettare l'eccezione che copia l'oggetto eccezione nella eccezioni-zona, al di fuori di qualsiasi stack. Quindi è perfettamente lecito e consigliabile raccogliere l'eccezione per riferimento, poiché la durata dell'oggetto eccezione si estenderà fino all'ultimo possibile catch().