È possibile eseguire RAII senza eccezioni?

Question

Se la risorsa che si richiede di acquisire nella costruzione di un oggetto può fallire, è possibile eseguire RAII, se le eccezioni sono proibite da uno standard di codifica locale?

In tal caso, qual è il modo canonico per gestire il fallimento dell'acquisizione delle risorse in questo caso?

Answer 1

non volevo andare con l'approccio oggetto non valido in generale, perché vorrei considerare questo come cattivo design. Dopo la costruzione, l'oggetto deve trovarsi in uno stato in cui sono stabiliti gli invarianti (che è l'unico scopo che un costruttore deve servire). Considerare una classe strange_vector che implementa qualcosa come std::vector, ma dopo aver chiamato strange_vector<int>(10, 0), l'oggetto si troverebbe in uno stato inutilizzabile perché l'allocazione non è riuscita.

Invece vorrei dichiarare costruttori privati ​​e utilizzare un metodo factory che restituisce un optional:

class file 
{ 
public: 
    ~file() {fclose(m_file);} 

    static std::optional<file> open(std::string const& filename) 
    { 
     auto f = fopen(filename.c_str(), "r"); 
     if (f) 
     { 
      return std::make_optional<file>(f); 
     } 
     else 
     { 
      return std::nullopt; 
     } 
    } 

private: 
    file(FILE* file); 
    FILE* m_file; 
}; 

Uno dei maggiori vantaggi di gestione delle eccezioni è (oltre disaccoppiamento gestione degli errori e normale percorso di codice) che non si può ignorali accidentalmente. Se lo si desidera, è possibile creare una classe personalizzata simile a optional che, quando non è inizializzata con un oggetto valido, registra un messaggio di errore e termina il programma (o qualsiasi altra ragionevole gestione degli errori). Penso che ci sia un talk from A. Alexandrescu about systematic error handling dove implementa una classe Expected<T> che contiene un valore di tipo T o un'eccezione. Puoi usare questa base e invece di aggiungere il tuo errore di gestione lì.

std::optional non fa ancora parte dello standard, ma è possibile ottenere facilmente implementazioni come parte di compilatori recenti, in boost o in altre librerie.

Answer 2

È sempre possibile creare un metodo bool valid(void). Il costruttore può quindi impostare la condizione appropriata e nel codice, è possibile verificare dopo la costruzione se questo ha funzionato o meno.

class foo 
{ 
public: 
    foo(const char *Filename) 
    { 
     mValid = false; 

     if(fopen(Filename) == NULL) 
      return; 

     mValid = true; 
    } 

    bool valid(void) { return mValid; } 

    private: 
     bool mValid; 
}; 

void myfunc(void) 
{ 
    foo fl("myfile"); 
    if(!fl.valid()) 
    { 
     printf("Error\n"); 
     return; 
    } 
}