Mengapa sizeof (x ++) tidak bertambah x?

Berikut adalah kode yang dikompilasi di dev c ++ windows:

#include <stdio.h>

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

Saya berharap xmenjadi 6 setelah mengeksekusi catatan 1 . Namun, hasilnya adalah:

4 and 5

Adakah yang bisa menjelaskan mengapa xtidak naik setelah catatan 1 ?

Dari Standar C99 (penekanannya adalah milik saya)

6.5.3.4/2

Ukuran operator menghasilkan ukuran (dalam byte) dari operandnya, yang dapat berupa ekspresi atau nama yang dikurung dalam suatu tipe. Ukurannya ditentukan dari jenis operan. Hasilnya adalah bilangan bulat. Jika jenis operan adalah jenis array panjang variabel, operan dievaluasi; jika tidak, operan tidak dievaluasi dan hasilnya adalah konstanta integer.

sizeofadalah operator waktu kompilasi , jadi pada saat kompilasi sizeofdan operasinya digantikan oleh nilai hasil. The operan tidak dievaluasi (kecuali bila itu adalah panjang variabel array) sama sekali; hanya jenis hasilnya yang penting.

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;
}

Keluaran:

2

sebagai shortmenempati 2 byte pada mesin saya.

Mengubah jenis fungsi yang dikembalikan ke double:

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

akan memberikan 8sebagai output.

sizeof(foo) berusaha sangat keras untuk menemukan ukuran ekspresi pada waktu kompilasi:

6.5.3.4:

Ukuran operator menghasilkan ukuran (dalam byte) dari operandnya, yang dapat berupa ekspresi atau nama yang dikurung dalam suatu tipe. Ukurannya ditentukan dari jenis operan. Hasilnya adalah bilangan bulat. Jika jenis operan adalah jenis array panjang variabel, operan dievaluasi; jika tidak, operan tidak dievaluasi dan hasilnya adalah konstanta integer.

Singkatnya: array panjang variabel, jalankan saat runtime. (Catatan: Array Panjang Variabel adalah fitur khusus - bukan array yang dialokasikan dengan malloc(3).) Jika tidak, hanya jenis ekspresi yang dihitung, dan pada waktu kompilasi.

sizeofadalah operator built-time kompilasi dan bukan fungsi. Ini menjadi sangat jelas dalam kasus Anda dapat menggunakannya tanpa tanda kurung:

(sizeof x)  //this also works

Catatan

Jawaban ini digabungkan dari duplikat, yang menjelaskan tanggal terakhir.

Asli

Kecuali untuk array panjang variabel, sizeof tidak mengevaluasi argumennya. Kita bisa melihat ini dari draft bagian standar C99 6.5.3.4 Ukuran operator paragraf 2 yang mengatakan:

Ukuran operator menghasilkan ukuran (dalam byte) dari operandnya, yang dapat berupa ekspresi atau nama yang dikurung dalam suatu tipe. Ukurannya ditentukan dari jenis operan. Hasilnya adalah bilangan bulat. Jika jenis operan adalah jenis array panjang variabel, operan dievaluasi; jika tidak, operan tidak dievaluasi dan hasilnya adalah konstanta integer.

Sebuah komentar ( sekarang dihapus ) bertanya apakah sesuatu seperti ini akan dievaluasi saat berjalan:

sizeof( char[x++]  ) ;

dan memang itu akan terjadi, sesuatu seperti ini juga akan berhasil ( Lihat mereka berdua hidup ):

sizeof( char[func()]  ) ;

karena keduanya adalah array panjang variabel. Meskipun, saya tidak melihat banyak kegunaan praktis di salah satu.

Catatan, array panjang variabel dicakup dalam rancangan bagian standar C99 Deklarator 6.7.5.2 array paragraf 4 :

[...] Jika ukurannya adalah ekspresi konstanta integer dan tipe elemen memiliki ukuran konstan yang diketahui, tipe array bukanlah tipe array panjang variabel; jika tidak, tipe array adalah tipe array panjang variabel.

Memperbarui

Di C11 jawaban berubah untuk kasus VLA, dalam kasus-kasus tertentu tidak ditentukan apakah ekspresi ukuran dievaluasi atau tidak. Dari bagian 6.7.6.2 deklarasi Array yang berbunyi:

[...] Jika ekspresi ukuran adalah bagian dari operan ukuran operator dan mengubah nilai ekspresi ukuran tidak akan mempengaruhi hasil operator, itu tidak ditentukan apakah ekspresi ukuran dievaluasi atau tidak.

Misalnya dalam kasus seperti ini ( lihat langsung ):

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

Karena operan sizeofoperator tidak dievaluasi, Anda dapat melakukan ini:

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

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

Demo online: http://ideone.com/S8e2Y

Artinya, Anda tidak perlu mendefinisikan fungsi fjika hanya digunakan sizeof. Teknik ini banyak digunakan dalam metaprogramming template C ++, karena bahkan dalam C ++, operan sizeoftidak dievaluasi.

Mengapa ini bekerja? Ini bekerja karena sizeofoperator tidak beroperasi pada nilai , melainkan beroperasi pada jenis ekspresi. Jadi ketika Anda menulis sizeof(f()), ini beroperasi pada tipe ekspresi f(), dan yang tidak lain adalah tipe kembalinya fungsi f. Jenis kembali selalu sama, tidak peduli berapa nilai fungsi akan kembali jika itu benar-benar dijalankan.

Di C ++, Anda dapat meratakan ini:

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;
}

Namun sepertinya, dalam sizeof, saya pertama kali membuat contoh A, dengan menulis A(), dan kemudian memanggil fungsif pada contoh, dengan menulis A().f(), tetapi tidak ada hal seperti itu terjadi.

Demo: http://ideone.com/egPMi

Berikut adalah topik lain yang menjelaskan beberapa sifat menarik lainnya dari sizeof:

• sizeof mengambil dua argumen

Eksekusi tidak dapat terjadi selama kompilasi. Jadi ++i/ i++tidak akan terjadi. Juga sizeof(foo())tidak akan menjalankan fungsi tetapi mengembalikan tipe yang benar.

sizeofberjalan pada waktu kompilasi, tetapi x++hanya dapat dievaluasi pada saat dijalankan. Untuk mengatasi ini, standar C ++ menentukan bahwa operan sizeoftidak dievaluasi. Standar C mengatakan:

Jika tipe operan sizeofadalah tipe array panjang variabel, operan dievaluasi; jika tidak, operan tidak dievaluasi dan hasilnya adalah konstanta integer.

sizeof() operator memberikan ukuran tipe data saja, tidak mengevaluasi elemen dalam.