ทำไมข้อความที่ไม่มีผลต่อการพิจารณาทางกฎหมายใน C

ให้อภัยหากคำถามนี้ไร้เดียงสา พิจารณาโปรแกรมต่อไปนี้:

#include <stdio.h>

int main() {
  int i = 1;
  i = i + 2;
  5;
  i;
  printf("i: %d\n", i);
}

ในตัวอย่างข้างต้นข้อความ5;และi;ดูเหมือนฟุ่มเฟือยโดยสิ้นเชิง แต่โค้ดรวบรวมโดยไม่มีคำเตือนหรือข้อผิดพลาดโดยค่าเริ่มต้น (อย่างไรก็ตาม gcc จะโยนwarning: statement with no effect [-Wunused-value]คำเตือนเมื่อวิ่งไปด้วย-Wall) พวกเขาไม่มีผลกับส่วนที่เหลือของโปรแกรมดังนั้นทำไมพวกเขาจึงพิจารณาข้อความที่ถูกต้องตั้งแต่แรก? คอมไพเลอร์ไม่สนใจพวกเขาเหรอ? มีประโยชน์ใด ๆ ในการอนุญาตข้อความดังกล่าวหรือไม่?

ข้อดีอย่างหนึ่งของการอนุญาตให้ใช้คำสั่งดังกล่าวนั้นมาจากรหัสที่สร้างขึ้นโดยมาโครหรือโปรแกรมอื่น ๆ แทนที่จะเขียนโดยมนุษย์

ตัวอย่างลองจินตนาการถึงฟังก์ชั่น int do_stuff(void)ที่ควรจะคืนค่า 0 เมื่อสำเร็จหรือ -1 เมื่อล้มเหลว อาจเป็นไปได้ว่าการสนับสนุน "เนื้อหา" นั้นเป็นตัวเลือกและคุณอาจมีไฟล์ส่วนหัวที่ทำ

#if STUFF_SUPPORTED
#define do_stuff() really_do_stuff()
#else
#define do_stuff() (-1)
#endif

ทีนี้ลองนึกถึงโค้ดที่ต้องการทำสิ่งต่าง ๆ ถ้าเป็นไปได้ แต่อาจหรืออาจไม่สนใจว่ามันจะสำเร็จหรือล้มเหลว

void func1(void) {
    if (do_stuff() == -1) {
        printf("stuff did not work\n");
    }
}

void func2(void) {
    do_stuff(); // don't care if it works or not
    more_stuff();
}

เมื่อSTUFF_SUPPORTEDเป็น 0 ตัวประมวลผลล่วงหน้าจะขยายการเรียกfunc2ไปยังคำสั่งที่เพิ่งอ่าน

    (-1);

และคอมไพเลอร์พาสจะเห็นเพียงคำสั่ง "ฟุ่มเฟือย" ที่ดูเหมือนจะรบกวนคุณ ยังมีอีกอย่างหนึ่งที่สามารถทำได้? หากคุณ#define do_stuff() // nothingแล้วรหัสในfunc1จะแตก (และคุณยังคงมีคำสั่งที่ว่างอยู่ในfunc2ที่เพิ่งอ่าน;ซึ่งอาจจะฟุ่มเฟือยมากขึ้น) ในทางกลับกันถ้าคุณต้องกำหนดdo_stuff()ฟังก์ชั่นที่ส่งกลับ -1 จริง ๆ คุณอาจต้องเสียค่าใช้จ่ายในการเรียกใช้ฟังก์ชัน ไม่มีเหตุผลที่ดี

ประโยคง่าย ๆ ใน C ถูกยกเลิกโดยเครื่องหมายอัฒภาค

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

ต้องบอกว่า "คอมไพเลอร์อัจฉริยะ" บางคนอาจทิ้ง 5; และฉัน; งบ

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

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

ตัวอย่างเช่นการเรียกใช้ฟังก์ชันเป็นการแสดงออกดังนั้นการเรียกใช้ฟังก์ชันตามด้วยเครื่องหมายอัฒภาคจึงเป็นข้อความ ข้อความนี้มีผลข้างเคียงหรือไม่?

some_function();

some_functionมันเป็นไปไม่ได้ที่จะบอกไม่เห็นการดำเนินงานของ

แล้วเรื่องนี้ล่ะ

obj;

อาจไม่ใช่ - แต่ถ้าobjกำหนดไว้เป็นอย่างvolatileนั้น

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

ข้อความสั่งที่คุณแสดงรายการโดยไม่มีผลกระทบเป็นตัวอย่างของข้อความสั่งนิพจน์ซึ่งมีไวยากรณ์ให้ไว้ในส่วน 6.8.3p1 ของมาตรฐาน Cดังนี้:

 คำสั่งexpression  :
    expression opt ;

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

ดังนั้นการแสดงออกใด ๆตามด้วยเครื่องหมายอัฒภาคจึงมีคุณสมบัติเป็นคำสั่งการแสดงออก ในความเป็นจริงแต่ละบรรทัดเหล่านี้จากรหัสของคุณเป็นตัวอย่างของคำสั่ง expression:

i = i + 2;
5;
i;
printf("i: %d\n", i);

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

นี่เป็นอีกตัวอย่าง:

atoi("1");

นี่คือการเรียกใช้ฟังก์ชันและยกเลิกผลลัพธ์เช่นเดียวกับการโทรprintfในตัวอย่างของคุณ แต่การprintfเรียกฟังก์ชันที่ไม่เหมือนกันนั้นจะไม่มีผลข้างเคียง

บางครั้งข้อความดังกล่าวมีประโยชน์มาก:

int foo(int x, int y, int z)
{
    (void)y;   //prevents warning
    (void)z;

    return x*x;
}

หรือเมื่อคู่มืออ้างอิงบอกให้เราอ่านทะเบียนเพื่อเก็บบางสิ่ง - ตัวอย่างเช่นเพื่อล้างหรือตั้งค่าสถานะบางอย่าง (สถานการณ์ทั่วไปในโลก uC)

#define SREG   ((volatile uint32_t *)0x4000000)
#define DREG   ((volatile uint32_t *)0x4004000)

void readSREG(void)
{
    *SREG;   //we read it here
    *DREG;   // and here
}

https://godbolt.org/z/6wjh_5