shared_ptr และ weak_ptr กับการครอบครองร่วมกัน
แบ่งปันการครอบครองด้วยการนับรีเฟอเรนซ์ และตัดวงจรด้วย weak_ptr
shared_ptr และ weak_ptr กับการครอบครองร่วมกัน เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน
การใช้ออบเจ็กต์ร่วมกัน
บางครั้งหลายส่วนของโปรแกรมจำเป็นต้องทำให้ออบเจ็กต์ยังคงอยู่ std::shared_ptr<T> จัดการความเป็นเจ้าของร่วมด้วยการนับการอ้างอิง
การสร้าง shared_ptr
ใช้ std::make_shared ซึ่งจัดสรรบล็อกควบคุมและออบเจ็กต์ในการจัดสรรครั้งเดียว
#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count(); // 1การคัดลอกทำให้มีความเป็นเจ้าของร่วม
การคัดลอก shared_ptr จะเพิ่มตัวนับการอ้างอิง การทำลายหรือการกำหนดค่าใหม่จะลดตัวนับ เมื่อจำนวนนับถึง 0 ออบเจ็กต์จะถูกลบ
auto a = std::make_shared<Widget>();
auto b = a; // ref count is now 2
std::cout << a.use_count(); // 2เบื้องหลังการทำงาน
shared_ptr เก็บพอยน์เตอร์สองตัว ตัวหนึ่งชี้ไปยังออบเจ็กต์ อีกตัวชี้ไปยังบล็อกควบคุมที่มีตัวนับการอ้างอิง บล็อกควบคุมจะถูกจัดสรรบนฮีป
ตัวนับการอ้างอิงแบบอะตอมิก
ตัวนับการอ้างอิงใช้การดำเนินการแบบอะตอมิก เพื่อให้สามารถคัดลอก shared_ptr ข้ามเธรดได้อย่างปลอดภัย อย่างไรก็ตาม ออบเจ็กต์ที่พอยน์เตอร์ชี้ถึงไม่ได้ปลอดภัยต่อการทำงานหลายเธรดโดยอัตโนมัติ
การรีเซ็ตและการกำหนดค่าใหม่
การกำหนดค่าใหม่จะลดตัวนับการอ้างอิงเดิมและเพิ่มตัวนับของค่าใหม่ ส่วน reset() จะกำหนดให้ shared_ptr อยู่ในสถานะว่าง
shared_ptr จากพอยน์เตอร์ดิบ (ควรหลีกเลี่ยง)
อย่าสร้าง shared_ptr สองตัวจากพอยน์เตอร์ดิบตัวเดียวกัน เพราะแต่ละตัวจะมีบล็อกควบคุมของตัวเอง โปรดใช้ make_shared เสมอ
// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw); // disaster: two control blocksปัญหาการวนเป็นวงจร
shared_ptr สองตัวที่อ้างอิงถึงกันจะก่อให้เกิดวงจร ตัวนับการอ้างอิงของทั้งสองตัวจะไม่มีวันลดลงถึงศูนย์ และไม่มีตัวใดถูกคืนหน่วยความจำ หน่วยความจำจึงรั่วไหล
struct Node {
std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // cycle — never freedตัดวงจรด้วย weak_ptr
std::weak_ptr<T> เฝ้าดู shared_ptr โดยไม่เข้าร่วมในตัวนับการอ้างอิง ใช้ด้านหนึ่งของความสัมพันธ์เป็น weak เพื่อทำลายวงจร
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak — does not own
};การใช้ weak_ptr
คุณไม่สามารถเข้าถึงค่าผ่าน weak_ptr ได้โดยตรง ให้เรียก lock() เพื่อรับ shared_ptr หรือได้รับค่าว่างหากออบเจ็กต์ถูกทำลายไปแล้ว
std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
p->use(); // safe — we have a shared_ptr now
} else {
std::cout << "object expired";
}ต้นทุนเมื่อเทียบกับ unique_ptr
shared_ptr มีขนาดใหญ่กว่า (พอยน์เตอร์สองตัวรวมกับบล็อกควบคุม) และทำงานช้ากว่า (เนื่องจากตัวนับการอ้างอิงแบบอะตอมิก) โปรดใช้เฉพาะเมื่อจำเป็นต้องแบ่งปันการครอบครองจริง ๆ
ตรวจสอบความเข้าใจ
กรณีการใช้งานโดยทั่วไปของ std::weak_ptr คืออะไร
สรุปทบทวน
shared_ptr ติดตามการครอบครองด้วยตัวนับการอ้างอิงแบบอะตอมิก โปรดใช้ make_shared ระวังวงจร และทำลายวงจรเหล่านั้นด้วย weak_ptr หากไม่จำเป็นต้องแบ่งปันการครอบครอง ให้เลือกใช้ unique_ptr
คำถามที่พบบ่อย
บทเรียน “shared_ptr และ weak_ptr กับการครอบครองร่วมกัน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “shared_ptr และ weak_ptr กับการครอบครองร่วมกัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “shared_ptr และ weak_ptr กับการครอบครองร่วมกัน”
แบ่งปันการครอบครองด้วยการนับรีเฟอเรนซ์ และตัดวงจรด้วย weak_ptr คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “shared_ptr และ weak_ptr กับการครอบครองร่วมกัน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม
ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- เหตุใดพอยน์เตอร์อัจฉริยะจึงมาแทน new และ delete แบบดิบ
- unique_ptr และการครอบครองแต่เพียงผู้เดียว
- shared_ptr และ weak_ptr กับการครอบครองร่วมกัน
- ตัวลบแบบกำหนดเองและฟังก์ชันสร้าง