การใช้สมาร์ทพอยน์เตอร์สำหรับสมาชิกชั้นเรียน

ฉันมีปัญหาในการทำความเข้าใจการใช้งานตัวชี้อัจฉริยะในฐานะสมาชิกคลาสใน C ++ 11 ฉันได้อ่านพอยน์เตอร์ที่ชาญฉลาดมากและฉันคิดว่าฉันเข้าใจวิธีการunique_ptrและshared_ptr/ หรือweak_ptrทำงานโดยทั่วไป สิ่งที่ฉันไม่เข้าใจคือการใช้งานจริง ดูเหมือนว่าทุกคนแนะนำให้ใช้unique_ptrเป็นวิธีที่จะไปเกือบตลอดเวลา แต่ฉันจะใช้บางสิ่งเช่นนี้ได้อย่างไร:

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

สมมติว่าฉันต้องการแทนที่พอยน์เตอร์ด้วยพอยน์เตอร์อัจฉริยะ unique_ptrจะไม่ทำงานเพราะgetDevice()ใช่มั้ย? ดังนั้นเวลาที่ฉันใช้shared_ptrและweak_ptr? ไม่มีวิธีใช้unique_ptr? ดูเหมือนว่าฉันจะชอบในกรณีส่วนใหญ่shared_ptrเหมาะสมกว่าถ้าฉันใช้ตัวชี้ในขอบเขตที่เล็กจริงๆ?

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

นั่นเป็นวิธีที่จะไปไหม? ขอบคุณมาก ๆ!

unique_ptrจะไม่ทำงานเพราะgetDevice()ใช่มั้ย?

ไม่ไม่จำเป็น สิ่งสำคัญที่นี่คือการกำหนดนโยบายความเป็นเจ้าของที่เหมาะสมสำหรับDeviceวัตถุของคุณคือใครจะเป็นเจ้าของวัตถุที่ชี้โดยตัวชี้ (สมาร์ท) ของคุณ

มันจะเป็นตัวอย่างของSettingsวัตถุเพียงอย่างเดียวหรือไม่? จะDeviceวัตถุต้องถูกทำลายโดยอัตโนมัติเมื่อSettingsวัตถุได้รับการทำลายหรือมันควรจะอายุยืนวัตถุที่?

ในกรณีแรกstd::unique_ptrคือสิ่งที่คุณต้องการเพราะมันทำให้Settingsเจ้าของวัตถุแหลม (เฉพาะ) เท่านั้นและวัตถุเดียวที่รับผิดชอบการทำลายมัน

ภายใต้สมมติฐานนี้getDevice()ควรส่งคืนพอยน์เตอร์แบบสังเกตง่าย(การพอยน์เตอร์พอยน์เตอร์เป็นพอยน์เตอร์ที่ไม่ทำให้วัตถุแหลมมีชีวิตอยู่) ชนิดของการสังเกตที่ง่ายที่สุดคือตัวชี้แบบดิบ:

#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...
}

[ หมายเหตุ 1: คุณอาจสงสัยว่าทำไมฉันถึงใช้พอยน์เตอร์ดิบที่นี่เมื่อทุกคนบอกว่าพอยน์เตอร์ดิบนั้นไม่ดีไม่ปลอดภัยและอันตราย แต่จริงๆแล้วเป็นคำเตือนที่มีค่า แต่มันเป็นสิ่งสำคัญที่จะนำมันในบริบทที่ถูกต้อง: ตัวชี้ดิบที่ไม่ดีเมื่อนำมาใช้สำหรับการดำเนินการจัดการหน่วยความจำคู่มือเช่นการจัดสรรและ deallocating วัตถุผ่านและnew deleteเมื่อใช้อย่างหมดจดเป็นวิธีการเพื่อให้บรรลุความหมายอ้างอิงและผ่านไปรอบ ๆ ที่ไม่ได้เป็นเจ้าของสังเกตพอยน์เตอร์ไม่มีอะไรที่เป็นอันตรายภายในพอยน์เตอร์พอยน์ยกเว้นอาจเป็นเพราะความจริงที่ว่าเราควรระวัง - จบหมายเหตุ 1 ]

[ หมายเหตุ 2: ตามที่ปรากฏในความคิดเห็นในกรณีนี้โดยเฉพาะที่ความเป็นเจ้าของไม่ซ้ำกันและวัตถุที่เป็นเจ้าของจะรับประกันเสมอว่าจะนำเสนอ (เช่นสมาชิกข้อมูลภายในdeviceจะไม่เป็นไปได้nullptr) ฟังก์ชั่นgetDevice()สามารถ (และอาจจะ) ส่งคืนการอ้างอิงมากกว่าตัวชี้ ในขณะที่สิ่งนี้เป็นจริงฉันตัดสินใจคืนตัวชี้แบบดิบที่นี่เพราะฉันหมายความว่านี่เป็นคำตอบสั้น ๆ ที่คนทั่วไปสามารถพูดถึงกรณีที่deviceเป็นไปได้nullptrและเพื่อแสดงให้เห็นว่าตัวชี้แบบดิบนั้นใช้ได้ดีตราบใดที่ไม่ได้ใช้ การจัดการหน่วยความจำด้วยตนเอง - จบหมายเหตุ 2 ]

แน่นอนว่าสถานการณ์นั้นแตกต่างกันอย่างสิ้นเชิงหากSettingsวัตถุของคุณไม่ควรมีกรรมสิทธิ์เฉพาะของอุปกรณ์ ตัวอย่างเช่นในกรณีนี้หากการทำลายของSettingsวัตถุไม่ควรบ่งบอกถึงการทำลายของDeviceวัตถุที่แหลมเช่นกัน

นี่เป็นสิ่งที่มีเพียงคุณเท่านั้นที่เป็นผู้ออกแบบโปรแกรมของคุณที่สามารถบอกได้ จากตัวอย่างที่คุณให้มามันยากสำหรับฉันที่จะบอกว่านี่เป็นกรณีหรือไม่

เพื่อช่วยให้คุณเข้าใจได้คุณอาจถามตัวเองว่ามีวัตถุอื่นนอกเหนือจากSettingsที่มีสิทธิ์รักษาDeviceวัตถุให้มีชีวิตอยู่หรือไม่ตราบใดที่วัตถุนั้นยังคงมีพอยน์เตอร์อยู่ หากเป็นเช่นนั้นคุณต้องมีนโยบายการเป็นเจ้าของร่วมซึ่งเป็นstd::shared_ptrข้อเสนอ:

#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...
}

ขอให้สังเกตว่าweak_ptrเป็นตัวชี้การสังเกตไม่ใช่ตัวชี้การเป็นเจ้าของ - ในคำอื่น ๆ มันจะไม่ทำให้วัตถุแหลมมีชีวิตอยู่หากตัวชี้การเป็นเจ้าของอื่น ๆ ทั้งหมดไปยังวัตถุปลายแหลมอยู่นอกขอบเขต

ข้อดีของweak_ptrการใช้ตัวชี้ raw แบบปกติคือคุณสามารถบอกได้อย่างปลอดภัยว่าweak_ptrกำลังห้อยอยู่หรือไม่ (นั่นคือการชี้ไปยังวัตถุที่ถูกต้องหรือว่าวัตถุนั้นถูกทำลายไปแล้วในตอนแรก) สิ่งนี้สามารถทำได้โดยการเรียกexpired()ฟังก์ชั่นสมาชิกบนweak_ptrวัตถุ

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_ptrใช้สำหรับอ้างอิงลูปเท่านั้น กราฟการขึ้นต่อกันต้องเป็นกราฟที่กำหนดทิศทางไว้ ในพอยน์เตอร์ที่แชร์มีจำนวนการอ้างอิง 2 รายการ: 1 สำหรับshared_ptrs และ 1 สำหรับตัวชี้ ( shared_ptrและweak_ptr) ทั้งหมด เมื่อshared_ptrลบ s ทั้งหมดแล้วตัวชี้จะถูกลบ เมื่อตัวชี้เป็นสิ่งจำเป็นจากweak_ptr, lockควรจะใช้ในการรับตัวชี้ถ้ามันมีอยู่