Double Negation ใน C ++

ฉันเพิ่งเข้ามาในโครงการที่มีฐานรหัสขนาดใหญ่มาก

ฉันจัดการกับ C ++ เป็นส่วนใหญ่และโค้ดจำนวนมากที่พวกเขาเขียนใช้การปฏิเสธสองครั้งสำหรับตรรกะบูลีน

 if (!!variable && (!!api.lookup("some-string"))) {
       do_some_stuff();
 }                                   

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

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

ถูกต้องหรือฉันพลาดอะไรไป?

มันเป็นเคล็ดลับในการแปลงเป็นบูล

มันเป็นสำนวนที่มีประโยชน์มากในบางบริบท ใช้มาโครเหล่านี้ (ตัวอย่างจากเคอร์เนล Linux) สำหรับ GCC มีการดำเนินการดังนี้:

#define likely(cond)   (__builtin_expect(!!(cond), 1))
#define unlikely(cond) (__builtin_expect(!!(cond), 0))

ทำไมพวกเขาต้องทำเช่นนี้? GCC __builtin_expectถือว่าพารามิเตอร์เป็นlongไม่ใช่boolดังนั้นจึงต้องมีรูปแบบการแปลงบางรูปแบบ เนื่องจากพวกเขาไม่รู้ว่าcondเวลาเขียนมาโครเหล่านั้นคืออะไรจึงเป็นเรื่องปกติที่จะใช้ไฟล์!!สำนวน

พวกเขาอาจทำสิ่งเดียวกันได้โดยการเปรียบเทียบกับ 0 แต่ในความคิดของฉันมันตรงไปตรงมามากกว่าที่จะทำการลบล้างสองครั้งเนื่องจากเป็นสิ่งที่ใกล้เคียงที่สุดกับ cast-to-bool ที่ C มี

รหัสนี้สามารถใช้ใน C ++ ได้เช่นกัน ... มันเป็นตัวหารที่มีค่าน้อยที่สุด ถ้าเป็นไปได้ให้ทำสิ่งที่ใช้ได้ทั้ง C และ C ++

ผู้เขียนโค้ดคิดว่าจะแปลงตัวถูกดำเนินการเป็นบูล แต่เนื่องจากตัวถูกดำเนินการของ && ถูกแปลงเป็นบูลโดยปริยายแล้วจึงซ้ำซ้อนอย่างที่สุด

เป็นเทคนิคในการหลีกเลี่ยงการเขียน (ตัวแปร! = 0) - คือการแปลงจากประเภทใดก็ได้เป็นบูล

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

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

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

ด้านข้าง - ขั้นตอนคำเตือนของคอมไพเลอร์ ลองสิ่งนี้:

int _tmain(int argc, _TCHAR* argv[])
{
    int foo = 5;
    bool bar = foo;
    bool baz = !!foo;
    return 0;
}

บรรทัด "bar" สร้าง "ค่าบังคับให้บูล" จริง "หรือ" เท็จ "(คำเตือนเกี่ยวกับประสิทธิภาพ)" บน MSVC ++ แต่บรรทัด "baz" แอบดูได้ดี

เป็นผู้ดำเนินการ! มากเกินไป?
ถ้าไม่เป็นเช่นนั้นพวกเขาอาจทำเช่นนี้เพื่อแปลงตัวแปรเป็นบูลโดยไม่มีการเตือน นี่ไม่ใช่วิธีมาตรฐานในการทำสิ่งต่างๆอย่างแน่นอน

นักพัฒนามรดก C ไม่มีชนิดบูลีนเพื่อให้พวกเขามักจะ#define TRUE 1และ#define FALSE 0และนำไปใช้โดยพลการประเภทข้อมูลที่เป็นตัวเลขสำหรับการเปรียบเทียบบูลีน ตอนนี้เรามีboolแล้วคอมไพเลอร์จำนวนมากจะส่งเสียงเตือนเมื่อมีการกำหนดและการเปรียบเทียบบางประเภทโดยใช้ส่วนผสมของประเภทตัวเลขและประเภทบูลีน การใช้งานทั้งสองนี้จะขัดแย้งกันในที่สุดเมื่อทำงานกับรหัสเดิม

เพื่อหลีกเลี่ยงปัญหานี้นักพัฒนาบางรายใช้ข้อมูลประจำตัวบูลีนต่อไปนี้: !num_valueส่งกลับbool trueif num_value == 0; falseมิฉะนั้น. !!num_valueผลตอบแทนbool falseถ้าnum_value == 0; trueมิฉะนั้น. การปฏิเสธเพียงครั้งเดียวก็เพียงพอที่จะแปลงnum_valueเป็นbool; อย่างไรก็ตามการปฏิเสธสองครั้งเป็นสิ่งจำเป็นเพื่อคืนความรู้สึกดั้งเดิมของนิพจน์บูลีน

รูปแบบนี้เรียกว่าสำนวนกล่าวคือสิ่งที่คนคุ้นเคยกับภาษาใช้กันทั่วไป ดังนั้นฉันจึงไม่เห็นว่ามันเป็นการต่อต้านรูปแบบมากเท่าที่ฉันจะทำได้static_cast<bool>(num_value)ทำได้ การแคสต์อาจให้ผลลัพธ์ที่ถูกต้องเป็นอย่างดี แต่คอมไพเลอร์บางตัวก็ส่งเสียงเตือนเกี่ยวกับประสิทธิภาพดังนั้นคุณยังคงต้องจัดการกับสิ่งนั้น

วิธีอื่น ๆ (num_value != FALSE)ที่อยู่นี้คือการพูด ฉันก็โอเคเช่นกัน แต่โดยรวมแล้ว!!num_valueเป็น verbose น้อยกว่ามากอาจจะชัดเจนกว่าและไม่สับสนในครั้งที่สองที่คุณเห็น

!! ถูกใช้เพื่อรับมือกับ C ++ ดั้งเดิมซึ่งไม่มีประเภทบูลีน (เช่นเดียวกับ C)

ตัวอย่างปัญหา:

ภายในif(condition)ที่conditionตอบสนองความต้องการในการประเมินเพื่อบางชนิดเช่นdouble, int, void*ฯลฯ แต่ไม่ได้boolมันไม่ได้อยู่เลย

สมมติว่ามีคลาสอยู่int256(จำนวนเต็ม 256 บิต) และการแปลงจำนวนเต็ม / แคสต์ทั้งหมดมีมากเกินไป

int256 x = foo();
if (x) ...

หากต้องการทดสอบว่าxเป็น "จริง" หรือไม่เป็นศูนย์ให้if (x)แปลงxเป็นจำนวนเต็มแล้วประเมินว่าintไม่ใช่ศูนย์ การโอเวอร์โหลดโดยทั่วไป(int) xจะส่งคืนเฉพาะ LSbits ของx. if (x)เป็นเพียงการทดสอบ LSbits ของx.

แต่ C ++ มีตัว!ดำเนินการ !xโดยทั่วไปแล้วการโอเวอร์โหลดจะประเมินบิตทั้งหมดของx. ดังนั้นเพื่อให้ได้กลับไปตรรกะไม่ใช่คว่ำif (!!x)ถูกนำมาใช้

Ref รุ่นเก่าของ C ++ ใช้โอเปอเรเตอร์ "int" ของคลาสเมื่อประเมินเงื่อนไขในคำสั่ง "if ()" หรือไม่

ในฐานะที่เป็นMarcinกล่าวได้เป็นอย่างดีอาจจะสำคัญว่าถ้าไปประกอบอยู่ในการเล่น มิฉะนั้นใน C / C ++ จะไม่สำคัญยกเว้นว่าคุณกำลังทำสิ่งใดสิ่งหนึ่งต่อไปนี้:

• การเปรียบเทียบโดยตรงกับtrue(หรือใน C เช่นTRUEมาโคร) ซึ่งเป็นความคิดที่ไม่ดี ตัวอย่างเช่น:

  if (api.lookup("some-string") == true) {...}

• คุณเพียงแค่ต้องการให้บางสิ่งบางอย่างถูกแปลงเป็นค่า 0/1 ที่เข้มงวด ใน C ++ การมอบหมายให้ a boolจะทำสิ่งนี้โดยปริยาย (สำหรับสิ่งที่แปลงสภาพได้โดยปริยายbool) ใน C หรือถ้าคุณกำลังจัดการกับตัวแปรที่ไม่ใช่บูลนี่เป็นสำนวนที่ฉันเคยเห็น แต่ฉันชอบ(some_variable != 0)ความหลากหลายด้วยตัวเอง

ฉันคิดว่าในบริบทของนิพจน์บูลีนที่ใหญ่กว่านั้นมันทำให้สิ่งต่าง ๆ กระจัดกระจาย

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

ถูกต้อง แต่ใน C ไม่มีจุดหมายที่นี่ - 'if' และ '&&' จะปฏิบัติต่อนิพจน์ในลักษณะเดียวกันโดยไม่มี "!!"

ฉันคิดว่าเหตุผลที่ต้องทำใน C ++ ก็คือ '&&' อาจจะทำงานมากเกินไป แต่แล้วจึงจะทำได้ '' จึงไม่ได้จริงๆรับประกันว่าคุณจะได้รับบูลโดยไม่ต้องมองหาที่รหัสสำหรับประเภทของและvariable api.callอาจมีคนที่มีประสบการณ์ C ++ มากกว่าสามารถอธิบายได้ บางทีอาจหมายถึงมาตรการเชิงลึกเชิงป้องกันไม่ใช่การรับประกัน

บางทีโปรแกรมเมอร์กำลังคิดอะไรแบบนี้ ...

!! myAnswer เป็นบูลีน ในบริบทมันควรจะกลายเป็นบูลีน แต่ฉันชอบที่จะปังปัง ๆ เพื่อให้แน่ใจเพราะกาลครั้งหนึ่งมีแมลงลึกลับที่กัดฉันและปังปังฉันก็ฆ่ามัน

นี่อาจเป็นตัวอย่างของเคล็ดลับดับเบิ้ลปังดูThe Safe Bool Idiomสำหรับรายละเอียดเพิ่มเติม ที่นี่ฉันสรุปหน้าแรกของบทความ

ใน C ++ มีหลายวิธีในการจัดเตรียมการทดสอบบูลีนสำหรับคลาส

วิธีที่ชัดเจนคือoperator boolตัวดำเนินการแปลง

// operator bool version
  class Testable {
    bool ok_;
  public:
    explicit Testable(bool b=true):ok_(b) {}

    operator bool() const { // use bool conversion operator
      return ok_;
    }
  };

เราสามารถทดสอบชั้นเรียน

Testable test;
  if (test) 
    std::cout << "Yes, test is working!\n";
  else 
    std::cout << "No, test is not working!\n";

แต่opereator boolถือว่าไม่ปลอดภัยเพราะจะช่วยให้การดำเนินงานไร้สาระเช่นหรือtest << 1;int i=test

การใช้operator!จะปลอดภัยกว่าเนื่องจากเราหลีกเลี่ยงปัญหาการแปลงโดยปริยายหรือการใช้งานมากเกินไป

การใช้งานเป็นเรื่องเล็กน้อย

bool operator!() const { // use operator!
    return !ok_;
  }

สองวิธีทางสำนวนในการทดสอบTestableวัตถุคือ

  Testable test;
  if (!!test) 
    std::cout << "Yes, test is working!\n";
  if (!test2) {
    std::cout << "No, test2 is not working!\n";

รุ่นแรกif (!!test)เป็นสิ่งที่บางคนเรียกว่าเคล็ดลับคู่ปัง