Theo dõi các đối tượng (xếp chồng được phân bổ)

Question

Trong một ứng dụng khá lớn, tôi muốn theo dõi một số số liệu thống kê về các đối tượng của một lớp nhất định. Để không làm giảm hiệu suất, tôi muốn các số liệu thống kê được cập nhật trong một cấu hình kéo. Do đó, tôi cần phải có một tham chiếu đến từng đối tượng sống ở một số vị trí. Có một ngữ cách để:

1. Tạo, tìm kiếm, lặp tài liệu tham khảo như
2. Manage nó tự động (tức là loại bỏ các tài liệu tham khảo khi tiêu hủy)

Tôi đang nghĩ về một bộ của con trỏ thông minh ở đây, nhưng việc quản lý bộ nhớ sẽ bị đảo ngược một chút: Thay vì phá hủy đối tượng khi con trỏ thông minh bị phá hủy, tôi muốn con trỏ thông minh bị xóa, khi đối tượng bị hủy. Lý tưởng nhất, tôi không muốn phát minh lại bánh xe.

Tôi có thể sống với một sự chậm trễ trong việc loại bỏ các con trỏ, tôi chỉ cần một cách để làm mất hiệu lực chúng một cách nhanh chóng.

chỉnh sửa: Vì lúa yêu cầu: Lý do thu thập dựa trên kéo là lấy thông tin có thể tương đối tốn kém. Đẩy rõ ràng là một giải pháp sạch nhưng được coi là quá đắt.

Answer 1

Không có tính năng đặc biệt của ngôn ngữ cho phép bạn thực hiện việc này. Đôi khi việc theo dõi đối tượng được xử lý bằng cách lăn bộ cấp phát bộ nhớ của riêng bạn, nhưng điều này không hoạt động dễ dàng trên ngăn xếp.

Nhưng nếu bạn đang sử dụng chỉ ngăn xếp, nó thực sự làm cho vấn đề của bạn dễ dàng hơn, giả sử rằng các đối tượng đang được theo dõi là trên một sợi đơn. C++ tạo ra sự bảo đảm đặc biệt về thứ tự xây dựng và phá hủy trên stack. Đó là, thứ tự hủy diệt chính xác là ngược lại trật tự xây dựng.

Và vì vậy, bạn có thể tận dụng điều này để lưu trữ một con trỏ trong mỗi đối tượng, cộng với một con trỏ tĩnh để theo dõi con trỏ gần nhất. Bây giờ bạn có một đối tượng ngăn xếp đại diện như một danh sách liên kết.

template <typename T> 
class Trackable 
{ 
public: 
    Trackable() 
    : previous(current()) 
    { 
     current() = this; 
    } 

    ~Trackable() 
    { 
     current() = previous; 
    } 

    // External interface 
    static const T *head() const { return dynamic_cast<const T*>(current()); } 
    const T *next() const { return dynamic_cast<const T*>(previous); } 

private: 
    static Trackable * & current() 
    { 
     static Trackable *ptr = nullptr; 
     return ptr; 
    } 

    Trackable *previous; 
} 

Ví dụ:

struct Foo : Trackable<Foo> {}; 
struct Bar : Trackable<Bar> {}; 

// ::: 

// Walk linked list of Foo objects currently on stack. 
for(Foo *foo = Foo::head(); foo; foo = foo->next()) 
{ 
    // Do kung foo 
} 

Bây giờ, phải thừa nhận đây là một giải pháp rất đơn giản. Trong một ứng dụng lớn, bạn có thể có nhiều ngăn xếp bằng cách sử dụng các đối tượng của bạn. Bạn có thể xử lý các ngăn xếp trên nhiều luồng bằng cách thực hiện current() sử dụng ngữ nghĩa thread_local. Mặc dù bạn cần một số phép thuật để thực hiện công việc này, vì head() sẽ cần phải trỏ vào sổ đăng ký các chủ đề và điều đó sẽ yêu cầu đồng bộ hóa.

Bạn chắc chắn không muốn đồng bộ hóa tất cả các ngăn xếp thành một danh sách duy nhất, vì điều đó sẽ giết khả năng mở rộng hiệu suất của chương trình của bạn.

Đối với yêu cầu kéo của bạn, tôi cho rằng đó là một chuỗi riêng biệt muốn đi qua danh sách. Bạn sẽ cần một cách để đồng bộ hóa như vậy mà tất cả các đối tượng xây dựng mới hoặc phá hủy bị chặn bên trong Trackable<T> trong khi danh sách đang được lặp lại. Hoặc tương tự.

Nhưng ít nhất bạn có thể lấy ý tưởng cơ bản này và mở rộng nó theo nhu cầu của bạn.

Hãy nhớ rằng, bạn không thể sử dụng cách tiếp cận danh sách đơn giản này nếu bạn phân bổ động các đối tượng của mình. Cho rằng bạn sẽ cần một danh sách hai chiều.

Answer 2

Cách tiếp cận đơn giản nhất là phải có mã bên trong từng đối tượng để nó tự đăng ký ngay lập tức và tự xóa khi hủy. Mã này có thể dễ dàng được tiêm sử dụng một CRTP:

template <class T> 
struct AutoRef { 

    static auto &all() { 
     static std::set<T*> theSet; 
     return theSet; 
    } 

private: 
    friend T; 

    AutoRef() { all().insert(static_cast<T*>(this)); } 
    ~AutoRef() { all().erase(static_cast<T*>(this)); } 
}; 

Bây giờ một lớp Foo có thể kế thừa từ AutoRef<Foo> có trường hợp nó tham chiếu bên trong AutoRef<Foo>::all().

See it live on Coliru