È un aliasing vuoto shared_ptr una buona alternativa a un no-op che elimina shared_ptr?

Question

A volte ho bisogno delle istanze shared_ptr che hanno un deleter no-op, perché un'API si aspetta un'istanza shared_ptr che desidera archiviare per un tempo limitato, ma mi viene fornito un puntatore raw che non sono autorizzato a possedere per un tempo maggiore di per cosa sto correndo.

Per questo caso, ho utilizzato un deleter no-op, come ad esempio [](const void *){}, ma oggi ho scoperto che c'è un'altra alternativa a quella, usando (o abusando?) Il aliasing constructor di shared_ptr:

void f(ExpectedClass *ec) { 
    std::shared_ptr<ExpectedClass> p(std::shared_ptr<void>(), ec); 
    assert(p.use_count() == 0 && p.get() != nullptr); 
    apiCall(p); 
} 

La mia domanda è, qual è il modo migliore per farlo e perché? Le aspettative di rendimento sono le stesse? Con un deleter no-op mi aspetto di pagare un costo per la memorizzazione del deleter e del conteggio dei riferimenti, che non sembra essere il caso quando si utilizza il costruttore aliasing con lo shared_ptr vuoto.

Answer 1

quanto riguarda le prestazioni, il seguente parametro di riferimento mostra figure irregolari:

#include <chrono> 
#include <iostream> 
#include <limits> 
#include <memory> 

template <typename... Args> 
auto test(Args&&... args) { 
    using clock = std::chrono::high_resolution_clock; 
    auto best = clock::duration::max(); 

    for (int outer = 1; outer < 10000; ++outer) { 
     auto now = clock::now(); 

     for (int inner = 1; inner < 20000; ++inner) 
      std::shared_ptr<int> sh(std::forward<Args>(args)...); 

     auto time = clock::now()-now; 
     if (time < best) { 
      best = time; 
      outer = 1; 
     } 
    } 

    return best.count(); 
} 

int main() 
{ 
    int j; 

    std::cout << "With aliasing ctor: " << test(std::shared_ptr<void>(), &j) << '\n' 
       << "With empty deleter: " << test(&j, [] (auto) {}); 
} 

uscita sulla mia macchina con clang++ -march=native -O2:

With aliasing ctor: 11812 
With empty deleter: 651502 

GCC con opzioni identiche dà un rapporto ancora più grande, 5921: 465.794.
E Clang con -stdlib=libc++ produce un enorme 12: 613175.