คุณใช้ NULL หรือ 0 (ศูนย์) สำหรับตัวชี้ใน C ++ หรือไม่?

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

จนถึงวันนี้ผมยังคงใช้เป็นศูนย์เป็นตัวชี้โมฆะ แต่คนรอบ ๆ NULLตัวผมยืนยันในการใช้ ฉันเองไม่เห็นประโยชน์ใด ๆ ในการตั้งชื่อ ( NULL) ให้กับค่าที่มีอยู่ - และเนื่องจากฉันต้องการทดสอบพอยน์เตอร์เป็นค่าความจริง:

if (p && !q)
  do_something();

จากนั้นใช้ศูนย์ทำให้รู้สึกมากขึ้น (เช่นถ้าคุณใช้NULLคุณไม่สามารถใช้อย่างมีเหตุผลp && !q- คุณต้องเปรียบเทียบอย่างชัดเจนNULLเว้นแต่คุณจะถือว่าNULLเป็นศูนย์ในกรณีนี้ทำไมใช้NULL)

มีเหตุผลวัตถุประสงค์ใดที่จะชอบศูนย์มากกว่า NULL (หรือกลับกัน) หรือทั้งหมดเป็นเพียงการตั้งค่าส่วนตัว?

แก้ไข: ฉันควรเพิ่ม (และตั้งใจจะพูด แต่เดิม) ว่าด้วย RAII และข้อยกเว้นฉันไม่ค่อยใช้ตัวชี้ศูนย์ / NULL แต่บางครั้งคุณก็ยังต้องการ

นี่คือสิ่งที่ Stroustrup ใช้ในเรื่องนี้: สไตล์ C ++ และคำถามที่พบบ่อยด้านเทคนิค

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

หากคุณมีการตั้งชื่อตัวชี้โมฆะเรียกว่าnullptr; นั่นคือสิ่งที่มันถูกเรียกใน C ++ 11 จากนั้นnullptrจะเป็นคำหลัก

ที่กล่าวว่าอย่าเหงื่อสิ่งเล็ก ๆ น้อย ๆ

มีข้อโต้แย้งเล็กน้อย (ข้อหนึ่งซึ่งค่อนข้างเร็ว) ซึ่งฉันเชื่อว่าตำแหน่งของ Bjarne ขัดแย้งกับเรื่องนี้

1. เอกสารแสดงเจตจำนง

การใช้NULLช่วยให้สามารถค้นหาโดยใช้งานได้และยังเน้นว่านักพัฒนาซอฟต์แวร์ต้องการใช้NULLตัวชี้โดยไม่คำนึงว่าคอมไพเลอร์ตีความNULLหรือไม่

2. เกินชี้และ 'int' ค่อนข้างหายาก

ตัวอย่างที่ทุกคนพูดคือ:

void foo(int*);
void foo (int);

void bar() {
  foo (NULL);  // Calls 'foo(int)'
}

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

3. เครื่องมือวิเคราะห์สามารถช่วยวันนี้!

แม้ในกรณีที่ไม่มี C ++ 0x มีเครื่องมือที่พร้อมใช้งานทุกวันนี้ที่ตรวจสอบว่าNULLมีการใช้งานสำหรับพอยน์เตอร์และ0มีการใช้งานสำหรับประเภทที่สำคัญ

4. C ++ 11จะมีใหม่std::nullptr_tประเภท

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

#define NULL  nullptr

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

ใช้ NULL NULL แสดงเจตนาของคุณ ว่ามันคือ 0 คือรายละเอียดการใช้งานที่ไม่สำคัญ

ฉันมักจะใช้:

• NULL สำหรับพอยน์เตอร์
• '\0' สำหรับตัวอักษร
• 0.0 สำหรับลอยและคู่

ที่ 0 จะทำอะไรได้ดี มันเป็นเรื่องของเจตนาการส่งสัญญาณ ที่กล่าวว่าฉันไม่ได้เกี่ยวกับเรื่องนี้

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

ในโครงการใหม่ฉันใส่มันในส่วนหัวของโครงการ:

static const int nullptr = 0;

ตอนนี้เมื่อคอมไพเลอร์ที่เข้ากันได้ของ C ++ 0x มาถึงสิ่งที่ฉันต้องทำคือลบบรรทัดนั้นออก ประโยชน์ที่ดีของสิ่งนี้คือ Visual Studio รับรู้ nullptr เป็นคำหลักและไฮไลต์มันอย่างเหมาะสม

    cerr << sizeof(0) << endl;
    cerr << sizeof(NULL) << endl;
    cerr << sizeof(void*) << endl;

    ============
    On a 64-bit gcc RHEL platform you get:
    4
    8
    8
    ================

คุณธรรมของเรื่องราว คุณควรใช้ค่า NULL เมื่อคุณติดต่อกับพอยน์เตอร์

1) มันประกาศเจตนาของคุณ (อย่าให้ฉันค้นหารหัสทั้งหมดของคุณที่พยายามคิดออกว่าตัวแปรเป็นตัวชี้หรือบางประเภทตัวเลข)

2) ในการเรียก API บางอย่างที่ต้องการอาร์กิวเมนต์ของตัวแปรพวกเขาจะใช้ NULL-pointer เพื่อระบุจุดสิ้นสุดของรายการอาร์กิวเมนต์ ในกรณีนี้การใช้ '0' แทนค่า NULL อาจทำให้เกิดปัญหาได้ บนแพลตฟอร์ม 64 บิตการโทร va_arg ต้องการตัวชี้ 64 บิต แต่คุณจะผ่านจำนวนเต็ม 32 บิตเท่านั้น ดูเหมือนว่าฉันจะพึ่ง 32 บิตอื่น ๆ ที่จะเป็นศูนย์สำหรับคุณหรือไม่ ฉันเห็นคอมไพเลอร์บางตัว (เช่น icpc ของ Intel) ที่ไม่สุภาพ - และสิ่งนี้ส่งผลให้เกิดข้อผิดพลาดรันไทม์

ถ้าฉันจำได้อย่างถูกต้อง NULL มีการกำหนดแตกต่างกันในส่วนหัวที่ฉันได้ใช้ สำหรับ C มันถูกกำหนดเป็น (void *) 0 และสำหรับ C ++ มันนิยามเป็นเพียง 0

#ifndef __cplusplus
#define NULL (void*)0
#else
#define NULL 0
#endif

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

นอกจากนี้ฉันไม่พึ่งพาการแปลงจำนวนเต็มอัตโนมัติเป็นค่าบูลีน แต่จะเปรียบเทียบอย่างชัดเจน

ตัวอย่างเช่นต้องการใช้:

if (pointer_value != NULL || integer_value == 0)

ค่อนข้างมากกว่า:

if (pointer_value || !integer_value)

พอจะพูดได้ว่านี้แก้ได้ทั้งหมดใน C ++ 11 ที่หนึ่งก็สามารถใช้nullptrแทนNULLและยังว่าเป็นประเภทของการnullptr_tnullptr

ฉันจะบอกว่าประวัติศาสตร์ได้พูดไปแล้วและผู้ที่โต้แย้งว่าการใช้ 0 (ศูนย์) นั้นผิด (รวมถึง Bjarne Stroustrup) ข้อโต้แย้งในความโปรดปรานของ 0 ส่วนใหญ่เป็นสุนทรียภาพและ "ความชอบส่วนบุคคล"

หลังจากการสร้าง C ++ 11 ด้วยประเภท nullptr ใหม่คอมไพเลอร์บางคนเริ่มบ่น (ด้วยพารามิเตอร์เริ่มต้น) เกี่ยวกับการส่ง 0 ไปยังฟังก์ชันที่มีอาร์กิวเมนต์ตัวชี้เนื่องจาก 0 ไม่ใช่ตัวชี้

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

และถ้าคุณต้องเขียนโค้ดใหม่ตอนนี้ถึงมาตรฐาน C ++ 03 (และไม่สามารถใช้ nullptr) ได้คุณควรใช้ NULL มันจะทำให้คุณอัปเดตได้ง่ายขึ้นในอนาคต

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

คุณสามารถใช้วัตถุ nullptr ตามที่เสนอโดย Scott Meyers และอื่น ๆ จนกว่า C ++ จะได้รับคำหลัก nullptr:

const // It is a const object...
class nullptr_t 
{
public:
    template<class T>
    operator T*() const // convertible to any type of null non-member pointer...
    { return 0; }

    template<class C, class T>
    operator T C::*() const   // or any type of null member pointer...
    { return 0; }

private:
    void operator&() const;  // Can't take address of nullptr

} nullptr = {};

Google "nullptr" สำหรับข้อมูลเพิ่มเติม

ฉันเคยทำงานกับเครื่องที่ 0 เป็นที่อยู่ที่ถูกต้องและ NULL ถูกกำหนดเป็นค่าฐานแปดพิเศษ บนเครื่องนั้น (0! = NULL) ดังนั้นรหัสเช่น

char *p;

...

if (p) { ... }

จะไม่ทำงานตามที่คุณคาดหวัง คุณต้องเขียน

if (p != NULL) { ... }

แม้ว่าฉันจะเชื่อว่าคอมไพเลอร์ส่วนใหญ่กำหนด NULL เป็น 0 วันนี้ฉันยังจำบทเรียนจากปีที่ผ่านมา: NULL ไม่จำเป็นต้องเป็น 0

ฉันคิดว่ามาตรฐานรับรองว่า NULL == 0 ดังนั้นคุณสามารถทำได้ ฉันชอบ NULL เพราะเอกสารแสดงเจตจำนงของคุณ

การใช้ 0 หรือ NULL จะมีผลเหมือนกัน

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

NULL, 0, 0.0, '\ 0', 0x00 และ whatelse ทั้งหมดแปลเป็นสิ่งเดียวกัน แต่เป็นเอนทิตีเชิงตรรกะที่แตกต่างกันในโปรแกรมของคุณ พวกเขาควรจะใช้เช่นนี้ NULL คือตัวชี้, 0 คือปริมาณ, 0x0 เป็นค่าที่บิตน่าสนใจ ฯลฯ คุณจะไม่กำหนด '\ 0' ให้กับตัวชี้ไม่ว่าจะเป็นการรวบรวมหรือไม่

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

แปลกไม่มีใครรวมถึง Stroustroup กล่าวว่า ในขณะที่พูดมากเกี่ยวกับมาตรฐานและความงามไม่มีใครสังเกตเห็นว่ามันเป็นอันตรายที่จะใช้0ในการNULL's sizeof(int) != sizeof(void*)แทนตัวอย่างเช่นในรายการอาร์กิวเมนต์ตัวแปรกับสถาปัตยกรรมที่ เช่นเดียวกับ Stroustroup ฉันชอบ0เหตุผลด้านสุนทรียภาพ แต่ต้องระวังไม่ให้ใช้เพราะมันอาจจะคลุมเครือ

ฉันพยายามหลีกเลี่ยงคำถามทั้งหมดโดยใช้การอ้างอิง C ++ หากเป็นไปได้ ค่อนข้างมากกว่า

void foo(const Bar* pBar) { ... }

คุณมักจะสามารถเขียน

void foo(const Bar& bar) { ... }

แน่นอนว่ามันไม่ได้ผลเสมอไป แต่พอยน์เตอร์พอยน์เตอร์สามารถใช้มากเกินไปได้

ฉันใช้ Stroustrup กับอันนี้ :-) เนื่องจาก NULL ไม่ได้เป็นส่วนหนึ่งของภาษาฉันชอบที่จะใช้ 0

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

void *ptr = &something;
/* lots o' code */
ptr = NULL; // more obvious that it's a pointer and not being used

IIRC มาตรฐานไม่จำเป็นต้องมีค่า NULL เป็น 0 ดังนั้นการใช้อะไรก็ตามที่กำหนดไว้ใน <stddef.h> น่าจะดีที่สุดสำหรับคอมไพเลอร์ของคุณ

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

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

ที่กล่าวว่าฉันไม่มีปัญหากับการใช้พอยน์เตอร์เป็นค่าความจริงในตัวเอง เช่นเดียวกับ NULL มันเป็นสำนวนที่ฝังแน่น

C ++ 09 จะเพิ่มโครงสร้าง nullptr ซึ่งฉันคิดว่าค้างชำระนานเกินไป

ฉันมักจะใช้ 0 ไม่ได้เพราะเหตุผลที่คิดออกจริง ๆ เพียงเพราะเมื่อฉันเรียนรู้ C ++ ครั้งแรกฉันอ่านสิ่งที่แนะนำโดยใช้ 0 และฉันก็ทำอย่างนั้นเสมอ ในทางทฤษฎีอาจมีปัญหาความสับสนในการอ่าน แต่ในทางปฏิบัติฉันไม่เคยเจอปัญหาดังกล่าวในชั่วโมงการทำงานหลายพันชั่วโมงและหลายล้านบรรทัดของรหัส ดังที่สเตราสตรูปบอกว่ามันเป็นเรื่องของสุนทรียศาสตร์ส่วนตัวจนกระทั่งมาตรฐานกลายเป็นโมฆะ

มีคนบอกฉันอีกครั้ง ... ฉันจะกำหนด NULL เป็น 69 อีกครั้งตั้งแต่นั้นมาฉันไม่ได้ใช้: P

ทำให้รหัสของคุณค่อนข้างเสี่ยง

แก้ไข:

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

NULL ไม่ทำงานเป็นตัวชี้โมฆะ แต่เป็น O / OL ตัวอักษร

บอกฉันตัวอย่างต่อไปไม่สับสน:

void foo(char *); 
void foo(int); 
foo(NULL); // calls int version instead of pointer version! 

เป็นเพราะทั้งหมดนั้นในมาตรฐานใหม่จะปรากฏ std :: nullptr_t

หากคุณไม่ต้องการรอมาตรฐานใหม่และต้องการใช้ nullptr ให้ใช้อย่างน้อยหนึ่งค่าที่ดีเช่นเดียวกับข้อเสนอของ Meyers (ดูความคิดเห็น jon.h)

ฉันเถียงไม่ได้ใช้ 0 หรือตัวชี้ NULL เลยเมื่อใดก็ตามที่เป็นไปได้

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

นอกจากนี้ยังนำไปสู่คำสั่ง "if-not-null" ทั่วรหัสของคุณ ถ้าคุณสามารถใช้สถานะที่ถูกต้องได้ดีกว่าเสมอ

มีทางเลือกที่ดีกว่าเกือบตลอดเวลา

การตั้งตัวชี้ไปที่ 0 นั้นไม่ชัดเจนเลย โดยเฉพาะอย่างยิ่งถ้าคุณมาภาษาอื่นที่ไม่ใช่ C ++ ซึ่งรวมถึง C และ Javascript

ฉันเพิ่งจะลบรหัสบางอย่างเช่น:

virtual void DrawTo(BITMAP *buffer) =0;

สำหรับฟังก์ชั่นเสมือนบริสุทธิ์เป็นครั้งแรก ฉันคิดว่ามันจะเป็น jiberjash เวทมนตร์เป็นเวลาหนึ่งสัปดาห์ เมื่อฉันรู้ว่ามันเป็นเพียงการตั้งค่าตัวชี้ฟังก์ชั่นเป็นnull(เพราะฟังก์ชั่นเสมือนเป็นเพียงตัวชี้ฟังก์ชั่นในกรณีส่วนใหญ่สำหรับ C ++) ฉันเตะตัวเอง

virtual void DrawTo(BITMAP *buffer) =null;

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