เหตุใดขนาดของ (x ++) จึงไม่เพิ่มขึ้น x

นี่คือโค้ดที่คอมไพล์ใน windows dev c ++:

#include <stdio.h>

int main() {
    int x = 5;
    printf("%d and ", sizeof(x++)); // note 1
    printf("%d\n", x); // note 2
    return 0;
}

ผมคาดว่าxจะเป็น 6 หลังจากรัน1 ข้อความ อย่างไรก็ตามผลลัพธ์คือ:

4 and 5

ทุกคนสามารถอธิบายได้ว่าทำไมxไม่ได้เพิ่มขึ้นหลังจากที่ทราบ 1 ?

จากมาตรฐาน C99 (ความสำคัญคือของฉัน)

6.5.3.4/2

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

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

short func(short x) {  // this function never gets called !!
   printf("%d", x);    // this print never happens
   return x;
}

int main() {
   printf("%d", sizeof(func(3))); // all that matters to sizeof is the 
                                  // return type of the function.
   return 0;
}

เอาท์พุท:

2

เป็นshortหมกมุ่นอยู่ 2 ไบต์ในเครื่องของฉัน

การเปลี่ยนประเภทที่ส่งคืนของฟังก์ชันเป็นdouble:

double func(short x) {
// rest all same

จะให้8เป็นเอาท์พุท

sizeof(foo) พยายามอย่างหนักเพื่อค้นหาขนาดของนิพจน์ในเวลารวบรวม:

6.5.3.4:

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

ในระยะสั้น: อาร์เรย์ความยาวตัวแปรให้เรียกใช้ที่รันไทม์ (หมายเหตุ: Variable Length Araysเป็นคุณสมบัติเฉพาะ - ไม่ใช่อาร์เรย์ที่จัดสรรด้วยmalloc(3)) มิฉะนั้นเฉพาะประเภทของนิพจน์ที่คำนวณและในเวลารวบรวม

sizeofเป็นตัวดำเนินการ buildin เวลาคอมไพล์และไม่ใช่ฟังก์ชัน สิ่งนี้ชัดเจนมากในกรณีที่คุณสามารถใช้ได้โดยไม่ต้องใช้วงเล็บ:

(sizeof x)  //this also works

บันทึก

คำตอบนี้ถูกรวมเข้าด้วยกันจากคำซ้ำซึ่งอธิบายถึงวันที่ล่าช้า

เป็นต้นฉบับ

ยกเว้นอาร์เรย์ยาวตัวแปร sizeofไม่ได้ประเมินอาร์กิวเมนต์ เราสามารถดูได้จากส่วนมาตรฐาน C99 ฉบับร่างขนาด6.5.3.4 ตัวดำเนินการวรรค2ซึ่งระบุว่า:

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

ความคิดเห็น ( ตอนนี้ถูกลบ ) ถามว่าสิ่งนี้จะประเมินในเวลาทำงาน:

sizeof( char[x++]  ) ;

และแน่นอนว่ามันจะเป็นเช่นนี้เช่นกัน ( เห็นพวกเขาทั้งคู่มีชีวิตอยู่ ):

sizeof( char[func()]  ) ;

เนื่องจากทั้งสองเป็นอาร์เรย์ความยาวผันแปร แม้ว่าฉันจะไม่เห็นการใช้งานจริงมากนัก

หมายเหตุ: อาร์เรย์ความยาวผันแปรได้รับการกล่าวถึงในส่วนมาตรฐาน C99 ฉบับร่างส่วนผู้6.7.5.2 ประกาศอาร์เรย์วรรค 4 :

[... ] ถ้าขนาดเป็นนิพจน์ค่าคงที่จำนวนเต็มและชนิดองค์ประกอบมีขนาดค่าคงที่ที่รู้จักชนิดอาร์เรย์จะไม่เป็นชนิดอาร์เรย์ความยาวแปรผัน ไม่เช่นนั้นประเภทอาเรย์จะเป็นประเภทอาเรย์ที่มีความยาวผันแปรได้

ปรับปรุง

ใน C11 คำตอบจะเปลี่ยนไปสำหรับเคส VLA ในบางกรณีจะไม่มีการระบุว่าจะประเมินขนาดนิพจน์หรือไม่ จากส่วนผู้6.7.6.2 ประกาศอาร์เรย์ซึ่งพูดว่า:

[... ] ที่นิพจน์ขนาดเป็นส่วนหนึ่งของตัวถูกดำเนินการของตัวดำเนินการ sizeof และการเปลี่ยนค่าของขนาดนิพจน์จะไม่ส่งผลกระทบต่อผลลัพธ์ของตัวดำเนินการ

ตัวอย่างเช่นในกรณีเช่นนี้ ( ดูสด ):

sizeof( int (*)[x++] )

เนื่องจากตัวดำเนินการของsizeofตัวดำเนินการไม่ได้รับการประเมินคุณสามารถทำได้:

int f(); //no definition, which means we cannot call it

int main(void) {
        printf("%d", sizeof(f()) );  //no linker error
        return 0;
}

การสาธิตออนไลน์: http://ideone.com/S8e2Y

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

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

ใน C ++ คุณสามารถทำได้:

struct A
{
  A(); //no definition, which means we cannot create instance!
  int f(); //no definition, which means we cannot call it
};

int main() {
        std::cout << sizeof(A().f())<< std::endl;
        return 0;
}

แต่ดูเหมือนว่าในsizeofครั้งแรกที่ฉันสร้างอินสแตนซ์AโดยการเขียนA()แล้วเรียกใช้ฟังก์ชันfบนอินสแตนซ์โดยการเขียนA().f()แต่ไม่มีสิ่งใดเกิดขึ้น

ตัวอย่าง: http://ideone.com/egPMi

นี่คือหัวข้อที่อธิบายคุณสมบัติที่น่าสนใจอื่น ๆ ของsizeof:

• sizeof รับสองข้อโต้แย้ง

การดำเนินการไม่สามารถเกิดขึ้นได้ในระหว่างการรวบรวม ดังนั้น++i/ i++จะไม่เกิดขึ้น นอกจากนี้sizeof(foo())จะไม่ดำเนินการฟังก์ชั่น แต่กลับประเภทที่ถูกต้อง

sizeofรันที่คอมไพล์เวลา แต่x++สามารถประเมินได้ในเวลาทำงานเท่านั้น ในการแก้ปัญหานี้มาตรฐาน C ++ กำหนดว่าตัวถูกดำเนินการsizeofไม่ได้รับการประเมิน The C Standard พูดว่า:

หากชนิดของตัวถูกดำเนินการ [ของsizeof] เป็นชนิดอาร์เรย์ความยาวผันแปรตัวถูกดำเนินการจะถูกประเมิน มิฉะนั้นตัวถูกดำเนินการไม่ได้รับการประเมินและผลที่ได้คือค่าคงที่จำนวนเต็ม

sizeof() ผู้ประกอบการให้ขนาดของประเภทข้อมูลเท่านั้นมันไม่ได้ประเมินองค์ประกอบด้านใน