Perché non esiste un costrutto "finalmente" in C ++?

La gestione delle eccezioni in C ++ è limitata a provare / lanciare / catturare. A differenza di Object Pascal, Java, C # e Python, anche in C ++ 11, il finallycostrutto non è stato implementato.

Ho visto un sacco di letteratura C ++ che parlava di "codice sicuro di eccezione". Lippman scrive che il codice sicuro di eccezione è un argomento importante ma avanzato e difficile, al di là dell'ambito del suo Primer, il che sembra implicare che il codice sicuro non sia fondamentale per C ++. Herb Sutter dedica 10 capitoli all'argomento nel suo eccezionale C ++!

Tuttavia, mi sembra che molti dei problemi riscontrati durante il tentativo di scrivere "codice sicuro di eccezione" potrebbero essere risolti abbastanza bene se il finallycostrutto fosse implementato, consentendo al programmatore di garantire che anche in caso di eccezione, il programma potesse essere ripristinato a uno stato sicuro, stabile, privo di perdite, vicino al punto di allocazione delle risorse e al codice potenzialmente problematico. Come programmatore Delphi e C # molto esperto, uso try .. finalmente si blocca abbastanza ampiamente nel mio codice, così come la maggior parte dei programmatori in queste lingue.

Considerando tutte le "campane e fischietti" implementate in C ++ 11, sono rimasto sorpreso di scoprire che "finalmente" non c'era ancora.

Quindi, perché il finallycostrutto non è mai stato implementato in C ++? Non è davvero un concetto molto difficile o avanzato da comprendere e aiuta molto il programmatore a scrivere "codice sicuro eccezioni".

Come alcuni commenti aggiuntivi sulla risposta di @ Nemanja (che, dal momento che cita Stroustrup, è davvero una risposta tanto buona quanto puoi ottenere):

È davvero solo una questione di comprensione della filosofia e dei modi di dire del C ++. Prendi l'esempio di un'operazione che apre una connessione al database su una classe persistente e deve assicurarsi che chiuda tale connessione se viene generata un'eccezione. Questa è una questione di sicurezza delle eccezioni e si applica a qualsiasi linguaggio con eccezioni (C ++, C #, Delphi ...).

In una lingua che utilizza try/ finally, il codice potrebbe assomigliare a questo:

database.Open();
try {
    database.DoRiskyOperation();
} finally {
    database.Close();
}

Semplice e diretto Vi sono, tuttavia, alcuni svantaggi:

• Se la lingua non ha distruttori deterministici, devo sempre scrivere il finallyblocco, altrimenti perdo risorse.
• Se DoRiskyOperationè più di una singola chiamata di metodo - se ho qualche elaborazione da fare nel tryblocco - l' Closeoperazione può finire per essere un po 'decente Opendall'operazione. Non riesco a scrivere la pulizia proprio accanto alla mia acquisizione.
• Se ho diverse risorse che devono essere acquisite e poi liberate in modo sicuro dalle eccezioni, posso finire con diversi strati profondi di try/ finallyblocchi.

L'approccio C ++ sarebbe simile al seguente:

ScopedDatabaseConnection scoped_connection(database);
database.DoRiskyOperation();

Questo risolve completamente tutti gli svantaggi finallydell'approccio. Ha un paio di svantaggi, ma sono relativamente minori:

• Ci sono buone probabilità che tu abbia bisogno di scrivere ScopedDatabaseConnectiontu stesso la lezione. Tuttavia, è un'implementazione molto semplice: solo 4 o 5 righe di codice.
• Implica la creazione di una variabile locale aggiuntiva - di cui apparentemente non sei un fan, in base al tuo commento su "creare e distruggere costantemente le classi per fare affidamento sui loro distruttori per ripulire il tuo casino è molto scarso" - ma un buon compilatore ottimizzerà fuori dal lavoro extra che comporta una variabile locale extra. Un buon design C ++ si basa molto su questo tipo di ottimizzazioni.

Personalmente, considerando questi vantaggi e svantaggi, trovo che RAII sia una tecnica molto preferibile finally. Il tuo chilometraggio può variare.

Infine, poiché RAII è un linguaggio così consolidato in C ++ e per alleviare gli sviluppatori di alcuni degli oneri di scrivere numerose Scoped...classi, ci sono librerie come ScopeGuard e Boost.ScopeExit che facilitano questo tipo di pulizia deterministica.

Da Perché il C ++ non fornisce un costrutto "finalmente"? nelle FAQ su stile e tecnica C ++ di Bjarne Stroustrup :

Perché C ++ supporta un'alternativa che è quasi sempre migliore: la tecnica "acquisizione delle risorse è inizializzazione" (TC ++ PL3 sezione 14.4). L'idea di base è quella di rappresentare una risorsa da un oggetto locale, in modo che il distruttore dell'oggetto locale rilasci la risorsa. In questo modo, il programmatore non può dimenticare di rilasciare la risorsa.

Il motivo che C ++ non ha finallyè perché non è necessario in C ++. finallyviene utilizzato per eseguire del codice indipendentemente dal fatto che si sia verificata o meno un'eccezione, che è quasi sempre una sorta di codice di pulizia. In C ++, questo codice di pulizia dovrebbe trovarsi nel distruttore della classe pertinente e il distruttore verrà sempre chiamato, proprio come un finallyblocco. Il linguaggio dell'uso del distruttore per la tua pulizia si chiama RAII .

All'interno della comunità C ++ si potrebbe parlare più del codice "eccezioni sicure", ma è quasi altrettanto importante in altre lingue che hanno eccezioni. L'intero punto del codice "eccezioni sicure" è che pensi a quale stato viene lasciato il tuo codice se si verifica un'eccezione in una qualsiasi delle funzioni / metodi che chiami.
In C ++, il codice "eccezioni sicure" è leggermente più importante, poiché C ++ non ha garbage collection automatica che si occupa degli oggetti lasciati orfani a causa di un'eccezione.

Il motivo per cui la sicurezza delle eccezioni viene discussa di più nella comunità C ++ probabilmente deriva anche dal fatto che in C ++ devi essere più consapevole di ciò che può andare storto, perché ci sono meno reti di sicurezza predefinite nella lingua.

Altri hanno discusso di RAII come soluzione. È una soluzione perfettamente valida. Ma questo non affronta davvero il motivo per cui non hanno aggiunto finallyaltrettanto poiché è una cosa ampiamente desiderata. La risposta a questo è più fondamentale per la progettazione e lo sviluppo del C ++: durante lo sviluppo del C ++, le persone coinvolte hanno resistito fortemente all'introduzione di funzionalità di progettazione che possono essere raggiunte usando altre funzionalità senza un grande sforzo e soprattutto dove ciò richiede l'introduzione di nuove parole chiave che potrebbero rendere incompatibile il codice precedente. Dal momento che RAII offre un'alternativa altamente funzionale a finallye puoi effettivamente creare il tuo finallyin C ++ 11, ci sono state poche richieste.

Tutto quello che devi fare è creare una classe Finallyche chiama la funzione passata al suo costruttore nel suo distruttore. Quindi puoi farlo:

try
{
    Finally atEnd([&] () { database.close(); });

    database.doRisky();
}

La maggior parte dei programmatori C ++ nativi preferirà, in generale, oggetti RAII dal design pulito.

È possibile utilizzare un modello "trap", anche se non si desidera utilizzare il blocco try / catch.

Inserire un oggetto semplice nell'ambito richiesto. Nel distruttore di questo oggetto metti la tua logica "definitiva". Indipendentemente da ciò, quando la pila viene srotolata, verrà chiamato il distruttore dell'oggetto e otterrai le tue caramelle.

Bene, potresti finallyusare il roll-your-own , usando Lambdas, che farebbe compilare bene quanto segue (usando ovviamente un esempio senza RAII, non il codice più carino):

{
    FILE *file = fopen("test","w");

    finally close_the_file([&]{
        cout << "We're closing the file in a pseudo-finally clause." << endl;
        fclose(file);
    });
}

Vedere questo articolo .

Non sono sicuro di essere d'accordo con le affermazioni qui che RAII è un superset di finally. Il tallone d'Achille di RAII è semplice: eccezioni. RAII è implementato con i distruttori, ed è sempre sbagliato in C ++ eliminare un distruttore. Ciò significa che non è possibile utilizzare RAII quando è necessario lanciare il codice di pulizia. Se finallyfossero stati implementati, d'altra parte, non c'è motivo di credere che non sarebbe legale lanciare da un finallyblocco.

Considera un percorso di codice come questo:

void foo() {
    try {
        ... stuff ...
        complex_cleanup();
    } catch (A& a) {
        handle_a(a);
        complex_cleanup();
        throw;
    } catch (B& b) {
        handle_b(b);
        complex_cleanup();
        throw;
    } catch (...) {
        handle_generic();
        complex_cleanup();
        throw;
    }
}

Se avessimo finallypotuto scrivere:

void foo() {
    try {
        ... stuff ...
    } catch (A& a) {
        handle_a(a);
        throw;
    } catch (B& b) {
        handle_b(b);
        throw;
    } catch (...) {
        handle_generic();
        throw;
    } finally {
        complex_cleanup();
    }
}

Ma non riesco a trovare il modo di ottenere un comportamento equivalente usando RAII.

Se qualcuno sa come farlo in C ++, sono molto interessato alla risposta. Sarei anche felice di qualcosa su cui fare affidamento, ad esempio, imponendo che tutte le eccezioni ereditate da una singola classe con alcune capacità speciali o qualcosa del genere.