C++ std :: unique_ptr: Warum gibt es bei lambdas keine Größengebühren?

Question

Ich lese "Effective Modern C++". In dem Artikel, der sich auf std::unique_ptr bezieht, heißt es, dass, wenn der benutzerdefinierte Löscher ein zustandsloses Objekt ist, keine Größengebühren anfallen, aber wenn es sich um einen Funktionszeiger oder um eine std::function Gebühr handelt. Können Sie erklären warum?

Lassen Sie uns sagen, dass wir den folgenden Code haben:

auto deleter_ = [](int *p) { doSth(p); delete p; }; 
std::unique_ptr<int, decltype(deleter_)> up(new int, deleter_); 

Zu meinem Verständnis, das unique_ptr ein Objekt vom Typ sollte decltype(deleter_) und weisen deleter_ zu diesem internen Objekt. Aber offensichtlich passiert das nicht. Können Sie den Mechanismus dafür anhand eines möglichst kleinen Codebeispiels erklären?

Answer 1

Wenn der Deleter staatenlos ist, ist kein Speicherplatz zum Speichern erforderlich. Wenn der Deleter nicht zustandslos ist, muss der Zustand im unique_ptr selbst gespeichert werden.
std::function und Funktionszeiger haben Informationen, die nur zur Laufzeit verfügbar sind und daher im Objekt neben dem Zeiger das Objekt selbst gespeichert werden müssen. Dies wiederum erfordert das Zuordnen (in dem unique_ptr selbst) Speicherplatz, um diesen zusätzlichen Status zu speichern.

Vielleicht verstehen Sie die Empty Base Optimization wird Ihnen helfen zu verstehen, wie dies in der Praxis umgesetzt werden könnte.
Das Merkmal std::is_empty ist eine andere Möglichkeit, wie dies implementiert werden könnte.

Wie genau Bibliotheksautoren das implementieren, liegt natürlich bei ihnen und was der Standard erlaubt.

Answer 2

Aus unique_ptr Implementierung:

template<class _ElementT, class _DeleterT = std::default_delete<_ElementT>> 
class unique_ptr 
{ 
public: 
    // public interface... 

private: 

    // using empty base class optimization to save space 
    // making unique_ptr with default_delete the same size as pointer 

    class _UniquePtrImpl : private deleter_type 
    { 
    public: 
    constexpr _UniquePtrImpl() noexcept = default; 

    // some other constructors... 

    deleter_type& _Deleter() noexcept 
    { return *this; } 

    const deleter_type& _Deleter() const noexcept 
    { return *this; } 

    pointer& _Ptr() noexcept 
    { return _MyPtr; } 

    const pointer _Ptr() const noexcept 
    { return _MyPtr; } 

    private: 
    pointer _MyPtr; 

    }; 

    _UniquePtrImpl _MyImpl; 

}; 

Die _UniquePtrImpl Klasse enthält den Zeiger und leitet sich von dem deleter_type.

Wenn der Deleter statuslos ist, kann die Basisklasse optimiert werden, so dass sie keine Bytes für sich selbst benötigt. Dann kann die ganze unique_ptr die gleiche Größe wie der enthaltene Zeiger haben - das heißt: die gleiche Größe wie ein gewöhnlicher Zeiger.

Answer 3

Ein unique_ptr muss immer seinen Deleter speichern. Wenn es sich bei dem Deleter um einen Klassentyp ohne Status handelt, kann unique_ptrempty base optimization verwenden, sodass der Deleter keinen zusätzlichen Speicherplatz verwendet.

Wie genau dies geschieht, unterscheidet sich zwischen Implementierungen. Zum Beispiel speichern sowohl libc++ als auch MSVC den verwalteten Zeiger und den Deleter in einer compressed pair, wodurch Sie automatisch eine leere Basisoptimierung erhalten, wenn einer der beteiligten Typen eine leere Klasse ist.

Von dem libC++ Link oben

template <class _Tp, class _Dp = default_delete<_Tp> > 
class _LIBCPP_TYPE_VIS_ONLY unique_ptr 
{ 
public: 
    typedef _Tp element_type; 
    typedef _Dp deleter_type; 
    typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 
private: 
    __compressed_pair<pointer, deleter_type> __ptr_; 

libstdC++ stores the two in einem std::tuple und einig Google-Suche schlägt ihre tuple Implementierung Optimierung leer Basis beschäftigt, aber ich kann keine Dokumentation nicht finden, so ausdrücklich erklärt.

In jedem Fall zeigt this example, dass sowohl libC++ als auch libstdC++ EBO verwenden, um die Größe eines unique_ptr mit einem leeren Deleter zu reduzieren.

Answer 4

Tatsächlich wird eine Größenstrafe für Lambdas sein, die nicht zustandslos sind, d. H. Lambdas, die einen oder mehrere Werte erfassen.

Aber für Nicht-Erfassung lambdas gibt es zwei wichtige Fakten zu bemerken:

• Der Typ des einzigartigen und bekannt für den Compiler nur Lambda.
• Nicht einfangende Lambdas sind zustandslos.

Daher ist der Compiler in der Lage des Lambda rein auf seiner Typ Basis aufzurufen, die als Teil von der Art des unique_ptr aufgezeichnet wird; kein extra Laufzeit Informationen sind erforderlich.

Dies ist in der Tat, warum nicht einfangende Lambdas zustandslos sind. In Bezug auf die Frage der Größenbeschränkung gibt es natürlich nichts Besonderes an nicht-erfassenden Lambdas im Vergleich zu irgendeinem anderen statuslosen Lösch-Funktortyp.

Beachten Sie, dass std::function ist nicht staatenlos, weshalb die gleiche Argumentation tut nicht für sie gelten.

Schließlich müssen statusfreie Objekte in der Regel eine Größe ungleich Null aufweisen, um sicherzustellen, dass sie eindeutige Adressen haben. Stateless-Basisklassen sind nicht erforderlich, um die Gesamtgröße des abgeleiteten Typs hinzuzufügen; Dies wird als leere Basisoptimierung bezeichnet. So kann unique_ptr (wie in der Antwort von Bo Perrson) als ein Typ implementiert werden, der vom Deletertyp abgeleitet ist, der, wenn er zustandslos ist, keine Größenstrafe mit sich bringt. (Dies kann in der Tat die nur Weg unique_ptr ohne eine Größenstrafe für statuslose Deleters zu implementieren, aber ich bin mir nicht sicher.)