การตั้งค่าตัวแปรเป็น NULL หลังจากว่าง

ใน บริษัท ของฉันมีกฎการเข้ารหัสที่บอกว่าหลังจากพ้นหน่วยความจำใด ๆ NULLตั้งค่าตัวแปร ตัวอย่างเช่น ...

void some_func () 
{
    int *nPtr;

    nPtr = malloc (100);

    free (nPtr);
    nPtr = NULL;

    return;
}

ฉันรู้สึกว่าในกรณีเช่นรหัสที่แสดงด้านบนการตั้งค่าเป็นNULLไม่มีความหมายใด ๆ หรือว่าฉันขาดอะไรไป?

หากไม่มีความหมายในกรณีเช่นนี้ฉันจะดำเนินการกับ "ทีมคุณภาพ" เพื่อลบกฎการเข้ารหัสนี้ โปรดให้คำแนะนำ.

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

สำหรับตัวแปรท้องถิ่นอาจไม่มีประโยชน์สักเล็กน้อยหากเห็นว่า "ชัดเจน" ว่าตัวชี้ไม่สามารถเข้าถึงได้อีกต่อไปหลังจากถูกปล่อยให้ว่างดังนั้นรูปแบบนี้เหมาะสมกว่าสำหรับข้อมูลสมาชิกและตัวแปรทั่วโลก แม้ว่าตัวแปรโลคัลอาจเป็นวิธีที่ดีถ้าฟังก์ชันยังคงดำเนินต่อไปหลังจากที่ปล่อยหน่วยความจำ

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

การตั้งตัวชี้เป็นNULLหลังจากfreeนั้นเป็นวิธีปฏิบัติที่น่าสงสัยที่มักได้รับความนิยมในฐานะกฎ "โปรแกรมที่ดี" ในสถานที่ที่ผิดพลาดจริง ๆ มันเป็นหนึ่งในความจริงปลอมที่อยู่ในหมวดหมู่ "ฟังดูถูก" แต่ในความเป็นจริงแล้วไม่มีอะไรที่เป็นประโยชน์จริง ๆ (และบางครั้งนำไปสู่ผลกระทบด้านลบ)

ถูกกล่าวหาว่าการตั้งค่าตัวชี้เป็นNULLหลังจากfreeควรป้องกันปัญหา "ฟรีสองเท่า" ที่น่าสะพรึงกลัวเมื่อค่าตัวชี้เดียวกันถูกส่งไปยังfreeมากกว่าหนึ่งครั้ง ในความเป็นจริงแม้ว่าใน 9 รายจาก 10 จริง "คู่ฟรี" ปัญหาเกิดขึ้นเมื่อที่แตกต่างกันfreeตัวชี้วัตถุถือค่าตัวชี้เดียวกันจะใช้เป็นข้อโต้แย้ง จำเป็นต้องพูดการตั้งค่าตัวชี้ไปNULLหลังจากทำfreeอะไรอย่างเพื่อป้องกันปัญหาในกรณีดังกล่าว

แน่นอนว่ามันเป็นไปได้ที่จะใช้เป็น "คู่ฟรี" freeปัญหาเมื่อใช้วัตถุชี้เช่นเดียวกับข้อโต้แย้งไปยัง อย่างไรก็ตามในสถานการณ์ความเป็นจริงเช่นนั้นโดยปกติจะบ่งบอกถึงปัญหากับโครงสร้างเชิงตรรกะทั่วไปของรหัสไม่ใช่แค่ "double free" โดยไม่ได้ตั้งใจ วิธีที่เหมาะสมในการจัดการกับปัญหาในกรณีเช่นนี้คือการทบทวนและทบทวนโครงสร้างของรหัสใหม่เพื่อหลีกเลี่ยงสถานการณ์เมื่อตัวชี้เดียวกันถูกส่งไปยังfreeมากกว่าหนึ่งครั้ง ในกรณีเช่นนี้การตั้งค่าตัวชี้NULLและการพิจารณาปัญหา "แก้ไข" คืออะไรมากกว่าความพยายามกวาดปัญหาใต้พรม มันจะไม่ทำงานในกรณีทั่วไปเพราะปัญหาเกี่ยวกับโครงสร้างรหัสมักจะหาวิธีอื่นในการเปิดเผยตัวเอง

สุดท้ายหากรหัสของคุณได้รับการออกแบบมาโดยเฉพาะเพื่อพึ่งพาเป็นค่าตัวชี้NULLหรือไม่NULLก็เป็นอย่างดีปรับการตั้งค่าตัวชี้ไปหลังจากNULL freeแต่ตามกฎทั่วไป "การปฏิบัติที่ดี" (เช่นเดียวกับใน "ตั้งค่าตัวชี้ของคุณเป็นNULLหลังfree") มันเป็นของปลอมที่รู้จักกันดีและไร้ประโยชน์อีกครั้งตามมาด้วยเหตุผลบางประการทางศาสนาเช่นเดียวกับลัทธิวูดู

การตอบสนองส่วนใหญ่มุ่งเน้นไปที่การป้องกันการเป็นอิสระสองเท่า แต่การตั้งค่าตัวชี้เป็น NULL มีประโยชน์อื่น เมื่อคุณเพิ่มพอยน์เตอร์แล้วหน่วยความจำนั้นจะถูกจัดสรรใหม่โดยการเรียกไปที่ malloc อื่น หากคุณยังมีตัวชี้ดั้งเดิมอยู่รอบ ๆ คุณอาจท้ายด้วยบั๊กที่คุณพยายามใช้ตัวชี้หลังจากตัวแปรอื่นฟรีและทำให้เสียหายและเสียหายจากนั้นโปรแกรมของคุณเข้าสู่สถานะที่ไม่รู้จักและสิ่งเลวร้ายทุกประเภทอาจเกิดขึ้นได้ โชคดีที่ข้อมูลเสียหายถ้าคุณโชคไม่ดี) หากคุณตั้งค่าตัวชี้เป็น NULL หลังจากว่างความพยายามใด ๆ ในการอ่าน / เขียนผ่านตัวชี้นั้นในภายหลังจะส่งผลให้เกิด segfault ซึ่งโดยทั่วไปแล้วจะดีกว่าหากหน่วยความจำแบบสุ่มเสียหาย

ด้วยเหตุผลทั้งสองมันเป็นความคิดที่ดีที่จะตั้งค่าตัวชี้เป็น NULL หลังจากว่าง () แม้ว่ามันจะไม่จำเป็นเสมอไป ตัวอย่างเช่นถ้าตัวแปรพอยเตอร์ออกนอกขอบเขตทันทีหลังจากฟรี () ไม่มีเหตุผลอะไรมากที่จะตั้งค่าเป็น NULL

นี่ถือเป็นแนวปฏิบัติที่ดีเพื่อหลีกเลี่ยงการเขียนทับหน่วยความจำ ในฟังก์ชั่นด้านบนมันไม่จำเป็น แต่บ่อยครั้งเมื่อมันทำมันสามารถค้นหาข้อผิดพลาดของแอปพลิเคชัน

ลองทำสิ่งนี้แทน:

#if DEBUG_VERSION
void myfree(void **ptr)
{
    free(*ptr);
    *ptr = NULL;
}
#else
#define myfree(p) do { void ** __p = (p); free(*(__p)); *(__p) = NULL; } while (0)
#endif

DEBUG_VERSION ช่วยให้โปรไฟล์ของคุณเป็นอิสระในการดีบักโค้ด แต่ทั้งสองแบบนั้นมีฟังก์ชั่นเหมือนกัน

แก้ไข : เพิ่มทำ ... ในขณะที่แนะนำด้านล่างขอบคุณ

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

หากคุณตั้งค่าตัวชี้เป็น NULL ถ้าคุณเข้าถึงตัวชี้โปรแกรมจะขัดข้องด้วย segfault ไม่อีกต่อไปบางครั้งก็ใช้งานได้ '' ไม่เกิน ,, ล่มในลักษณะที่ไม่สามารถคาดเดาได้ '' วิธีแก้ข้อบกพร่องง่ายขึ้น

การตั้งค่าตัวชี้ไปยังfreeหน่วยความจำ 'd หมายความว่าการพยายามเข้าถึงหน่วยความจำนั้นผ่านตัวชี้จะล้มเหลวทันทีแทนที่จะทำให้เกิดพฤติกรรมที่ไม่ได้กำหนด มันทำให้ง่ายขึ้นมากในการพิจารณาว่าสิ่งใดผิดพลาด

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

อาจเป็นไปได้ว่ามีการระบุกฎโดยไม่แยกความแตกต่างระหว่างสองกรณีนี้เนื่องจากเป็นการยากที่จะบังคับใช้กฎโดยอัตโนมัติ มันไม่เจ็บที่จะตั้งค่าพอยน์เตอร์ให้เป็นNULLอิสระ แต่มันมีศักยภาพที่จะชี้ปัญหาใหญ่ ๆ

ข้อผิดพลาดที่พบบ่อยที่สุดใน c คือฟรีสองครั้ง โดยทั่วไปคุณทำอะไรแบบนั้น

free(foobar);
/* lot of code */
free(foobar);

และท้ายที่สุดมันก็แย่มาก OS พยายามที่จะเพิ่มหน่วยความจำที่ว่างแล้ว ดังนั้นวิธีปฏิบัติที่ดีคือการตั้งค่าเพื่อNULLให้คุณสามารถทำการทดสอบและตรวจสอบว่าคุณจำเป็นต้องเพิ่มหน่วยความจำนี้หรือไม่

if(foobar != null){
  free(foobar);
}

ที่จะต้องสังเกตด้วยว่าfree(NULL)จะไม่ทำอะไรดังนั้นคุณไม่จำเป็นต้องเขียนคำสั่ง if ฉันไม่ได้เป็นกูรูด้านระบบปฏิบัติการจริงๆ แต่ฉันก็ยังสวยอยู่ดีตอนนี้ระบบปฏิบัติการส่วนใหญ่จะใช้งานฟรีสองเท่า

นั่นเป็นเหตุผลหลักว่าทำไมทุกภาษาที่มีการรวบรวมขยะ (Java, dotnet) ภูมิใจอย่างมากที่ไม่มีปัญหานี้และไม่ต้องออกจากการจัดการหน่วยความจำโดยรวม

แนวคิดเบื้องหลังนี้คือการหยุดการนำตัวชี้อิสระกลับมาใช้ซ้ำโดยไม่ได้ตั้งใจ

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

หากคุณปล่อยให้ตัวชี้ NULL แล้วความพยายามใด ๆ ที่จะใช้มันจะไป 0x0 dereference และความผิดพลาดที่นั่นซึ่งเป็นเรื่องง่ายที่จะแก้ปัญหา พอยน์เตอร์แบบสุ่มที่ชี้ไปยังหน่วยความจำแบบสุ่มนั้นยากที่จะทำการดีบัก เห็นได้ชัดว่าไม่จำเป็น แต่ก็เป็นเหตุผลว่าทำไมมันถึงอยู่ในเอกสารแนวปฏิบัติที่ดีที่สุด

จากมาตรฐาน ANSI C:

void free(void *ptr);

ฟังก์ชั่นฟรีทำให้พื้นที่ที่ชี้ไปโดย ptr ถูกจัดสรรคืนนั่นคือทำให้พร้อมสำหรับการจัดสรรเพิ่มเติม ถ้า ptr เป็นตัวชี้ null จะไม่มีการดำเนินการใด ๆ เกิดขึ้น มิฉะนั้นหากอาร์กิวเมนต์ไม่ตรงกับตัวชี้ที่ส่งคืนก่อนหน้านี้โดยฟังก์ชัน calloc, malloc หรือ realloc หรือหากพื้นที่ถูกจัดสรรคืนโดยการเรียกเพื่อให้ว่างหรือ realloc พฤติกรรมจะไม่ได้กำหนดไว้

"พฤติกรรมที่ไม่ได้กำหนด" มักจะเป็นความผิดพลาดของโปรแกรม เพื่อหลีกเลี่ยงปัญหานี้จะปลอดภัยในการรีเซ็ตตัวชี้เป็น NULL free () ตัวเองไม่สามารถทำสิ่งนี้ได้เนื่องจากมันถูกส่งผ่านเพียงตัวชี้ไม่ใช่ตัวชี้ไปยังตัวชี้ คุณยังสามารถเขียนรุ่นที่ปลอดภัยกว่าได้ฟรี () ซึ่งตัวชี้ NULLs:

void safe_free(void** ptr)
{
  free(*ptr);
  *ptr = NULL;
}

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

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

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

รูปแบบที่พบบ่อยคือการตั้งค่าทุกตัวชี้สมาชิกของเว็บไซต์เพื่อโมฆะในตัวสร้างและมีการโทร destructor ลบเกี่ยวกับตัวชี้ใด ๆ เพื่อให้ข้อมูลว่าการออกแบบของคุณว่าชั้นเรียนที่เป็นเจ้าของ ชัดเจนในกรณีนี้คุณต้องตั้งค่าตัวชี้เป็น NULL เมื่อคุณลบบางสิ่งเพื่อระบุว่าคุณไม่ได้เป็นเจ้าของข้อมูลใด ๆ มาก่อน

ดังนั้นเพื่อสรุปใช่ฉันมักจะตั้งตัวชี้ไปที่ NULL หลังจากลบบางสิ่งบางอย่าง แต่มันเป็นส่วนหนึ่งของการออกแบบที่มีขนาดใหญ่ขึ้นและความคิดเกี่ยวกับผู้ที่เป็นเจ้าของข้อมูลมากกว่าเนื่องจากการสุ่มสี่สุ่มห้าตามกฎมาตรฐานการเข้ารหัส ฉันจะไม่ทำเช่นนั้นในตัวอย่างของคุณเพราะฉันคิดว่าไม่มีประโยชน์ที่จะทำเช่นนั้นและมันเพิ่ม "ความยุ่งเหยิง" ซึ่งในประสบการณ์ของฉันมีหน้าที่รับผิดชอบต่อข้อผิดพลาดและรหัสที่ไม่ดีเช่นเดียวกับสิ่งนี้

เมื่อเร็ว ๆ นี้ฉันเจอคำถามเดียวกันหลังจากหาคำตอบ ฉันมาถึงข้อสรุปนี้:

เป็นการปฏิบัติที่ดีที่สุดและต้องปฏิบัติตามสิ่งนี้เพื่อให้สามารถพกพาได้ในทุกระบบ (ฝังตัว)

free()เป็นฟังก์ชันไลบรารีซึ่งแตกต่างกันไปตามการเปลี่ยนแปลงของแพลตฟอร์มดังนั้นคุณไม่ควรคาดหวังว่าหลังจากผ่านตัวชี้ไปยังฟังก์ชันนี้และหลังจากพ้นหน่วยความจำแล้วตัวชี้นี้จะถูกตั้งค่าเป็น NULL อาจไม่เป็นเช่นนั้นสำหรับบางไลบรารีที่ใช้งานกับแพลตฟอร์ม

ไปเพื่อเสมอ

free(ptr);
ptr = NULL;

กฎนี้มีประโยชน์เมื่อคุณพยายามหลีกเลี่ยงสถานการณ์ต่อไปนี้:

1) คุณมีฟังก์ชั่นที่ยาวมาก ๆ พร้อมตรรกะที่ซับซ้อนและการจัดการหน่วยความจำและคุณไม่ต้องการใช้ตัวชี้ซ้ำเพื่อลบหน่วยความจำในภายหลังโดยไม่ตั้งใจ

2) ตัวชี้เป็นตัวแปรสมาชิกของคลาสที่มีพฤติกรรมที่ค่อนข้างซับซ้อนและคุณไม่ต้องการใช้ตัวชี้ซ้ำเพื่อลบหน่วยความจำในฟังก์ชันอื่นโดยไม่ตั้งใจ

ในสถานการณ์ของคุณมันไม่สมเหตุสมผลเลย แต่ถ้าฟังก์ชั่นใช้งานได้นานขึ้นมันอาจจะสำคัญ

คุณอาจยืนยันว่าการตั้งค่าเป็น NULL อาจซ่อนความผิดพลาดเชิงตรรกะในภายหลังหรือในกรณีที่คุณคิดว่ามันถูกต้องคุณยังคงผิดพลาดใน NULL ดังนั้นจึงไม่สำคัญ

โดยทั่วไปฉันจะแนะนำให้คุณตั้งเป็น NULL เมื่อคุณคิดว่ามันเป็นความคิดที่ดีและไม่ต้องกังวลเมื่อคุณคิดว่ามันไม่คุ้มค่า มุ่งเน้นไปที่การเขียนฟังก์ชั่นสั้น ๆ และคลาสที่ออกแบบมาอย่างดีแทน

เพื่อเพิ่มสิ่งที่คนอื่นพูดวิธีการที่ดีอย่างหนึ่งของการใช้งานตัวชี้คือการตรวจสอบเสมอว่าเป็นตัวชี้ที่ถูกต้องหรือไม่ สิ่งที่ต้องการ:

if(ptr)
   ptr->CallSomeMethod();

ทำเครื่องหมายตัวชี้อย่างชัดเจนว่าเป็น NULL หลังจากปล่อยให้ใช้งานได้ใน C / C ++

นี่อาจเป็นข้อโต้แย้งในการเริ่มต้นพอยน์เตอร์ทั้งหมดให้เป็น NULL แต่สิ่งที่เป็นเช่นนี้อาจเป็นข้อผิดพลาดลับๆล่อๆ:

void other_func() {
  int *p; // forgot to initialize
  // some unrelated mallocs and stuff
  // ...
  if (p) {
    *p = 1; // hm...
  }
}

void caller() {
  some_func();
  other_func();
}

pสิ้นสุดในตำแหน่งเดียวกันบนสแต็กเหมือนอดีตnPtrดังนั้นจึงอาจยังคงมีตัวชี้ที่ใช้ได้ การมอบหมายให้*pอาจเขียนทับสิ่งที่ไม่เกี่ยวข้องทุกประเภทและนำไปสู่ข้อบกพร่องที่น่าเกลียด โดยเฉพาะอย่างยิ่งหากคอมไพเลอร์เริ่มต้นตัวแปรท้องถิ่นด้วยศูนย์ในโหมดดีบัก แต่ไม่ได้เปิดใช้งานการปรับให้เหมาะสมที่สุด ดังนั้นการสร้าง debug จะไม่แสดงสัญญาณของบั๊กในขณะที่ release builds ระเบิดขึ้นแบบสุ่ม ...

การตั้งค่าตัวชี้ที่เพิ่งถูกปลดปล่อยให้เป็น NULL นั้นไม่ใช่ข้อบังคับ แต่เป็นแนวปฏิบัติที่ดี ด้วยวิธีนี้คุณสามารถหลีกเลี่ยง 1) โดยใช้การชี้อิสระ 2) ปล่อยให้เป็นอิสระ

การตั้งค่าตัวชี้ไปที่ NULL คือการปกป้อง agains ที่เรียกว่า double-free - สถานการณ์เมื่อ free () ถูกเรียกมากกว่าหนึ่งครั้งสำหรับที่อยู่เดียวกันโดยไม่ต้องจัดสรรบล็อกใหม่ที่ที่อยู่นั้น

ฟรีสองครั้งนำไปสู่พฤติกรรมที่ไม่ได้กำหนด - โดยปกติกองการทุจริตหรือหยุดทำโปรแกรมทันที โทรฟรี () สำหรับตัวชี้ NULL ไม่ทำอะไรเลยและรับประกันได้ว่าปลอดภัย

ดังนั้นแนวปฏิบัติที่ดีที่สุดเว้นแต่คุณจะแน่ใจว่าตัวชี้ออกจากขอบเขตทันทีหรือในไม่ช้าหลังจาก free () คือการตั้งตัวชี้นั้นเป็น NULL ดังนั้นแม้ว่า free () จะถูกเรียกอีกครั้งตอนนี้จะถูกเรียกสำหรับตัวชี้ NULL และพฤติกรรมที่ไม่ได้กำหนด หลบเลี่ยง

แนวคิดคือถ้าคุณพยายามอ้างถึงตัวชี้ที่ไม่ถูกต้องอีกต่อไปหลังจากปล่อยให้เป็นอิสระคุณต้องการล้มเหลวอย่างหนัก (segfault) แทนที่จะเงียบและลึกลับ

แต่ ... ระวังตัวด้วย ไม่ใช่ทุกระบบที่ทำให้เกิด segfault ถ้าคุณยกเลิกการอ้างอิง NULL บน (อย่างน้อยบางเวอร์ชัน) AIX, * (int *) 0 == 0 และ Solaris มีความเข้ากันได้กับคุณลักษณะ "AIX" นี้เป็นทางเลือก

สำหรับคำถามเดิม: การตั้งค่าตัวชี้เป็น NULL โดยตรงหลังจากการปล่อยเนื้อหาเป็นการเสียเวลาอย่างสมบูรณ์หากรหัสตรงตามข้อกำหนดทั้งหมดจะถูกดีบั๊กอย่างสมบูรณ์และจะไม่ถูกแก้ไขอีกครั้ง ในทางกลับกัน NULL การป้องกันตัวชี้ที่ได้รับการปลดปล่อยจะมีประโยชน์มากเมื่อมีคนคิดเพิ่มบล็อกใหม่ของรหัสภายใต้ฟรี () เมื่อการออกแบบของโมดูลดั้งเดิมไม่ถูกต้องและในกรณีของมัน -compiles-but-not-do-what-I-want bugs

ไม่ว่าในระบบใดมีเป้าหมายที่ไม่สามารถหาสิ่งที่ถูกได้ง่ายที่สุดและค่าใช้จ่ายที่ไม่สามารถลดลงได้ของการวัดที่ไม่ถูกต้อง ใน C เรามีชุดเครื่องมือที่คมชัดและแข็งแกร่งมากซึ่งสามารถสร้างสิ่งต่าง ๆ ในมือของช่างฝีมือและทำดาเมจทุกประเภทของการบาดเจ็บเชิงเปรียบเทียบเมื่อจัดการอย่างไม่เหมาะสม บางอย่างยากที่จะเข้าใจหรือใช้อย่างถูกต้อง และผู้คนที่ไม่ชอบความเสี่ยงตามธรรมชาติทำสิ่งที่ไม่มีเหตุผลเช่นการตรวจสอบตัวชี้ค่า NULL ก่อนโทรฟรีด้วย ...

ปัญหาการวัดคือเมื่อใดก็ตามที่คุณพยายามแบ่งสิ่งที่ดีจากความดีที่น้อยกว่ายิ่งมีความซับซ้อนมากเท่าใดคุณก็ยิ่งมีความชัดเจนมากขึ้นเท่านั้น หากเป้าหมายเป็นเพียงการปฏิบัติที่ดีแล้วบางคนก็มีความคลุมเครือที่จะถูกโยนออกไปด้วยสิ่งที่ไม่ดี หากเป้าหมายของคุณคือกำจัดสิ่งไม่ดีออกไปความคลุมเครืออาจอยู่กับความดี เป้าหมายสองข้อนั้นรักษาได้ดีหรือกำจัดสิ่งที่ไม่ดีอย่างเห็นได้ชัดซึ่งดูเหมือนว่าจะถูกต่อต้านแบบ diametrically แต่โดยทั่วไปจะมีกลุ่มที่สามที่ไม่ใช่ทั้งสองกลุ่มและบางกลุ่ม

ก่อนที่คุณจะทำเรื่องกับแผนกคุณภาพให้ลองตรวจสอบฐานข้อมูลบั๊กเพื่อดูว่าค่าตัวชี้ที่ไม่ถูกต้องเกิดขึ้นบ่อยเพียงใดหากเคยเกิดปัญหาที่ต้องจดบันทึกไว้ หากคุณต้องการสร้างความแตกต่างที่แท้จริงระบุปัญหาที่พบบ่อยที่สุดในรหัสการผลิตของคุณและเสนอสามวิธีในการป้องกัน

มีสองเหตุผล:

หลีกเลี่ยงการล่มเมื่อปล่อยสองครั้ง

เขียนโดยRageZในคำถามที่ซ้ำกัน

ข้อผิดพลาดที่พบบ่อยที่สุดใน c คือฟรีสองครั้ง โดยทั่วไปคุณทำอะไรแบบนั้น

free(foobar);
/* lot of code */
free(foobar);

และท้ายที่สุดมันก็แย่มาก OS พยายามที่จะเพิ่มหน่วยความจำที่ว่างแล้ว ดังนั้นวิธีปฏิบัติที่ดีคือการตั้งค่าเพื่อNULLให้คุณสามารถทำการทดสอบและตรวจสอบว่าคุณจำเป็นต้องเพิ่มหน่วยความจำนี้หรือไม่

if(foobar != NULL){
  free(foobar);
}

ที่จะต้องสังเกตด้วยว่าfree(NULL) จะไม่ทำอะไรดังนั้นคุณไม่จำเป็นต้องเขียนคำสั่ง if ฉันไม่ได้เป็นกูรูด้านระบบปฏิบัติการจริงๆ แต่ฉันก็ยังสวยอยู่ดีตอนนี้ระบบปฏิบัติการส่วนใหญ่จะใช้งานฟรีสองเท่า

นั่นเป็นเหตุผลหลักว่าทำไมทุกภาษาที่มีการรวบรวมขยะ (Java, dotnet) ภูมิใจมากที่ไม่มีปัญหานี้และไม่ต้องออกไปพัฒนาการจัดการหน่วยความจำโดยรวม

หลีกเลี่ยงการใช้พอยน์เตอร์ที่เป็นอิสระแล้ว

เขียนโดยมาร์ติน v. Lowisในคำตอบอื่น

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

สำหรับตัวแปรท้องถิ่นอาจไม่มีประโยชน์สักเล็กน้อยหากเห็นว่า "ชัดเจน" ว่าตัวชี้ไม่สามารถเข้าถึงได้อีกต่อไปหลังจากถูกปล่อยให้ว่างดังนั้นรูปแบบนี้เหมาะสมกว่าสำหรับข้อมูลสมาชิกและตัวแปรทั่วโลก แม้ว่าตัวแปรโลคัลอาจเป็นวิธีที่ดีถ้าฟังก์ชันยังคงดำเนินต่อไปหลังจากที่ปล่อยหน่วยความจำ

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

ในขณะที่คุณมีทีมงานประกันคุณภาพให้ฉันเพิ่มประเด็นย่อยเกี่ยวกับ QA เครื่องมือ QA อัตโนมัติสำหรับ C จะตั้งค่าสถานะการมอบหมายให้แก่พอยน์เตอร์ที่เป็น "การมอบหมายที่ไร้ประโยชน์ptr " ตัวอย่างเช่น PC-lint / FlexeLint จาก Gimpel Software กล่าว tst.c 8 Warning 438: Last value assigned to variable 'nPtr' (defined at line 5) not used

มีวิธีการเลือกระงับข้อความเพื่อให้คุณสามารถตอบสนองความต้องการทั้งสองด้านได้หากทีมของคุณตัดสินใจ

ขอแนะนำให้ประกาศตัวแปรตัวชี้ด้วยNULLเช่น,

int *ptr = NULL;

สมมุติว่าptrชี้ไปยังที่อยู่หน่วยความจำ0x1000 หลังจากที่ใช้free(ptr)ก็มักจะแนะนำให้ลบล้างตัวแปรชี้ด้วยการประกาศอีกครั้งเพื่อเป็นโมฆะ เช่น:

free(ptr);
ptr = NULL;

ถ้าไม่ได้อีกครั้งประกาศให้เป็นโมฆะตัวแปรชี้ยังช่วยในการชี้ไปยังที่อยู่เดียวกัน ( 0x1000 ) ตัวแปรชี้นี้เรียกว่าตัวชี้ห้อยต่องแต่ง หากคุณกำหนดตัวแปรพอยน์เตอร์ตัวอื่น (สมมติว่าq ) และจัดสรรที่อยู่ให้กับตัวชี้ใหม่แบบไดนามิกอาจมีโอกาสที่จะใช้ที่อยู่เดียวกัน ( 0x1000 ) โดยตัวแปรตัวชี้ใหม่ หากในกรณีที่คุณใช้ตัวชี้ ( ptr ) เดียวกันและอัปเดตค่าตามที่อยู่ที่ชี้โดยตัวชี้เดียวกัน ( ptr ) จากนั้นโปรแกรมจะสิ้นสุดการเขียนค่าไปยังตำแหน่งที่qชี้ (ตั้งแต่pและqคือ ชี้ไปยังที่อยู่เดียวกัน (0x1000 ))

เช่น

*ptr = 20; //Points to 0x1000
free(ptr);
int *q = (int *)malloc(sizeof(int) * 2); //Points to 0x1000
*ptr = 30; //Since ptr and q are pointing to the same address, so the value of the address to which q is pointing would also change.

เรื่องสั้น ๆ สั้น ๆ : คุณไม่ต้องการเข้าถึงที่อยู่ที่คุณได้รับ (โดยไม่ได้ตั้งใจ) โดยไม่ตั้งใจ เนื่องจากเมื่อคุณเพิ่มที่อยู่คุณจึงอนุญาตให้ที่อยู่ดังกล่าวในฮีปได้รับการจัดสรรให้กับแอปพลิเคชันอื่น

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

เหตุใดฉันยังคงเข้าถึงตำแหน่งหน่วยความจำที่ฉันว่างได้ เนื่องจาก: คุณอาจมีหน่วยความจำว่าง แต่ตัวแปรตัวชี้ยังคงมีข้อมูลเกี่ยวกับที่อยู่หน่วยความจำฮีป ดังนั้นเป็นกลยุทธ์การป้องกันโปรดตั้งเป็น NULL