Có con trỏ lười C++ không?

Question

Tôi cần một đối tượng giống như shared_ptr, nhưng nó sẽ tự động tạo một đối tượng thực khi tôi cố gắng truy cập các thành viên của nó.

Ví dụ, tôi có:

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. 

Có một số thực hiện, hay tôi nên viết của riêng tôi?

Answer 1

Đó là rất ít nỗ lực để cuộn của riêng bạn.

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

Tôi chưa bao giờ nghe nói về một điều như vậy, nhưng sau đó một lần nữa có rất nhiều điều tôi chưa bao giờ nghe nói đến. Làm thế nào để "con trỏ lười biếng" đưa dữ liệu hữu ích vào các trường hợp của lớp cơ bản?

Bạn có chắc chắn rằng sparse matrix không phải là những gì bạn thực sự đang tìm kiếm không?

Answer 3

Cho đến giờ tôi biết, hiện không có triển khai thực hiện loại điều này. Nó sẽ không khó để tạo ra một mặc dù.

Answer 4

Sử dụng boost::optional, bạn có thể có một điều như vậy:

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

sẽ xây dựng 100 của lười biếng và gán một thực some_big_stuff để v[49]. boost::optional sẽ không sử dụng bộ nhớ heap, nhưng sử dụng vị trí mới để tạo các đối tượng trong bộ đệm được phân bổ theo chồng. Tôi sẽ tạo ra một wrapper xung quanh boost::optional như thế này:

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; 
}; 

này bây giờ sử dụng boost::optional để làm chất liệu. Nó phải hỗ trợ tại chỗ xây dựng như thế này (ví dụ trên op*):

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

Trong đó sẽ không yêu cầu bất kỳ bản sao-ing. Tuy nhiên, hướng dẫn tăng cường hiện tại không bao gồm quá tải của toán tử gán đó. Tuy nhiên, mã nguồn. Tôi không chắc liệu đây có phải chỉ là một khiếm khuyết trong sách hướng dẫn hay liệu tài liệu của nó có bị bỏ sót hay không. Vì vậy, tôi sẽ sử dụng cách an toàn hơn bằng cách sử dụng phân công bản sao bằng cách sử dụng T().