ข้อบกพร่องของหน่วยความจำที่พบบ่อย
หลีกเลี่ยงหน่วยความจำรั่วและพอยน์เตอร์ลอย
ข้อบกพร่องของหน่วยความจำที่พบบ่อย เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน
หน่วยความจำรั่ว
หน่วยความจำรั่วเกิดขึ้นเมื่อมีการจัดสรรหน่วยความจำบนฮีปแต่ไม่เคยคืนหน่วยความจำนั้น โปรแกรมจะยังคงใช้หน่วยความจำที่ไม่สามารถเข้าถึงได้อีกต่อไป
void leak() {
int* p = new int(5);
// missing delete p; -> leaked
}ตัวชี้ห้อยค้าง
ตัวชี้ห้อยค้างชี้ไปยังหน่วยความจำที่ถูกคืนไปแล้ว การเข้าถึงค่าผ่านตัวชี้ดังกล่าวเป็นพฤติกรรมที่ไม่ได้กำหนดไว้
int* p = new int(7);
delete p;
// *p = 3; // BUG: dangling accessการคืนหน่วยความจำซ้ำ
การเรียกใช้ delete สองครั้งกับตัวชี้เดียวกันจะทำให้ฮีปเสียหายและมักทำให้โปรแกรมหยุดทำงาน
int* p = new int(1);
delete p;
// delete p; // BUG: double freeการใช้งานหลังคืนหน่วยความจำ
การอ่านหรือเขียนผ่านตัวชี้หลังจากออบเจ็กต์ถูกลบแล้วเรียกว่าการใช้งานหลังคืนหน่วยความจำ ซึ่งเป็นสาเหตุที่พบได้บ่อยของช่องโหว่ด้านความปลอดภัย
Buffer ล้น
การเขียนเลยจุดสิ้นสุดของอาร์เรย์จะเขียนทับหน่วยความจำที่ไม่เกี่ยวข้อง โปรดทำงานภายในขอบเขตเสมอ
int a[3] = {1, 2, 3};
// a[3] = 99; // BUG: out of boundsการใช้ delete ไม่ตรงคู่
การใช้ delete กับการจัดสรรด้วย new[] (หรือใช้ในทางกลับกัน) เป็นพฤติกรรมที่ไม่ได้กำหนดไว้ โปรดใช้ทั้งสองอย่างเป็นคู่กัน
int* arr = new int[4];
// delete arr; // BUG: should be delete[] arr;
delete[] arr; // correctตัวชี้ที่ยังไม่ได้กำหนดค่า
ตัวชี้ที่ยังไม่ได้กำหนดค่าจะเก็บข้อมูลที่ไม่มีความหมาย โปรดกำหนดค่าเริ่มต้นให้เป็นที่อยู่ที่ถูกต้องหรือ nullptr เสมอ
#include <iostream>
int main() {
int* p = nullptr; // safe default
if (!p) std::cout << "not set\n";
}การคืนที่อยู่ของตัวแปรภายใน
การคืนที่อยู่ของตัวแปรภายในบนสแตกจะสร้างตัวชี้ห้อยค้างขึ้นมาทันที เนื่องจากตัวแปรภายในจะสิ้นอายุการใช้งานเมื่อฟังก์ชันคืนค่า
int* bad() {
int x = 10;
return &x; // BUG: x is gone
}ตัวชี้อัจฉริยะป้องกันหน่วยความจำรั่ว
การแทนที่ตัวจัดการหน่วยความจำแบบดิบด้วย std::unique_ptr จะกำจัดการรั่วไหลและการคืนหน่วยความจำซ้ำส่วนใหญ่ เพราะการล้างหน่วยความจำจะเกิดขึ้นโดยอัตโนมัติและเพียงครั้งเดียว
#include <iostream>
#include <memory>
int main() {
auto p = std::make_unique<int>(5);
std::cout << *p << "\n";
} // freed exactly once, automaticallyเครื่องมือค้นหาข้อผิดพลาด
เครื่องมืออย่าง AddressSanitizer และวาลกรินด์สามารถตรวจจับหน่วยความจำรั่ว การคืนหน่วยความจำซ้ำ และการเข้าถึงนอกขอบเขตขณะโปรแกรมทำงาน โปรดผนวกเครื่องมือเหล่านี้ไว้ในกระบวนการทดสอบ
การป้องกันดีกว่าการตรวจจับ
วิธีแก้ไขที่ดีที่สุดคือหลีกเลี่ยงการเป็นเจ้าของหน่วยความจำแบบดิบโดยสิ้นเชิง โปรดใช้โครงสร้างจัดเก็บอย่าง std::vector และตัวชี้อัจฉริยะ เพื่อให้ไลบรารีจัดการหน่วยความจำอย่างถูกต้องให้คุณ
ตรวจสอบความเข้าใจอย่างรวดเร็ว
โปรดทดสอบความเข้าใจเรื่องข้อผิดพลาดของหน่วยความจำ
สรุปทบทวน
คุณได้เรียนรู้ข้อผิดพลาดของหน่วยความจำที่พบบ่อย ได้แก่ หน่วยความจำรั่ว ตัวชี้ห้อยค้าง การคืนหน่วยความจำซ้ำ การใช้งานหลังคืนหน่วยความจำ การเขียนเกินบัฟเฟอร์ และการใช้ delete ไม่ตรงคู่ โปรดป้องกันข้อผิดพลาดเหล่านี้ด้วยตัวชี้อัจฉริยะและโครงสร้างจัดเก็บ และใช้เครื่องมือตรวจสอบหน่วยความจำกับวาลกรินด์ค้นหาข้อผิดพลาดที่เหลือ
คำถามที่พบบ่อย
บทเรียน “ข้อบกพร่องของหน่วยความจำที่พบบ่อย” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ข้อบกพร่องของหน่วยความจำที่พบบ่อย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ข้อบกพร่องของหน่วยความจำที่พบบ่อย”
หลีกเลี่ยงหน่วยความจำรั่วและพอยน์เตอร์ลอย คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “ข้อบกพร่องของหน่วยความจำที่พบบ่อย” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม
ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การจัดสรรบนสแตก
- การจัดสรรบนฮีพด้วย new/delete
- อายุการใช้งานของออบเจกต์
- ข้อบกพร่องของหน่วยความจำที่พบบ่อย