จุดประสงค์ของการบล็อก 'if (0)' ในบล็อก if-else คืออะไร

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

รหัสโดยรวมมีลักษณะดังนี้:

if (0) {
    // Empty braces
} else if (some_fn_call()) {
    // actual code
} else if (some_other_fn_call()) {
    // another actual code
    ...
} else {
    // default case
}

สาขาอื่นไม่เกี่ยวข้องกับคำถามของฉัน ฉันสงสัยว่าความหมายของการใส่if (0)ที่นี่คืออะไร เครื่องมือจัดฟันนั้นว่างเปล่าดังนั้นฉันไม่คิดว่ามันควรจะคอมเม้นต์บล็อคโค้ด มันบังคับให้คอมไพเลอร์ทำการปรับให้เหมาะสมหรือมีความตั้งใจแตกต่างกันหรือไม่?

ฉันพยายามค้นหากรณีที่ชัดเจนนี้ที่นี่บน SO และบนอินเทอร์เน็ต แต่ไม่ประสบความสำเร็จ มีคำถามที่คล้ายกันเกี่ยวกับ JavaScript แต่ไม่ใช่ C. มีคำถามอื่นเกิดอะไรขึ้นเมื่อมีการกำหนดศูนย์ในเงื่อนไข `if` แต่มันอธิบายการกำหนดศูนย์ให้กับตัวแปรไม่ใช่การใช้ 'if (0)'

บางครั้งผมใช้นี้สำหรับสมมาตรดังนั้นฉันสามารถย้ายอื่น ๆได้อย่างอิสระรอบด้วยการแก้ไขของฉันโดยไม่ต้องใจครั้งแรกelse if{if

ความหมายของ

if (0) {
    // Empty braces
} else 

ส่วนหนึ่งไม่ได้ทำอะไรและคุณสามารถพึ่งพาเครื่องมือเพิ่มประสิทธิภาพเพื่อลบออกได้

สิ่งนี้จะมีประโยชน์หากมี#ifคำสั่ง ala

   if (0)
   {
       // Empty block
   }
#if TEST1_ENABLED
   else if (test1())
   {
      action1();
   }
#endif
#if TEST2_ENABLED
   else if (test2())
   {
      action2();
   }
#endif

เป็นต้น

ในกรณีนี้การทดสอบใด ๆ (และทั้งหมด) สามารถ#if'ed out ได้และรหัสจะรวบรวมอย่างถูกต้อง คอมไพเลอร์เกือบทั้งหมดจะนำชิ้นif (0) {}ส่วนออก เครื่องมือสร้างอัตโนมัติอย่างง่ายสามารถสร้างรหัสได้เช่นนี้เนื่องจากรหัสง่ายขึ้นเล็กน้อย - ไม่ต้องพิจารณาบล็อกที่เปิดใช้งานแยกต่างหาก

ฉันเห็นรูปแบบที่คล้ายกันซึ่งใช้ในรหัสที่สร้างขึ้น ตัวอย่างเช่นใน SQL ฉันเคยเห็นห้องสมุดปล่อยwhereประโยคต่อไปนี้

where 1 = 1

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

ตามที่เขียนไว้, if (0) {}ประโยคจะรวบรวมข้อมูลใด ๆ

ฉันสงสัยว่าการทำงานของข้อที่ด้านบนของบันไดนี้คือการให้เป็นสถานที่ที่ง่ายต่อการปิดการใช้งานชั่วคราวทุกฟังก์ชั่นอื่น ๆ ได้ในครั้งเดียว (สำหรับการแก้จุดบกพร่องหรือเพื่อการเปรียบเทียบ) โดยการเปลี่ยน0ไปหรือ1true

ฉันไม่แน่ใจเกี่ยวกับการปรับให้เหมาะสม แต่มีสองเซนต์ของฉัน:

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

• ก็ขี้เกียจที่จะปรับโครงสร้างif-elseบล็อก
• ไม่ต้องการลงไปนับจำนวนสาขา

ดังนั้นแทนที่จะลบifบล็อกที่เกี่ยวข้องพวกเขาเพียงแค่เปลี่ยนเงื่อนไขเป็นif(0)และย้ายไป

มันเป็นรหัสเน่า

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

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

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

ความเป็นไปได้อย่างหนึ่งที่ยังไม่ได้กล่าวถึง: if (0) {เส้นอาจให้จุดพักที่สะดวกสำหรับจุดพัก

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

มีคำแนะนำที่ดีอื่น ๆ ข้างต้นเช่นกัน; วิธีเดียวที่จะรู้ว่าจุดประสงค์คืออะไรคือการติดตามผู้เขียนและถาม ระบบควบคุมซอร์สโค้ดของคุณอาจช่วยได้ (มองหาblameฟังก์ชั่น -type)

ฉันเห็นบล็อกโค้ดที่ไม่สามารถเข้าถึงได้ใน JavaScript ที่ขยายล่วงหน้าซึ่งสร้างขึ้นโดยใช้เทมเพลตภาษา

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

if ( ${requestIsNotHttps} ){ ... }else if( ...

ซึ่งครั้งหนึ่งก่อนการคอมไพล์ hences:

if ( 0 ){ ... }else if ( ...

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

โครงสร้างนั้นอาจใช้ใน C เพื่อใช้งานการเขียนโปรแกรมทั่วไปที่มีความปลอดภัยของประเภทโดยอาศัยข้อเท็จจริงที่ว่าโค้ดที่ไม่สามารถเข้าถึงได้นั้นยังคงถูกตรวจสอบโดยคอมไพเลอร์:

// this is a generic unsafe function, that will call fun(arg) at a later time
void defer(void *fun, void *arg);

// this is a macro that makes it safer, by checking the argument
// matches the function signature
#define DEFER(f, arg) \
   if(0) f(arg); \              // never actually called, but compile-time checked
   else defer(f, (void *)arg);  // do the unsafe call after safety check

void myfunction(int *p);

DEFER(myfunction, 42);     // compile error
int *b;
DEFER(myfunction, b);      // compiles OK

ฉันคิดว่ามันเป็นรหัสที่ไม่ดี การเขียนตัวอย่างด่วนใน Compiler Explorer เราจะเห็นว่าทั้ง gcc และ clang ไม่มีการสร้างโค้ดสำหรับif (0)บล็อกแม้ว่าจะปิดการใช้งานการปรับแต่งอย่างสมบูรณ์แล้วก็ตาม:

https://godbolt.org/z/PETIks

เล่นกับการลบif (0)สาเหตุที่ไม่มีการเปลี่ยนแปลงรหัสที่สร้างขึ้นดังนั้นฉันสรุปได้ว่านี่ไม่ใช่การเพิ่มประสิทธิภาพ

เป็นไปได้ว่ามีบางสิ่งบางอย่างในifบล็อกด้านบนซึ่งถูกลบออกในภายหลัง กล่าวโดยย่อดูเหมือนว่าการลบจะทำให้รหัสเดียวกันถูกสร้างขึ้นดังนั้นอย่าลังเลที่จะทำเช่นนั้น

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

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

if (feature_a_active()) {
    use_feature_a();
} else if (some_fn()) {
   ...

กลายเป็น

if (0) {
   // empty
} else if (some_fn()) {
   ...

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

    Actually according to my opinion, if we put any variable for checking inside
    e.g:-
public static void main(string args[])
{
        var status;
        var empList=_unitofWork.EmpRepository.Get(con=>con.isRetired==true);
        //some code logic 
        if(empList.count>0)
        {
          status=true;
        }
        if(status)
        {
         //do something
        }
        else
        {
        //do something else
        }
}
     if then its dynamically get the value in run time and invoke the logic inside it, else its simply extra line of code i guess.

    Anybody have any depth knowledge why this thing is used....or agree with me.
    kindly respond. 

@ คำตอบของ PSkocik นั้นใช้ได้ แต่ฉันเพิ่มสองเซ็นต์ของฉัน ไม่แน่ใจว่าฉันควรทำเช่นนี้เป็นความคิดเห็นหรือเป็นคำตอบ; เลือกอันหลังเนื่องจาก IMHO ให้ความสำคัญกับผู้อื่นที่เห็นในขณะที่ความคิดเห็นมักจะมองไม่เห็น

ไม่เพียง แต่ฉันจะใช้เป็นครั้งคราว

if(0) {
   //deliberately left empty
} else if( cond1 ) {
   //deliberately left empty
} else if( cond2 ) {
   //deliberately left empty
...
} else {
   // no conditions matched
}

แต่ฉันก็ทำเช่นกัน

if( 1 
    && cond1 
    && cond2
    ...
    && condN
) {

หรือ

if( 0 
    || cond1 
    || cond2
    ...
    || condN
) {

สำหรับเงื่อนไขที่ซับซ้อน ด้วยเหตุผลเดียวกัน - ง่ายต่อการแก้ไข #ifdef ฯลฯ

สำหรับเรื่องนั้นใน Perl ฉันจะทำ

@array = (  
    elem1,
    elem2,
    ...
    elem1,
) {

• สังเกตเครื่องหมายจุลภาคที่ท้ายรายการ ฉันลืมว่าเครื่องหมายจุลภาคเป็นตัวคั่นหรือตัวคั่นในรายการ C และ C ++ IMHO นี่คือสิ่งหนึ่งที่เราได้เรียนรู้: [จุลภาคต่อท้ายใน Perl เป็นวิธีปฏิบัติที่ไม่ดีหรือไม่? เครื่องหมายจุลภาค] เป็นสิ่งที่ดี เช่นเดียวกับสัญกรณ์ใหม่ ๆ มันใช้เวลาสักครู่ในการทำความคุ้นเคย

ฉันเปรียบเทียบ if(0)รหัสกับเสียงกระเพื่อม

(cond   (test1    action1)
   (test2    action2)
   ...
   (testn   actionn))

ซึ่งคุณเดาฉันอาจเยื้องเป็น

(cond   
   (test1    action1)
   (test2    action2)
   ...
   (testn   actionn)
)

บางครั้งฉันก็ลองจินตนาการถึงสิ่งที่ไวยากรณ์ที่มนุษย์อ่านได้มากกว่านี้อาจดูเหมือน

บางที

IF
:: cond1 THEN code1
:: cond2 THEN code2
...
:: condN THEN codeN
FI

รับแรงบันดาลใจจาก [Dikstra's [ https://en.wikipedia.org/wiki/Guarded_Command_Language#Selection:_ifrep 35] Command Language]

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

ฉันเริ่มทำสิ่งนี้เมื่อเขียนโปรแกรมที่สร้างโปรแกรมอื่น ๆ ซึ่งมันสะดวกอย่างยิ่ง

ในขณะที่เราอยู่ที่นั้นเมื่อเขียน RTL โดยใช้ iHDL เก่าของ Intel ฉันได้เขียนโค้ดดังนี้

   IF 0 THEN /*nothing*/
   **FORC i FROM 1 TO 10 DOC** 
   ELSE IF signal%i% THEN    
      // stuff to do if signal%i% is active
   **ENDC** 
   ELSE   
      // nothing matched 
   ENDIF

โดยที่FORC..DOC..ENDCis คือตัวสร้าง preprocessor วนรอบที่จะขยาย

   IF 0 THEN /*nothing*/
   ELSE IF signal1 THEN    
      // stuff to do if signal1 is active
   ELSE IF signal2 THEN    
      // stuff to do if signal2 is active
   ...
   ELSE IF signal100 THEN    
      // stuff to do if signal100 is active
   ELSE   
      // nothing matched 
   ENDIF

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

   IF 0 THEN /*nothing*/
   ELSE IF signal1 THEN    
      found := 1
   ELSE IF signal2 THEN    
      found := 2
   ...
   ELSE IF signal100 THEN    
      found := 100
   ELSE   
      // nothing matched 
   ENDIF

ลองคิดดูสินี่อาจเป็นครั้งแรกที่ฉันได้พบสิ่งก่อสร้าง

BTW การคัดค้านที่บางคนมีรูปแบบ if (0) - ซึ่งเงื่อนไขอื่น ๆ นั้นขึ้นอยู่กับการเรียงลำดับและไม่สามารถเรียงลำดับใหม่โดยพลการ - ไม่ใช้กับตรรกะ AND และ OR และ XOR ใน RTL - แต่ใช้กับ short- circuit && และ ||

ฉันเคยเห็นสิ่งนี้ใช้เพื่อจัดการข้อผิดพลาดตัวอย่างเช่น

if(0){
lable1:
   //do something
}
if(0){
lable2:
   //do something
}
.
.
and so on.

if(condition_fails)
   goto lable1;

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

ฉันเคยเห็นสิ่งนี้มาสองสามครั้งฉันคิดว่าเหตุผลที่น่าเป็นไปได้มากที่สุดคือการประเมินบางอย่างในรุ่นเก่า / แตกต่าง / สาขาของรหัสหรืออาจเป็นเพราะการดีบั๊กและการเปลี่ยนif(0)เป็นวิธีที่ค่อนข้างขี้เกียจ .