Buon modello di progettazione per un wrapper c ++ attorno a un oggetto c

Se la responsabilità di ripulire le risorse allocate dinamicamente si sposta tra la classe wrapper e la libreria C in base a come le cose vengono utilizzate, si ha a che fare con una libreria C mal progettata, o si sta tentando di fare troppo nel wrapper classe.

Nel primo caso, tutto ciò che puoi fare è tenere traccia di chi è responsabile della pulizia e sperare che non vengano commessi errori (né da te né dai manutentori della libreria C).

Nel secondo caso, dovresti riconsiderare il design del tuo wrapper. Tutte le funzionalità appartengono alla stessa classe o possono essere suddivise in più classi. Forse la libreria C usa qualcosa di simile al pattern di progettazione della facciata e dovresti mantenere una struttura simile nel tuo wrapper C ++.

In ogni caso, anche se la libreria C è responsabile della pulizia di alcune cose, non c'è nulla di sbagliato nel mantenere un riferimento / puntatore a quella roba. Devi solo ricordare che non sei responsabile della pulizia di ciò a cui il puntatore fa riferimento.

Spesso puoi usare uno schema come questo:

class C {
public:
  void foo() {
    underlying_foo(handle.get());
  }

  void bar() {
    // transfers ownership
    underlying_bar(handle.release());
  }

  // use default copy/move constructor and assignment operator

private:
  struct deleter {
    void operator()(T* ptr) {
      deleter_fn(ptr);
    }
  };
  std::unique_ptr<T, deleter> handle;
};

Usando release puoi trasferire esplicitamente la proprietà. Tuttavia questo è fonte di confusione e dovresti evitarlo se possibile.

La maggior parte delle librerie C ha un ciclo di vita dell'oggetto simile al C ++ (allocazione di oggetti, accessorie, distruzione) che si adatta perfettamente al modello C ++ senza trasferimento di proprietà.

Se gli utenti hanno bisogno di proprietà condivisa, dovrebbero usare shared_ptr con le tue classi. Non provare a implementare la condivisione della proprietà da solo.

Aggiornamento: se vuoi rendere più esplicito il trasferimento di proprietà, puoi utilizzare un qualificatore di riferimento:

void bar() && { ... }

Quindi gli utenti devono chiamare bar su lvalues come questo:

C o;
std::move(o).bar();  // transfer of ownership is explicit at call site

C'è una risposta semplice al tuo problema, puntatori intelligenti. Usando un puntatore intelligente per conservare la memoria della libreria C e aggiungere un riferimento quando il puntatore si trova anche nella libreria (e rilasciare il riferimento quando ritorna la libreria C), si libera automaticamente la memoria quando il conteggio dei riferimenti scende a zero (e solo allora)

Se la libreria può liberare le cose internamente e gli scenari in cui ciò può accadere sono ben documentati, allora tutto ciò che puoi fare è impostare una bandiera come già fatto.