Gibt es C++ faulen Zeiger?

Question

Ich brauche ein shared_ptr ähnliches Objekt, das aber automatisch ein reales Objekt erzeugt, wenn ich versuche, auf seine Mitglieder zuzugreifen.

Zum Beispiel habe ich:

class Box 
{ 
public: 
    unsigned int width; 
    unsigned int height; 
    Box(): width(50), height(100){} 
}; 

std::vector< lazy<Box> > boxes; 
boxes.resize(100); 

// at this point boxes contain no any real Box object. 
// But when I try to access box number 50, for example, 
// it will be created. 

std::cout << boxes[49].width; 

// now vector contains one real box and 99 lazy boxes. 

Gibt es eine Implementierung oder sollte ich meine eigene schreiben?

Answer 1

Es ist sehr wenig Mühe, Ihre eigenen zu rollen.

template<typename T> 
class lazy { 
public: 
    lazy() : child(0) {} 
    ~lazy() { delete child; } 
    T &operator*() { 
     if (!child) child = new T; 
     return *child; 
    } 
    // might dereference NULL pointer if unset... 
    // but if this is const, what else can be done? 
    const T &operator*() const { return *child; } 
    T *operator->() { return &**this; } 
    const T *operator->() const { return &**this; } 
private: 
    T *child; 
}; 

// ... 

cout << boxes[49]->width; 

Answer 2

Ich habe noch nie von so etwas gehört, aber dann wieder gibt es viele Dinge, von denen ich noch nie gehört habe. Wie würde der "faule Pointer" nützliche Daten in die Instanzen der zugrunde liegenden Klasse schreiben?

Sind Sie sicher, dass ein sparse matrix nicht das ist, was Sie wirklich suchen?

Answer 3

Soweit ich weiß, gibt es keine bestehende Implementierung dieser Art von Sache. Es wäre nicht schwer, eins zu erstellen.

Answer 4

boost::optional verwenden, können Sie so etwas haben:

// 100 lazy BigStuffs 
std::vector< boost::optional<BigStuff> > v(100); 
v[49] = some_big_stuff; 

100 faul des Konstrukts und eine echte some_big_stuff zu v[49] zuweisen. boost::optional wird keinen Heap-Speicher verwenden, aber placement-new verwenden, um Objekte in einem Stapelspeicherpuffer zu erstellen. Ich würde einen Wrapper um boost::optional wie folgt erstellen:

template<typename T> 
struct LazyPtr { 
    T& operator*() { if(!opt) opt = T(); return *opt; } 
    T const& operator*() const { return *opt; } 

    T* operator->() { if(!opt) opt = T(); return &*opt; } 
    T const* operator->() const { return &*opt; }  
private: 
    boost::optional<T> opt; 
}; 

Die jetzt boost::optional dafür stopft verwendet. Es sollte an Ort und Stelle Konstruktion wie dieses (Beispiel auf op*) unterstützen:

T& operator*() { if(!opt) opt = boost::in_place(); return *opt; } 

Welche nicht erfordern würde jedes Kopie-ing. Das aktuelle boost-Handbuch enthält jedoch nicht die Überlast des Zuweisungsoperators. Die Quelle tut dies jedoch. Ich bin mir nicht sicher, ob das nur ein Defekt im Handbuch ist oder ob seine Dokumentation absichtlich weggelassen wird. Also würde ich den sichereren Weg mit einer Kopierzuweisung unter Verwendung T() verwenden.