0Pricing
C++ Academy · บทเรียน

unique_ptr และการครอบครองแต่เพียงผู้เดียว

แสดงความหมายของการมีเจ้าของเพียงรายเดียวด้วย unique_ptr และชนิดที่ย้ายได้เท่านั้น

unique_ptr และการครอบครองแต่เพียงผู้เดียว เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

พอยน์เตอร์อัจฉริยะสำหรับเจ้าของรายเดียว

std::unique_ptr<T> เป็นเจ้าของออบเจ็กต์หนึ่งรายการบนฮีป เมื่อ unique_ptr ถูกทำลาย ออบเจ็กต์จะถูกลบ ไม่สามารถคัดลอกได้ — ย้ายได้เท่านั้น

การสร้าง unique_ptr

ใช้ std::make_unique (C++14) ซึ่งปลอดภัยเมื่อเกิดข้อยกเว้นและกระชับ

#include <memory>
auto w = std::make_unique<Widget>();         // default-constructed
auto p = std::make_unique<Point>(3, 4);       // forwarded args

ใช้งานเหมือนพอยน์เตอร์

unique_ptr รองรับการดำเนินการกับพอยน์เตอร์ทั่วไป

auto p = std::make_unique<Point>(3, 4);
std::cout << p->x;        // arrow access
std::cout << (*p).y;      // dereference
if (p) std::cout << "non-null";

คัดลอกไม่ได้ — ย้ายได้

การคัดลอกจะหมายถึงมีเจ้าของสองราย — ซึ่งขัดกับความหมายของคำว่า "หนึ่งเดียว" การย้ายจะโอนความเป็นเจ้าของ

std::unique_ptr<int> a = std::make_unique<int>(1);
std::unique_ptr<int> b = std::move(a);
// a is now empty, b owns the int

การส่งให้ฟังก์ชัน

ส่งตามค่า (พร้อม std::move): โอนความเป็นเจ้าของ ส่งตามการอ้างอิง: ยืมโดยไม่ถือครองความเป็นเจ้าของ

void consume(std::unique_ptr<Widget> w);   // takes ownership
void inspect(const Widget& w);              // borrows

auto w = std::make_unique<Widget>();
consume(std::move(w));
// w is now empty
inspect(*w);                                // (after re-creating)

การส่งคืนจากฟังก์ชัน

ฟังก์ชันที่จัดสรรออบเจ็กต์และส่งคืนความเป็นเจ้าของควรส่งคืน std::unique_ptr

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

การรีเซ็ตและการปล่อยความเป็นเจ้าของ

reset() จะลบออบเจ็กต์ปัจจุบันและ (ถ้ามี) รับความเป็นเจ้าของออบเจ็กต์ใหม่ ส่วน release() จะสละความเป็นเจ้าของและส่งคืนพอยน์เตอร์ดิบ

auto p = std::make_unique<int>(10);
p.reset(new int(20));    // delete the old, own the new
int* raw = p.release();   // p is now empty
delete raw;               // caller must delete

get(): ยืมพอยน์เตอร์ดิบ

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

auto p = std::make_unique<int>(42);
legacy_api(p.get());      // p still owns it

unique_ptr สำหรับอาร์เรย์

สำหรับอาร์เรย์ ให้ใช้ unique_ptr<T[]> เข้าถึงสมาชิกด้วยดัชนีโดยใช้ [] และจะเรียก delete[] เมื่อถูกทำลาย

auto arr = std::make_unique<int[]>(10);
arr[0] = 99;
std::cout << arr[0];

ตัวลบแบบกำหนดเอง

ระบุตัวลบแบบกำหนดเองเป็นพารามิเตอร์เทมเพลตเมื่อทรัพยากรไม่ใช่หน่วยความจำดิบ เช่น ตัวจัดการไฟล์หรือทรัพยากรของ OS

auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(std::fopen("a.txt","r"), closer);

ประสิทธิภาพ

เมื่อตัวลบเริ่มต้นถูกใช้ unique_ptr จะมีขนาดและความเร็วเท่ากับพอยน์เตอร์ดิบ — ไม่มีค่าใช้จ่ายส่วนเกิน

ตรวจสอบความเข้าใจ

เหตุใด std::unique_ptr จึงห้ามการคัดลอก

สรุปทบทวน

std::unique_ptr คือพอยน์เตอร์อัจฉริยะเริ่มต้น: ไม่มีค่าใช้จ่ายส่วนเกิน มีความเป็นเจ้าของแต่เพียงผู้เดียว ย้ายได้แต่คัดลอกไม่ได้ ควรเลือก std::make_unique สำหรับการสร้าง

คำถามที่พบบ่อย

บทเรียน “unique_ptr และการครอบครองแต่เพียงผู้เดียว” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “unique_ptr และการครอบครองแต่เพียงผู้เดียว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “unique_ptr และการครอบครองแต่เพียงผู้เดียว”

แสดงความหมายของการมีเจ้าของเพียงรายเดียวด้วย unique_ptr และชนิดที่ย้ายได้เท่านั้น คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “unique_ptr และการครอบครองแต่เพียงผู้เดียว” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม

ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. เหตุใดพอยน์เตอร์อัจฉริยะจึงมาแทน new และ delete แบบดิบ
  2. unique_ptr และการครอบครองแต่เพียงผู้เดียว
  3. shared_ptr และ weak_ptr กับการครอบครองร่วมกัน
  4. ตัวลบแบบกำหนดเองและฟังก์ชันสร้าง
← กลับไปที่ C++ Academy