Sizeof (x ++) neden x değerini artırmıyor?

Dev c ++ pencerelerinde derlenen kod:

#include <stdio.h>

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

Not 1'ix uyguladıktan sonra 6 olmasını bekliyorum . Ancak, çıktı:

4 and 5

Herkes not 1x sonra neden artmıyor açıklayabilir ?

Gönderen C99 Standardı (vurgu bana ait)

6.5.3.4/2

Sizeof işleci, işleneninin boyutunu (bayt cinsinden) verir; bu, bir ifade veya parantezin adı olabilir. Boyut, işlenen türünden belirlenir. Sonuç bir tamsayıdır. İşlenen türü değişken uzunluklu dizi türü ise, işlenen değerlendirilir; aksi takdirde, işlenen değerlendirilmez ve sonuç bir tamsayı sabitidir.

sizeofBir olan derleme zamanı operatörü böylece derleme zamanında, sizeofve işlenen sonucu değerine ile yer değiştirirler. İşlenen bir değerlendirilmedi hiç (bir değişken uzunluklu dizi hariç); sadece sonucun türü önemlidir.

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

Çıktı:

2

olarak shortbenim makinemde 2 bayt kaplar.

İşlevin dönüş türünü şu şekilde değiştirmek double:

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

8çıktı olarak verecektir .

sizeof(foo) derleme zamanında bir ifadenin boyutunu bulmak gerçekten çok çalışır:

6.5.3.4:

Sizeof işleci, işleneninin boyutunu (bayt cinsinden) verir; bu, bir ifade veya parantezin adı olabilir. Boyut, işlenen türünden belirlenir. Sonuç bir tamsayıdır. İşlenen türü değişken uzunluklu dizi türü ise, işlenen değerlendirilir; aksi takdirde, işlenen değerlendirilmez ve sonuç bir tamsayı sabitidir.

Kısacası: değişken uzunluklu diziler, çalışma zamanında çalıştırın. (Not: Değişken uzunluk Diziler - dizileri ile ayrılan bir spesifik bir özelliği vardır malloc(3)Aksi takdirde, sadece.) Tipi derleme zamanında ifade hesaplanır ve bu.

sizeofderleme zamanı yerleşik bir işleçtir ve bir işlev değildir . Parantez olmadan kullanabileceğiniz durumlarda bu çok açıktır:

(sizeof x)  //this also works

Not

Bu cevap, geç tarihi açıklayan bir kopyadan birleştirildi.

orijinal

Değişken uzunluklu diziler hariç sizeof argümanlarını değerlendirmez. Biz taslak C99 standart bölümünden görebilirsiniz 6.5.3.4 sizeof operatörü paragraf 2 diyor ki:

Sizeof işleci, işleneninin boyutunu (bayt cinsinden) verir; bu, bir ifade veya parantezin adı olabilir. Boyut, işlenen türünden belirlenir. Sonuç bir tamsayıdır. İşlenen türü değişken uzunluklu dizi türü ise, işlenen değerlendirilir; aksi takdirde, işlenen değerlendirilmez ve sonuç bir tamsayı sabitidir.

Bir yorum ( şimdi kaldırıldı ), böyle bir şeyin çalışma zamanında değerlendirilip değerlendirilmeyeceğini sordu:

sizeof( char[x++]  ) ;

ve gerçekten de böyle bir şey işe yarayacaktır ( İkisini de canlı görün ):

sizeof( char[func()]  ) ;

çünkü ikisi de değişken uzunluklu dizilerdir. Her ikisinde de çok pratik kullanım görmüyorum.

Not, değişken uzunluklu diziler taslak C99 standart bölümünde 6.7.5.2 Dizi bildiricileri paragraf 4 kapsamındadır :

[...] Boyut bir tamsayı sabit ifadesiyse ve öğe türü bilinen bir sabit boyuta sahipse, dizi türü değişken uzunluklu bir dizi türü değildir; aksi takdirde, dizi türü değişken uzunluklu bir dizi türüdür.

Güncelleme

C11'de VLA vakası için cevap değişir, bazı durumlarda boyut ifadesinin değerlendirilip değerlendirilmediği belirtilmez. 6.7.6.2 Dizi bildiricileri bölümünden :

[...] Bir boyut ifadesinin bir sizeof operatörünün işlenmesinin bir parçası olduğu ve boyut ifadesinin değerinin değiştirilmesi operatörün sonucunu etkilemeyeceği durumlarda, boyut ifadesinin değerlendirilip değerlendirilmediği belirtilmez.

Örneğin böyle bir durumda ( canlı olarak görün ):

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

sizeofOperatörün işleneni değerlendirilmediğinden, bunu yapabilirsiniz:

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

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

Çevrimiçi demo: http://ideone.com/S8e2Y

Diğer bir deyişle, yalnızca fkullanıldıysa işlevi tanımlamanız gerekmez sizeof. Bu teknik çoğunlukla C ++ şablon meta programlamasında kullanılır;sizeof değerlendirilmez.

Bu neden işe yarıyor? Çalışır çünkü sizeofoperatör değer üzerinde çalışmaz bunun yerine çalışır, tip ifadesinin. Bu nedenle, yazdığınızda sizeof(f()), ifadenin türü üzerinde çalışır f()ve işlevin dönüş türünden başka bir şey değildirf . İşlev, gerçekte yürütülürse hangi değeri döndürürse döndürsün her zaman aynıdır.

C ++ 'da bunu bile yapabilirsiniz:

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

Yine de, sizeof ben ilk örneğini oluşturarak ediyorum, Ayazılı tarafından, A()işlevini çağırarak sonra ve fyazılı tarafından, örneğindeA().f() , ancak böyle bir şey oluyor.

Demo: http://ideone.com/egPMi

İşte diğer ilginç özelliklerini açıklayan başka bir konu sizeof:

• iki argüman alan sizeof

Derleme sırasında yürütme yapılamaz. Yani ++i/ i++olmayacak. Ayrıca sizeof(foo())işlevi yürütmez, ancak doğru türü döndürür.

sizeofderleme zamanında çalışır, ancak x++yalnızca çalışma zamanında değerlendirilebilir. Bunu çözmek için, C ++ standardı işleneninin sizeofdeğerlendirilmediğini belirtir . C Standardı diyor ki:

İşlenen [of sizeof] türü değişken uzunluklu bir dizi türü ise, işlenen değerlendirilir; aksi takdirde, işlenen değerlendirilmez ve sonuç bir tamsayı sabitidir.

sizeof() operatörü yalnızca veri türünün boyutunu verir, iç elemanları değerlendirmez.