กำลังตรวจหาตัวชี้ NULL ใน C / C ++ [ปิด]

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

int * some_ptr;
// ...
if (some_ptr == NULL)
{
    // Handle null-pointer error
}
else
{
    // Proceed
}

แทน

int * some_ptr;
// ...
if (some_ptr)
{
    // Proceed
}
else
{
    // Handle null-pointer error
}

ฉันยอมรับว่าวิธีของเขาชัดเจนขึ้นเล็กน้อยในแง่ที่ว่าชัดเจนว่า "ตรวจสอบให้แน่ใจว่าตัวชี้นี้ไม่ใช่ NULL" แต่ฉันจะตอบโต้ด้วยการบอกว่าทุกคนที่ทำงานกับรหัสนี้จะเข้าใจว่าการใช้ตัวแปรตัวชี้ในคำสั่งการตรวจสอบโดยปริยายif NULLฉันรู้สึกว่าวิธีที่สองมีโอกาสน้อยกว่าในการแนะนำบั๊กของ ilk:

if (some_ptr = NULL)

ซึ่งเป็นเพียงความเจ็บปวดอย่างที่สุดในการค้นหาและแก้ไขข้อบกพร่อง

คุณชอบวิธีไหนและทำไม

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

แก้ไข: SoapBox ชี้ให้เห็นในความคิดเห็นพวกเขาเข้ากันได้กับคลาส C ++ เช่นauto_ptrที่เป็นวัตถุที่ทำหน้าที่เป็นตัวชี้และให้การแปลงboolเพื่อเปิดใช้งานสำนวนนี้ตรง สำหรับวัตถุเหล่านี้การเปรียบเทียบอย่างชัดเจนถึงNULLจะต้องเรียกใช้การแปลงไปยังตัวชี้ซึ่งอาจมีผลข้างเคียงเชิงความหมายอื่น ๆ หรือมีราคาแพงกว่าการตรวจสอบการมีอยู่อย่างง่ายที่การboolแปลงหมายถึง

ฉันมีการตั้งค่าสำหรับรหัสที่ระบุความหมายโดยไม่มีข้อความที่ไม่จำเป็น if (ptr != NULL)มีความหมายเหมือนกันif (ptr)แต่มีค่าใช้จ่ายเฉพาะเจาะจงซ้ำซ้อน สิ่งตรรกะถัดไปคือการเขียนif ((ptr != NULL) == TRUE)และวิธีการที่อยู่บ้า ภาษาซีเป็นที่ชัดเจนว่าการทดสอบโดยบูลif, whileหรือชอบมีความหมายเฉพาะที่ไม่ใช่ศูนย์ที่มีมูลค่าเป็นความจริงและเป็นศูนย์การเป็นเท็จ ความซ้ำซ้อนไม่ได้ทำให้ชัดเจน

if (foo)มีความชัดเจนเพียงพอ ใช้มัน.

ฉันจะเริ่มต้นด้วยสิ่งนี้: ความมั่นคงเป็นราชาการตัดสินใจมีความสำคัญน้อยกว่าความมั่นคงในรหัสฐานของคุณ

ใน C ++

NULL ถูกกำหนดเป็น 0 หรือ 0L ใน C ++

หากคุณอ่านภาษา C ++ Bjarne Stroustrup แนะนำให้ใช้0อย่างชัดเจนเพื่อหลีกเลี่ยงNULLมาโครเมื่อทำงานที่ได้รับมอบหมายฉันไม่แน่ใจว่าเขาทำแบบเดียวกันกับการเปรียบเทียบหรือไม่เพราะฉันอ่านหนังสือฉันคิดว่าเขาเพิ่งทำไปif(some_ptr)ไม่มีการเปรียบเทียบที่ชัดเจน แต่ฉันก็คลุมเครือ

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

โดยไม่คำนึงถึงความรู้สึกส่วนตัวนี่เป็นทางเลือกที่เลวร้ายที่สุดเนื่องจากไม่มีวิธีการที่ถูกต้อง

นี่เป็นเรื่องชัดเจนและเป็นสำนวนทั่วไปและฉันชอบมันไม่มีโอกาสที่จะกำหนดค่าโดยบังเอิญระหว่างการเปรียบเทียบและอ่านอย่างชัดเจน:

if(some_ptr){;}

สิ่งนี้ชัดเจนถ้าคุณรู้ว่าsome_ptrเป็นประเภทตัวชี้ แต่มันอาจดูเหมือนการเปรียบเทียบจำนวนเต็ม:

if(some_ptr != 0){;}

นี่คือชัดเจน - ish ในกรณีทั่วไปมันทำให้รู้สึก ... แต่มันเป็นนามธรรมรั่วNULLจริง ๆ แล้วมันเป็น0ตัวอักษรและท้ายที่สุดจะถูกนำมาใช้ในทางที่ผิดได้ง่าย:

if(some_ptr != NULL){;}

C ++ 0x มี nullptr ซึ่งตอนนี้เป็นวิธีที่ต้องการเนื่องจากชัดเจนและแม่นยำเพียงระวังการมอบหมายโดยไม่ตั้งใจ:

if(some_ptr != nullptr){;}

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

ในซี

C เป็นสัตว์ร้ายที่แตกต่างกัน

ใน C NULL สามารถกำหนดเป็น 0 หรือ ((void *) 0), C99 ช่วยให้การดำเนินการกำหนดค่าคงที่ตัวชี้โมฆะ ดังนั้นจริง ๆ แล้วมาลงความหมายของการใช้ NULL และคุณจะต้องตรวจสอบในไลบรารีมาตรฐานของคุณ

มาโครนั้นเป็นเรื่องที่พบได้ทั่วไปและโดยทั่วไปแล้วพวกเขาก็ใช้มันเป็นจำนวนมากเพื่อชดเชยข้อบกพร่องในการสนับสนุนการเขียนโปรแกรมทั่วไปในภาษาและสิ่งอื่น ๆ เช่นกัน ภาษานั้นง่ายกว่าและพึ่งพาพรีโปรเซสเซอร์มากขึ้น

จากมุมมองนี้ฉันอาจแนะนำให้ใช้NULLนิยามแมโครใน C

ฉันใช้if (ptr)แต่มันก็ไม่คุ้มค่าที่จะเถียง

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

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

หมายเหตุใน C ++ 0x เราสามารถทำอะไรif (ptr == nullptr)ที่ฉันไม่ดีกว่าการอ่าน (อีกครั้งฉันเกลียดมาโคร แต่nullptrก็ดีนะ) ฉันยังคงทำif (ptr)อยู่เพียงเพราะมันเป็นสิ่งที่ฉันคุ้นเคย

ตรงไปตรงมาฉันไม่เห็นว่าทำไมมันถึงสำคัญ อย่างใดอย่างหนึ่งค่อนข้างชัดเจนและใครก็ตามที่มีประสบการณ์ปานกลางกับ C หรือ C ++ ควรเข้าใจทั้งสองอย่าง หนึ่งความคิดเห็นแม้ว่า:

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

int f(void* p)
{
    if (!p) { return -1; }

    // p is not null
    return 0;
}

ด้วยวิธีนี้คุณหลีกเลี่ยง "รหัสลูกศร"

โดยส่วนตัวฉันมักจะใช้if (ptr == NULL)เพราะมันทำให้ความตั้งใจของฉันชัดเจน แต่ ณ จุดนี้มันเป็นเพียงนิสัย

การใช้งาน=แทน==จะถูกจับโดยคอมไพเลอร์ที่มีอำนาจใด ๆ ด้วยการตั้งค่าคำเตือนที่ถูกต้อง

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

เพียงหนึ่งจุดในความโปรดปรานของfoo == NULLการปฏิบัติ: ถ้าfooมีบอกว่าเป็นint *หรือbool *แล้วif (foo)สามารถตรวจสอบได้ตั้งใจจะตีความโดยผู้อ่านเช่นการทดสอบค่าของ pointee if (*foo)คือเป็น NULLเปรียบเทียบที่นี่เป็นการเตือนว่าเรากำลังพูดถึงตัวชี้

แต่ฉันคิดว่าการตั้งชื่อที่ดีทำให้ข้อโต้แย้งนี้เกิดขึ้น

ที่จริงฉันใช้ทั้งสองรูปแบบ

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

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

ภาษาโปรแกรม C (K&R) จะให้คุณตรวจสอบ null == ptr เพื่อหลีกเลี่ยงการมอบหมายโดยไม่ตั้งใจ

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

และไม่ว่ามันเป็นเรื่องสำคัญ if (ptr)แต่ความชอบส่วนบุคคลของฉันคือ ความหมายชัดเจนยิ่งกว่าฉันในทันทีif (ptr == NULL)ทันที

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

ข้อยกเว้นนี้คือถ้าข้อผิดพลาดทำให้ฉันประกันตัวจากฟังก์ชั่นหรือฉันสามารถกู้คืนจากมันก่อนที่จะย้าย ในกรณีเหล่านั้นฉันจัดการข้อผิดพลาดก่อน:

if (error_condition)
  bail_or_fix();
  return if not fixed;

// If I'm still here, I'm on the happy path

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

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

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

• พอยน์เตอร์ไม่ใช่บูลีน
• คอมไพเลอร์ C / C ++ ที่ทันสมัยเปล่งคำเตือนเมื่อคุณเขียนif (foo = bar)โดยไม่ได้ตั้งใจ

ดังนั้นฉันชอบ

if (foo == NULL)
{
    // null case
}
else
{
    // non null case
}

หรือ

if (foo != NULL)
{
    // non null case
}
else
{
    // null case
}

อย่างไรก็ตามหากฉันกำลังเขียนแนวทางสไตล์ชุดหนึ่งฉันจะไม่ใส่สิ่งนี้ลงไปในนั้นฉันจะวางสิ่งต่าง ๆ เช่น:

ตรวจสอบให้แน่ใจว่าคุณทำเครื่องหมายเป็นศูนย์บนตัวชี้

ฉันเป็นแฟนตัวยงของความจริงที่ว่า C / C ++ ไม่ได้ตรวจสอบชนิดในสภาพบูลีนในif, forและwhileงบ ฉันมักจะใช้สิ่งต่อไปนี้:

if (ptr)

if (!ptr)

แม้ในจำนวนเต็มหรือชนิดอื่น ๆ ที่แปลงเป็นบูล:

while(i--)
{
    // Something to do i times
}

while(cin >> a >> b)
{
    // Do something while you've input
}

การเข้ารหัสในลักษณะนี้สามารถอ่านได้และชัดเจนยิ่งขึ้นสำหรับฉัน แค่ความเห็นส่วนตัวของฉัน

เมื่อเร็ว ๆ นี้ขณะที่ทำงานกับไมโครคอนโทรลเลอร์ OKI 431 ฉันได้สังเกตเห็นสิ่งต่อไปนี้:

unsigned char chx;

if (chx) // ...

มีประสิทธิภาพมากกว่า

if (chx == 1) // ...

เพราะในกรณีต่อมาคอมไพเลอร์ต้องเปรียบเทียบค่าของ chx เป็น 1 โดยที่ chx เป็นเพียงค่าสถานะจริง / เท็จ

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