C++ Primer, ฉบับที่ 5

📚 สรุปเนื้อหา

คู่มือที่ครอบคลุมและเป็นที่ยอมรับอย่างสูงเกี่ยวกับภาษา C++ ที่ถูกเขียนใหม่ทั้งหมดเพื่อรองรับมาตรฐาน C++11 หลักสูตรนี้ครอบคลุมตั้งแต่องค์ประกอบพื้นฐานของภาษา ไปจนถึงเครื่องมือขั้นสูงในการจัดการไลบรารี และเครื่องมือการสร้างคลาสขั้นสูง

คู่มือมาตรฐานอุตสาหกรรมที่สมบูรณ์แบบสำหรับการเชี่ยวชาญการเขียนโปรแกรมด้วย C++ สมัยใหม่

ผู้เขียน: สแตนลีย์ บี. ลิปแมน, โจซี ลาโออี, บาร์บาร่า เอ. มู

ขอบคุณ: เดฟ อาเบราแฮมส์, แอนดี้ โคเนจ, สเตเฟน ที. ลาวาเวจ, แจสัน เมอร์ริลล์, จอห์น สไปเซอร์, เฮิร์บ ซัตเตอร์, บียาร์เน สโตรูสตรัป, อล렉ซ์ สเตปานอฟ และสมาชิกคณะกรรมการกำหนดมาตรฐาน

🎯 เป้าหมายการเรียนรู้

1. กำหนดและนำ main ฟังก์ชันมาใช้งาน และเข้าใจการโต้ตอบกับระบบปฏิบัติการ
2. ดำเนินการคอมไพล์จากบรรทัดคำสั่ง และจัดการการส่งออก-รับเข้าข้อมูลพื้นฐาน (cin, cout)
3. ใช้โครงสร้างควบคุมลำดับการทำงานเพื่อแก้ปัญหาตรรกะแบบวนซ้ำ เช่น การนับจำนวนปรากฏ
4. ประยุกต์โครงสร้างตรรกะเพื่อนับและประมวลผลข้อมูลที่ปรากฏต่อเนื่องกัน
5. แยกความแตกต่างระหว่างตัวดำเนินการกำหนดค่า (=) และตัวดำเนินการเปรียบเทียบค่าเท่ากัน (==) ภายในประโยคควบคุม
6. ใช้วัตถุคลาส (Sales_item) ใช้ฟังก์ชันสมาชิกผ่านตัวดำเนินการจุด (dot operator) และรวมไฟล์หัวข้อเฉพาะที่สร้างเองได้
7. แยกความแตกต่างระหว่างชนิดข้อมูลพื้นฐานต่าง ๆ และคาดการณ์ผลลัพธ์จากการแปลงชนิดข้อมูลและการเปลี่ยนค่าอาร์กิเมนต์ของเลขจำนวนบวก
8. ใช้คุณสมบัติของ C++11 เช่น การเริ่มต้นแบบรายการ (list initialization), nullptr, constexpr, และตัวระบุการอนุมานประเภท
9. แยกความแตกต่างระหว่างการประกาศตัวแปรและการกำหนดตัวแปร และใช้กฎขอบเขต (scope rules) เพื่อจัดการความมองเห็นของชื่อตัวแปร
10. แยกความแตกต่างระหว่างการอ้างอิง (references) และตัวชี้ (pointers) และใช้ void* เพื่อจัดการหน่วยความจำโดยทั่วไป

🔹 บทเรียนที่ 1: แนะนำภาษา C++ และการรับ-ส่งข้อมูลพื้นฐาน

ภาพรวม: บทเรียนนี้แนะนำโครงสร้างพื้นฐานของโปรแกรมภาษา C++ โดยเน้นที่ฟังก์ชัน main ชนิดข้อมูลพื้นฐาน และกระบวนการคอมไพล์ ครอบคลุมการดำเนินการรับ-ส่งข้อมูลพื้นฐานโดยใช้ไลบรารี iostream ตรรกะการทำงานผ่านลูป while และ for และจบลงด้วยการแนะนำแนวคิดทางวัตถุ (object-oriented) ผ่านคลาส Sales_item

ผลลัพธ์การเรียนรู้:

• กำหนดและนำ main ฟังก์ชันมาใช้งาน และเข้าใจการโต้ตอบกับระบบปฏิบัติการ
• ดำเนินการคอมไพล์จากบรรทัดคำสั่ง และจัดการการส่งออก-รับเข้าข้อมูลพื้นฐาน (cin, cout)
• ใช้โครงสร้างควบคุมลำดับการทำงานเพื่อแก้ปัญหาตรรกะแบบวนซ้ำ เช่น การนับจำนวนปรากฏ

🔹 บทเรียนที่ 2: การควบคุมลำดับการทำงานและแนวคิดพื้นฐานของคลาส

ภาพรวม: บทเรียนนี้เปลี่ยนจากโครงสร้างควบคุมลำดับการทำงานพื้นฐานไปสู่พลังพื้นฐานของภาษา C++: คลาส ผู้เรียนจะได้เรียนรู้ตรรกะที่จำเป็นต้องใช้ในการประมวลผลข้อมูลไหล (การนับจำนวนการปรากฏต่อเนื่องกัน) และเรียนรู้วิธีใช้คลาส Sales_item เพื่อจัดการโครงสร้างข้อมูลที่ซับซ้อนได้อย่างง่ายดายเหมือนชนิดข้อมูลในตัว บทเรียนสิ้นสุดด้วยการสร้างโปรแกรมร้านหนังสือที่ทำงานได้จริง โดยรวมการเปลี่ยนเส้นทางไฟล์และการรายงานข้อผิดพลาด

ผลลัพธ์การเรียนรู้:

• ประยุกต์โครงสร้างตรรกะเพื่อนับและประมวลผลข้อมูลที่ปรากฏต่อเนื่องกัน
• แยกความแตกต่างระหว่างตัวดำเนินการกำหนดค่า (=) และตัวดำเนินการเปรียบเทียบค่าเท่ากัน (==) ภายในประโยคควบคุม
• ใช้วัตถุคลาส (Sales_item) ใช้ฟังก์ชันสมาชิกผ่านตัวดำเนินการจุด (dot operator) และรวมไฟล์หัวข้อเฉพาะที่สร้างเองได้

🔹 บทเรียนที่ 3: ชนิดข้อมูลพื้นฐานและตัวแปร

ภาพรวม: บทเรียนนี้สร้างพื้นฐานสำคัญของการเขียนโปรแกรมภาษา C++ โดยสำรวจชนิดข้อมูลเชิงพาณิชย์ วงจรชีวิตของตัวแปร และโมเดลหน่วยความจำ นักเรียนจะเรียนรู้รายละเอียดการแปลงชนิดข้อมูล (โดยเฉพาะชนิดไม่ลบ) รูปแบบการเริ่มต้นแบบรายการใน C++11 และความแตกต่างที่สำคัญระหว่างตัวชี้ (pointer) กับการอ้างอิง (reference) บทเรียนสิ้นสุดด้วยระบบชนิดข้อมูลขั้นสูง ได้แก่ คุณสมบัติ const อนุมานชนิด (auto, decltype) และการสร้างโครงสร้างข้อมูลเฉพาะที่แข็งแรงโดยใช้การป้องกันไฟล์หัวข้อ (preprocessor guards)

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่างชนิดข้อมูลพื้นฐานต่าง ๆ และคาดการณ์ผลลัพธ์จากการแปลงชนิดข้อมูลและการเปลี่ยนค่าอาร์กิเมนต์ของเลขจำนวนบวก
• ใช้คุณสมบัติของ C++11 เช่น การเริ่มต้นแบบรายการ (list initialization), nullptr, constexpr, และตัวระบุการอนุมานประเภท
• แยกความแตกต่างระหว่างการประกาศตัวแปรและการกำหนดตัวแปร และใช้กฎขอบเขต (scope rules) เพื่อจัดการความมองเห็นของชื่อตัวแปร

🔹 บทเรียนที่ 4: ชนิดข้อมูลผสมและคุณสมบัติชนิดขั้นสูง

ภาพรวม: บทเรียนนี้สำรวจระบบชนิดข้อมูลที่ซับซ้อนของ C++11 โดยเน้นว่าชนิดข้อมูลผสม (ตัวชี้และตัวอ้างอิง) ทำงานร่วมกับคุณสมบัติชนิดอย่างไร เช่น const และ constexpr นักเรียนจะเรียนรู้รายละเอียดการอนุมานชนิดโดยใช้ auto และ decltype และเรียนรู้วิธีห่อหุ้มข้อมูลไว้ภายในโครงสร้างเฉพาะที่ได้รับการป้องกันด้วยการป้องกันไฟล์หัวข้อ (preprocessor header guards)

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่างการอ้างอิง (references) และตัวชี้ (pointers) และใช้ void* เพื่อจัดการหน่วยความจำโดยทั่วไป
• จัดหมวดหมู่และนำไปใช้คุณสมบัติ const ระดับสูงและระดับต่ำ และ constexpr เพื่อค่าคงที่ที่คำนวณตอนคอมไพล์
• ใช้การอนุมานชนิดของ C++11 (auto และ decltype) เพื่อเขียนโค้ดที่ยืดหยุ่นและบำรุงรักษาง่าย

🔹 บทเรียนที่ 5: สายอักขระและเวกเตอร์ในไลบรารี

ภาพรวม: บทเรียนนี้ครอบคลุมชนิดข้อมูลหลักของไลบรารีมาตรฐานภาษา C++ ได้แก่ string และ vector ซึ่งให้ทางเลือกที่ยืดหยุ่นและปลอดภัยกว่าชนิดข้อมูลในตัว นักเรียนจะเรียนรู้วิธีจัดการการเข้าถึงชื่อพื้นที่ (namespace) โดยใช้คำสั่ง using จัดการการเริ่มต้นและจัดการข้อมูลที่มีความยาวเปลี่ยนแปลงได้ และใช้ลูปแบบ for ตามช่วงข้อมูล (range-based for) และตัวชี้ (iterator) เพื่อประมวลผลกลุ่มข้อมูลอย่างมีประสิทธิภาพ

ผลลัพธ์การเรียนรู้:

• ลดความซับซ้อนของโค้ดโดยใช้คำสั่ง namespace using พร้อมหลีกเลี่ยงข้อผิดพลาดทั่วไปในไฟล์หัวข้อ
• จัดการการเริ่มต้น string และ vector อย่างมั่นคง รวมถึงการเริ่มต้นแบบรายการใน C++11
• ประมวลผลระดับตัวอักษรและขยายขนาดคอนเทนเนอร์แบบไดนามิกโดยใช้ push_back, ลูป for ตามช่วงข้อมูล และการดำเนินการพื้นฐานของตัวชี้ (iterator)

🔹 บทเรียนที่ 6: ตัวชี้และอาร์เรย์ในตัว

ภาพรวม: บทเรียนนี้ครอบคลุมกลไกพื้นฐานสำหรับการเดินทางและจัดการลำดับข้อมูลใน C++11 ย้ายจากเครื่องมือระดับสูงทันสมัยอย่างตัวชี้ (iterator) สำหรับ string และ vector ไปสู่อาร์เรย์ในตัวระดับล่าง คำนวณตัวชี้ (pointer arithmetic) และสตริงตัวอักษรแบบดั้งเดิม นักเรียนจะเรียนรู้วิธีเชื่อมต่อโค้ดที่ใช้อาร์เรย์เก่ากับคอนเทนเนอร์ไลบรารีมาตรฐานสมัยใหม่ และจัดการโครงสร้างหลายมิติที่ซับซ้อน

ผลลัพธ์การเรียนรู้:

• ใช้ตัวชี้ (iterator) และการคำนวณตัวชี้ (iterator arithmetic) เพื่อเดินทางและจัดการคอนเทนเนอร์ string และ vector
• กำหนด ตั้งค่า และเดินทางผ่านอาร์เรย์ในตัวโดยใช้การคำนวณตัวชี้และฟังก์ชันไลบรารี begin/end
• ใช้งานการดำเนินการสตริงแบบดั้งเดิมอย่างปลอดภัย และเชื่อมต่ออาร์เรย์ในตัวกับชนิดไลบรารีสมัยใหม่

🔹 บทเรียนที่ 7: นิพจน์ ตัวดำเนินการ และการแปลง

ภาพรวม: บทเรียนนี้ครอบคลุมองค์ประกอบพื้นฐานของนิพจน์ในภาษา C++ โดยเน้นว่าภาษาจัดการการประเมินการดำเนินการและจัดการชนิดข้อมูลอย่างไร นักเรียนจะเรียนรู้ความแตกต่างระหว่าง lvalue กับ rvalue กฎของลำดับการดำเนินการและลำดับการดำเนินการ (precedence and associativity) และกลไกของการดำเนินการทางคณิตศาสตร์ ตรรกะ และบิต นอกเหนือจากนี้ บทเรียนยังเจาะลึกเรื่องการจัดการชนิดข้อมูลในภาษา C++ รวมถึงการแปลงข้อมูลเชิงคณิตศาสตร์โดยอัตโนมัติและการใช้การแปลงชื่ออย่างปลอดภัย

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่าง lvalue (เอกลักษณ์ของวัตถุ) กับ rvalue (ค่าของวัตถุ) และเข้าใจบทบาทของพวกมันในนิพจน์
• คาดการณ์ลำดับการประเมินนิพจน์ที่ซับซ้อนโดยใช้ลำดับการดำเนินการ ลำดับการดำเนินการ และตรรกะตัดสินใจ
• ดำเนินการจัดการข้อมูลระดับล่างโดยใช้ตัวดำเนินการบิต และจัดการความปลอดภัยของชนิดข้อมูลผ่านการแปลงโดยอัตโนมัติและการแปลงชื่อที่ชัดเจน

🔹 บทเรียนที่ 8: คำสั่งขั้นสูงและการจัดการข้อผิดพลาด

ภาพรวม: บทเรียนนี้ครอบคลุมโครงสร้างควบคุมลำดับการทำงานที่จำเป็นในภาษา C++ ตั้งแต่ชนิดคำสั่งพื้นฐานและกฎการจัดขอบเขต ไปจนถึงตรรกะที่ซับซ้อนขึ้นทั้งแบบเงื่อนไขและแบบวนซ้ำ บทเรียนยังแนะนำเทคนิคการจัดการข้อผิดพลาดที่มั่นคงโดยใช้กลไกการจัดการข้อผิดพลาด (exception handling) ของภาษา C++ และลำดับชั้นข้อผิดพลาดในไลบรารีมาตรฐาน

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่างคำสั่งว่างเปล่า คำสั่งธรรมดา และคำสั่งซ้อน และจัดการขอบเขตตัวแปรภายในโครงสร้างเหล่านี้
• ใช้คำสั่ง if และ switch อย่างซับซ้อนเพื่อตัดสินใจ ในขณะที่แก้ไขข้อผิดพลาดตรรกะเช่น "dangling else"
• เลือกและใช้โครงสร้างวนซ้ำที่เหมาะสม (while, for, range for, do while) สำหรับงานเขียนโปรแกรมเฉพาะ

🔹 บทเรียนที่ 9: การออกแบบฟังก์ชันและการส่งพารามิเตอร์

ภาพรวม: บทเรียนนี้ครอบคลุมสถาปัตยกรรมของฟังก์ชันในภาษา C++ โดยเน้นว่าข้อมูลถูกส่งเข้าไปในบล็อกโค้ดที่แยกส่วน และส่งคืนออกมาอย่างไร บทเรียนสำรวจวงจรชีวิตของวัตถุท้องถิ่น กลไกการส่งพารามิเตอร์ (ค่าแทนอ้างอิง) และมาตรฐาน C++11 สำหรับการจัดการพารามิเตอร์ที่หลากหลาย การเข้าใจแนวคิดเหล่านี้ช่วยให้ผู้เขียนโปรแกรมสามารถเขียนโค้ดที่มีประสิทธิภาพ ใช้ซ้ำได้ และปลอดภัยต่อหน่วยความจำ

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่างวิธีการเริ่มต้นพารามิเตอร์ และผลกระทบต่อประสิทธิภาพและความถูกต้องของข้อมูล
• สร้าง interface ฟังก์ชันที่มั่นคงโดยใช้ const qualifier, initializer_list, และเทคนิคการส่งอาร์เรย์
• จัดการอายุการใช้งานวัตถุอย่างมีประสิทธิภาพโดยใช้ระยะเวลาเก็บข้อมูลแบบอัตโนมัติ (automatic) และแบบคงที่ (static)

🔹 บทเรียนที่ 10: ความสามารถขั้นสูงและการโอเวอร์โหลดฟังก์ชัน

ภาพรวม: บทเรียนนี้ครอบคลุมกลไกขั้นสูงของฟังก์ชันในภาษา C++ โดยเน้นการส่งพารามิเตอร์ วงจรชีวิตของวัตถุ และความซับซ้อนของการโอเวอร์โหลดฟังก์ชัน นักเรียนจะเรียนรู้คุณสมบัติ C++11 เช่น initializer_list สำหรับพารามิเตอร์ที่หลากหลาย constexpr ฟังก์ชัน และการประกาศและใช้ pointer ฟังก์ชันเพื่อสร้างโค้ดที่ยืดหยุ่นและแยกส่วนได้

ผลลัพธ์การเรียนรู้:

• แยกความแตกต่างระหว่างการส่งค่า (pass-by-value) และการส่งอ้างอิง (pass-by-reference) และระบุเมื่อควรใช้พารามิเตอร์ const
• ใช้กฎการเลือกโอเวอร์โหลดเพื่อระบุ "ตัวเลือกที่ดีที่สุด" จากฟังก์ชันที่เป็นไปได้และเหมาะสม
• ใช้ pointer ฟังก์ชัน รวมถึงการใช้งานใน container เช่น vector และเป็น return type

🔹 บทเรียนที่ 11: การห่อหุ้มคลาสและคอนสตรัคเตอร์

ภาพรวม: บทเรียนนี้ครอบคลุมการเปลี่ยนจากโครงสร้างข้อมูลพื้นฐานไปสู่ชนิดข้อมูลที่มีนามธรรม (ADT) ในภาษา C++ บทเรียนเน้นกลไกการออกแบบคลาส ได้แก่ ฟังก์ชันสมาชิก ตัวชี้ this ที่ซ่อนอยู่ และบทบาทสำคัญของคอนสตรัคเตอร์ในการเริ่มต้นวัตถุ นอกจากนี้ยังสำรวจการห่อหุ้มผ่านการควบคุมการเข้าถึง (public/private) และการใช้ "เพื่อน" (friends) เพื่อรักษา interface ที่สะอาดพร้อมซ่อนรายละเอียดการประมวลผล

ผลลัพธ์การเรียนรู้:

• ออกแบบและสร้างคลาส C++ (เช่น Sales_data) ที่แยก interface ออกจาก implementation
• ควบคุมกฎการเริ่มต้นวัตถุโดยใช้คอนสตรัคเตอร์แบบเริ่มต้น โอเวอร์โหลด และ explicit
• ใช้ specifier การเข้าถึงและ friendship เพื่อเสริมการห่อหุ้มและจัดการขอบเขตของคลาส

🔹 บทเรียนที่ 12: ขอบเขตของคลาสและการจัดการการแปลง

ภาพรวม: บทเรียนนี้ครอบคลุมกลไกขั้นสูงของการออกแบบคลาสในภาษา C++ โดยเน้นการเปลี่ยนจากโครงสร้างข้อมูลพื้นฐานไปสู่ ADT ที่มั่นคง หัวข้อสำคัญ ได้แก่ การจัดการการเริ่มต้นวัตถุผ่านประเภทคอนสตรัคเตอร์ต่างๆ การควบคุมการแปลงชนิดข้อมูลโดยอัตโนมัติโดยใช้คำสั่ง explicit และความเข้าใจในสิ่งที่อยู่ในระดับคลาส เช่น สมาชิก static และคลาส literal

ผลลัพธ์การเรียนรู้:

• ออกแบบและสร้างคลาสที่มีการห่อหุ้ม (ADT) โดยใช้ specifier การเข้าถึงและคำสั่ง friend declarations
• จัดการการแปลงชนิดข้อมูลโดยอัตโนมัติ และปิดกั้นการแปลงโดยใช้คำสั่ง explicit
• ใช้และตั้งค่า static member ของคลาสเพื่อจัดการข้อมูลที่ใช้ร่วมกันทั้งคลาส

🔹 บทเรียนที่ 13: การรับ-ส่งข้อมูลผ่าน Stream และพื้นฐานของคอนเทนเนอร์ลำดับ

ภาพรวม: บทเรียนนี้ครอบคลุมกลไกพื้นฐานของระบบ I/O ไลบรารีมาตรฐาน C++ และคอนเทนเนอร์ลำดับ นักเรียนจะเรียนรู้การจัดการสถานะกระแส (stream condition states) และบัฟเฟอร์เอาต์พุต การดำเนินการ I/O บนไฟล์และสตริง และการเดินทางผ่านคอนเทนเนอร์ในไลบรารี บทเรียนเน้นแนวคิดสำคัญ เช่น ช่วงตัวชี้ (iterator ranges) การเริ่มต้นคอนเทนเนอร์ และผลกระทบด้านประสิทธิภาพของการจัดการหน่วยความจำในคอนเทนเนอร์

ผลลัพธ์การเรียนรู้:

• สอบถามและรีเซ็ตสถานะกระแส (stream condition states) และควบคุมการรีเซ็ตบัฟเฟอร์เอาต์พุตเพื่อรักษาความสมบูรณ์ของกระแส
• ใช้ fstream และ sstream เพื่อจัดการข้อมูลถาวรและข้อมูลในหน่วยความจำโดยใช้โหมดไฟล์ต่างๆ
• เลือกคอนเทนเนอร์ลำดับที่เหมาะสมตามรูปแบบการเข้าถึงและต้นทุนหน่วยความจำ เพื่อเพิ่มประสิทธิภาพการเลือก

🔹 บทเรียนที่ 14: การดำเนินการของคอนเทนเนอร์และอัลกอริธึมทั่วไป

ภาพรวม: บทเรียนนี้ครอบคลุมการจัดการคอนเทนเนอร์ลำดับของ C++ และการประยุกต์ใช้อัลกอริธึมทั่วไปเพื่อประมวลผลข้อมูลโดยไม่ขึ้นกับประเภทของคอนเทนเนอร์ บทเรียนสำรวจวิธีที่คอนเทนเนอร์จัดการการเติบโตของหน่วยความจำและวงจรชีวิตขององค์ประกอบ พร้อมการใช้ lambda และ function binders เพื่อปรับแต่งอัลกอริธึมไลบรารี นักเรียนจะเรียนรู้โครงสร้างของไลบรารี รวมถึงประเภทตัวชี้ (iterator categories) และอัลกอริธึมเฉพาะ

ผลลัพธ์การเรียนรู้:

• จัดการวงจรชีวิตของคอนเทนเนอร์โดยใช้การดำเนินการเฉพาะสำหรับ forward_list เทคนิคการปรับขนาด และการจัดการ capacity ของ vector
• ดำเนินการเปลี่ยนแปลงสตริงขั้นสูงและแปลงเลขจำนวนโดยใช้ไลบรารี string ที่ขยาย และ adaptor ของคอนเทนเนอร์
• ใช้อัลกอริธึมทั่วไปเพื่ออ่าน เขียน และจัดเรียงข้อมูล โดยปรับพฤติกรรมผ่าน predicate ตัวแปร lambda และ std::bind

🔹 บทเรียนที่ 15: คอนเทนเนอร์แบบสัมพันธ์และตัวชี้อัจฉริยะ

ภาพรวม: บทเรียนนี้ครอบคลุมมาตรฐาน C++11 สำหรับคอนเทนเนอร์แบบสัมพันธ์และการจัดการหน่วยความจำแบบไดนามิก บทเรียนอธิบายการใช้คอนเทนเนอร์ที่จัดเรียงและไม่จัดเรียงเพื่อการค้นหาที่มีประสิทธิภาพตามคีย์ และการสร้างโค้ดที่ทนทานและปลอดภัยต่อข้อผิดพลาดโดยใช้ตัวชี้อัจฉริยะ (smart pointers) บทเรียนสิ้นสุดด้วยการออกแบบแอปพลิเคชัน Text-Query จริงที่รวมโครงสร้างข้อมูลที่ซับซ้อนเหล่านี้

ผลลัพธ์การเรียนรู้:

• ใช้และจัดการคอนเทนเนอร์แบบสัมพันธ์โดยใช้เทคนิคการค้นหา การแทรก และการเข้าถึงโดยดัชนีที่มีประสิทธิภาพ
• ควบคุมการจัดการหน่วยความจำแบบไดนามิกโดยเปลี่ยนจาก new/delete แบบดั้งเดิมไปสู่ตัวชี้อัจฉริยะที่ใช้ RAII และคลาส allocator
• ออกแบบระบบที่ซับซ้อนที่แบ่งปันข้อมูลอย่างปลอดภัยระหว่างคลาสโดยใช้การนับการอ้างอิงและการครอบครองของตัวชี้อัจฉริยะ

🔹 บทเรียนที่ 16: การจัดการทรัพยากรและกลไกการย้าย

ภาพรวม: บทเรียนนี้สำรวจวิธีที่คลาส C++ ควบคุมวงจรชีวิตทรัพยากรผ่าน "Big Five" ฟังก์ชันพิเศษ นักเรียนจะเรียนรู้การจัดการหน่วยความจำแบบไดนามิกโดยใช้กลยุทธ์แบบค่าและแบบตัวชี้ ใช้แนวทางการคัดลอกและแลกเปลี่ยนที่ปลอดภัยต่อข้อผิดพลาด และเพิ่มประสิทธิภาพโดยใช้กลไกการย้าย (move semantics) และ rvalue references ของ C++11

ผลลัพธ์การเรียนรู้:

• ใช้และอธิบายกฎของ Three/Five อย่างถูกต้องเพื่อให้มั่นใจการจัดการทรัพยากรและป้องกันการรั่วไหลของหน่วยความจำ
• แยกความแตกต่างระหว่างพฤติกรรมคลาสแบบค่าและแบบตัวชี้ และใช้การนับการอ้างอิง
• ใช้การย้าย (move semantics) โดยใช้ rvalue references และ std::move เพื่อตัดการคัดลอกลึกที่ไม่จำเป็นของวัตถุขนาดใหญ่

🔹 บทเรียนที่ 17: การโอเวอร์โหลดตัวดำเนินการและสืบทอด (OOP)

ภาพรวม: บทเรียนนี้สำรวจการขยายไวยากรณ์ของภาษาผ่านการโอเวอร์โหลดตัวดำเนินการ และการสร้างระบบที่ขยายได้ผ่านการเขียนโปรแกรมเชิงวัตถุ (OOP) นักเรียนจะเรียนรู้การสร้างคลาสที่รวมกับการดำเนินการในตัว และเรียนรู้กลไกการสืบทอด การผูกพันแบบไดนามิก และโครงสร้างคลาสที่มีพหุภาค (polymorphic class hierarchies)

ผลลัพธ์การเรียนรู้:

• ออกแบบและใช้ตัวดำเนินการที่ถูกโอเวอร์โหลดให้สอดคล้องกับแนวทางไลบรารีมาตรฐานของ C++
• สร้างและใช้ object ฟังก์ชัน และ wrapper ประเภท function เพื่อรวมวัตถุที่สามารถเรียกใช้ได้
• สร้างโครงสร้างคลาสที่มั่นคงโดยใช้ virtual functions, abstract base classes, และ specifier การเข้าถึง C++11

🔹 บทเรียนที่ 18: เทมเพลตและโปรแกรมเชิงทั่วไป

ภาพรวม: บทเรียนนี้ครอบคลุมกลไกพื้นฐานและขั้นสูงของเทมเพลตในภาษา C++ ซึ่งเป็นพื้นฐานของการเขียนโปรแกรมเชิงทั่วไป นักเรียนจะเรียนรู้ตั้งแต่การกำหนดเทมเพลตฟังก์ชันและเทมเพลตคลาสพื้นฐาน ไปจนถึงการควบคุมคุณสมบัติเฉพาะ C++11 เช่น variadic templates, perfect forwarding, และ template specialization

ผลลัพธ์การเรียนรู้:

• กำหนดและใช้เทมเพลตฟังก์ชันและเทมเพลตคลาสโดยใช้ทั้งพารามิเตอร์ชนิดและไม่ใช่ชนิด
• จัดการโมเดลการคอมไพล์เทมเพลต และควบคุมการสร้างออบเจกต์ในหลายไฟล์โดยใช้ extern template
• ใช้เทคนิคการอนุมานขั้นสูง รวมถึงการระบุประเภทผลลัพธ์แบบท้าย และ perfect forwarding ด้วย std::forward

🔹 บทเรียนที่ 19: เครื่องมือไลบรารีเฉพาะและระบบขนาดใหญ่

ภาพรวม: บทเรียนนี้ครอบคลุมส่วนประกอบขั้นสูงของไลบรารีมาตรฐาน C++11 และคุณสมบัติของภาษาที่ออกแบบมาเพื่อการพัฒนาโปรแกรมระบบซับซ้อน ครอบคลุมโครงสร้างข้อมูลเฉพาะ รูปแบบการจับคู่ที่แข็งแรงผ่านไลบรารี regex และเครื่องมือสถาปัตยกรรมสำหรับการเขียนโปรแกรมระดับใหญ่ บทเรียนยังสำรวจการจัดการข้อผิดพลาดขั้นสูง การจัดการชื่อพื้นที่ และความซับซ้อนของการสืบทอดหลายชั้น

ผลลัพธ์การเรียนรู้:

• ใช้ tuple เพื่อส่งค่ากลับหลายค่า และ bitset เพื่อจัดการแฟล็กระดับบิตอย่างมีประสิทธิภาพ
• ใช้ไลบรารี regex เพื่อจับคู่ ตรวจสอบ และแปลงสตริงที่ซับซ้อน
• สร้างเลขสุ่มคุณภาพสูงโดยใช้ engine และ distribution พร้อมรักษาสถานะและ seed อย่างถูกต้อง