Sử dụng con trỏ thông minh cho các thành viên trong lớp

Tôi gặp khó khăn trong việc hiểu cách sử dụng con trỏ thông minh như các thành viên lớp trong C ++ 11. Tôi đã đọc rất nhiều về con trỏ thông minh và tôi nghĩ rằng tôi hiểu cách thức unique_ptrvà shared_ptr/ weak_ptrcông việc nói chung. Những gì tôi không hiểu là sử dụng thực sự. Có vẻ như tất cả mọi người khuyên bạn nên sử dụng unique_ptrnhư là cách để đi gần như mọi lúc. Nhưng làm thế nào tôi có thể thực hiện một cái gì đó như thế này:

class Device {
};

class Settings {
    Device *device;
public:
    Settings(Device *device) {
        this->device = device;
    }

    Device *getDevice() {
        return device;
    }
};    

int main() {
    Device *device = new Device();
    Settings settings(device);
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

Hãy nói rằng tôi muốn thay thế con trỏ bằng con trỏ thông minh. A unique_ptrsẽ không hoạt động vì getDevice(), phải không? Vì vậy, đó là thời gian khi tôi sử dụng shared_ptrvà weak_ptr? Không có cách sử dụng unique_ptr? Có vẻ như đối với tôi, hầu hết các trường hợp shared_ptrcó ý nghĩa hơn trừ khi tôi sử dụng một con trỏ trong phạm vi thực sự nhỏ?

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> device) {
        this->device = device;
    }

    std::weak_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::weak_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

đó là phải đường để đi không? Cảm ơn rất nhiều!

A unique_ptrsẽ không hoạt động vì getDevice(), phải không?

Không, không nhất thiết. Điều quan trọng ở đây là xác định chính sách sở hữu phù hợp cho Deviceđối tượng của bạn , tức là ai sẽ là chủ sở hữu của đối tượng được trỏ bởi con trỏ (thông minh) của bạn.

Nó sẽ là ví dụ của Settingsđối tượng một mình ? Sẽ Deviceđối tượng phải bị phá hủy tự động khi Settingsđối tượng bị phá hủy, hoặc nó sẽ sống lâu hơn đối tượng đó?

Trong trường hợp đầu tiên, std::unique_ptrlà những gì bạn cần, vì nó làmSettings chủ sở hữu duy nhất (duy nhất) của đối tượng nhọn và là đối tượng duy nhất chịu trách nhiệm cho sự phá hủy của nó.

Theo giả định này, getDevice()nên trả về một con trỏ quan sát đơn giản (quan sát các con trỏ là các con trỏ không giữ cho vật nhọn) tồn tại. Loại con trỏ quan sát đơn giản nhất là con trỏ thô:

#include <memory>

class Device {
};

class Settings {
    std::unique_ptr<Device> device;
public:
    Settings(std::unique_ptr<Device> d) {
        device = std::move(d);
    }

    Device* getDevice() {
        return device.get();
    }
};

int main() {
    std::unique_ptr<Device> device(new Device());
    Settings settings(std::move(device));
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

[ LƯU Ý 1: Bạn có thể tự hỏi tại sao tôi sử dụng con trỏ thô ở đây, khi mọi người cứ nói rằng con trỏ thô là xấu, không an toàn và nguy hiểm. Trên thực tế, đó là một cảnh báo quý giá, nhưng điều quan trọng là phải đặt nó trong ngữ cảnh chính xác: con trỏ thô rất tệ khi được sử dụng để thực hiện quản lý bộ nhớ thủ công , tức là phân bổ và phân bổ các đối tượng thông qua newvà delete. Khi được sử dụng hoàn toàn như một phương tiện để đạt được ngữ nghĩa tham chiếu và vượt qua các con trỏ không sở hữu, quan sát, về bản chất không có gì nguy hiểm trong các con trỏ thô, ngoại trừ có thể thực tế là người ta không nên coi thường con trỏ lơ lửng. - KẾT THÚC 1 ]

[ CHÚ THÍCH 2: Như đã xuất hiện trong các nhận xét, trong trường hợp cụ thể này, quyền sở hữu là duy nhất và đối tượng sở hữu luôn được đảm bảo có mặt (tức là thành viên dữ liệu nội bộ devicesẽ không bao giờ tồn tại nullptr), chức năng getDevice()có thể (và có thể nên) trả về một tham chiếu chứ không phải là một con trỏ Trong khi điều này là đúng, tôi đã quyết định trả về một con trỏ thô ở đây bởi vì tôi muốn nói đây là một câu trả lời ngắn gọn mà người ta có thể khái quát cho trường hợp devicecó thể nullptr, và cho thấy rằng các con trỏ thô vẫn ổn miễn là người ta không sử dụng chúng cho quản lý bộ nhớ thủ công. - KẾT THÚC 2 ]

Tất nhiên, tình huống hoàn toàn khác, nếu Settingsđối tượng của bạn không có quyền sở hữu độc quyền của thiết bị. Đây có thể là trường hợp, ví dụ, nếu sự phá hủy của Settingsđối tượng không nên ngụ ý sự phá hủy của Devicevật nhọn .

Đây là điều mà chỉ bạn là người thiết kế chương trình của bạn có thể nói; từ ví dụ bạn cung cấp, thật khó để tôi biết liệu đây có phải là trường hợp hay không.

Để giúp bạn tìm ra nó, bạn có thể tự hỏi liệu có bất kỳ đối tượng nào khác ngoài Settingsviệc có quyền giữ cho Deviceđối tượng tồn tại miễn là họ giữ một con trỏ đến nó, thay vì chỉ là những người quan sát thụ động. Nếu đó thực sự là trường hợp, thì bạn cần một chính sách sở hữu chung , đó là những gì std::shared_ptrcung cấp:

#include <memory>

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> const& d) {
        device = d;
    }

    std::shared_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device = std::make_shared<Device>();
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

Lưu ý, đó weak_ptrlà một con trỏ quan sát , không phải là một con trỏ sở hữu - nói cách khác, nó không giữ cho đối tượng nhọn tồn tại nếu tất cả các con trỏ sở hữu khác đến đối tượng nhọn đi ra khỏi phạm vi.

Ưu điểm của weak_ptrmột con trỏ thô thông thường là bạn có thể biết được liệu weak_ptrcó lơ lửng hay không (nghĩa là nó đang trỏ đến một đối tượng hợp lệ hay nếu đối tượng ban đầu được chỉ ra đã bị phá hủy). Điều này có thể được thực hiện bằng cách gọi expired()hàm thành viên trênweak_ptr đối tượng.

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(const std::shared_ptr<Device>& device) : device(device) {

    }

    const std::shared_ptr<Device>& getDevice() {
        return device;
    }
};

int main()
{
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice(settings.getDevice());
    // do something with myDevice...
    return 0;
}

week_ptrchỉ được sử dụng cho các vòng tham chiếu. Biểu đồ phụ thuộc phải là đồ thị acyclicdirected. Trong các con trỏ chia sẻ có 2 số tham chiếu: 1 cho shared_ptrs và 1 cho tất cả các con trỏ ( shared_ptrvà weak_ptr). Khi tất cả shared_ptrs được loại bỏ, con trỏ sẽ bị xóa. Khi con trỏ là cần thiết weak_ptr, locknên được sử dụng để có được con trỏ, nếu nó tồn tại.