Warum erhöht sizeof (x ++) x nicht?

Hier ist der Code, der in Dev C ++ - Fenstern kompiliert wurde:

#include <stdio.h>

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

Ich erwarte x6 nach Ausführung von Note 1 . Die Ausgabe lautet jedoch:

4 and 5

Kann jemand erklären, warum xnicht nach Note 1 erhöht wird ?

Aus dem C99 Standard (der Schwerpunkt liegt bei mir)

6.5.3.4/2

Der Operator sizeof gibt die Größe (in Bytes) seines Operanden an, der ein Ausdruck oder der Name eines Typs in Klammern sein kann. Die Größe wird aus dem Typ des Operanden bestimmt. Das Ergebnis ist eine Ganzzahl. Wenn der Typ des Operanden ein Array-Typ variabler Länge ist, wird der Operand ausgewertet. Andernfalls wird der Operand nicht ausgewertet und das Ergebnis ist eine ganzzahlige Konstante.

sizeofist ein Operator zur Kompilierungszeit , daher werden zum Zeitpunkt der Kompilierung sizeofund seines Operanden durch den Ergebniswert ersetzt. Der Operand wird überhaupt nicht ausgewertet (außer wenn es sich um ein Array mit variabler Länge handelt). Nur die Art des Ergebnisses ist von Bedeutung.

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

Ausgabe:

2

as shortbelegt 2 Bytes auf meinem Computer.

Ändern des Rückgabetyps der Funktion in double:

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

wird 8als Ausgabe geben.

sizeof(foo) versucht wirklich, die Größe eines Ausdrucks beim Kompilieren zu ermitteln:

6.5.3.4:

Der Operator sizeof gibt die Größe (in Bytes) seines Operanden an, der ein Ausdruck oder der Name eines Typs in Klammern sein kann. Die Größe wird aus dem Typ des Operanden bestimmt. Das Ergebnis ist eine Ganzzahl. Wenn der Typ des Operanden ein Array-Typ variabler Länge ist, wird der Operand ausgewertet. Andernfalls wird der Operand nicht ausgewertet und das Ergebnis ist eine ganzzahlige Konstante.

Kurz gesagt: Arrays mit variabler Länge, die zur Laufzeit ausgeführt werden. (Hinweis: Arrays mit variabler Länge sind eine spezielle Funktion - keine Arrays, denen sie zugewiesen sind malloc(3).) Andernfalls wird nur der Typ des Ausdrucks berechnet, und zwar zur Kompilierungszeit.

sizeofist ein in die Kompilierungszeit eingebauter Operator und keine Funktion. Dies wird sehr deutlich, wenn Sie es ohne Klammern verwenden können:

(sizeof x)  //this also works

Hinweis

Diese Antwort wurde aus einem Duplikat zusammengeführt, das das späte Datum erklärt.

Original

Mit Ausnahme von Arrays mit variabler Länge wertet sizeof seine Argumente nicht aus. Wir können dies aus dem Entwurf des C99-Standardabschnitts 6.5.3.4 ersehen. Die Größe des Operators Absatz 2, der besagt:

Der Operator sizeof gibt die Größe (in Bytes) seines Operanden an, der ein Ausdruck oder der Name eines Typs in Klammern sein kann. Die Größe wird aus dem Typ des Operanden bestimmt. Das Ergebnis ist eine Ganzzahl. Wenn der Typ des Operanden ein Array-Typ variabler Länge ist, wird der Operand ausgewertet. Andernfalls wird der Operand nicht ausgewertet und das Ergebnis ist eine ganzzahlige Konstante.

In einem Kommentar ( jetzt entfernt ) wurde gefragt, ob so etwas zur Laufzeit ausgewertet werden würde:

sizeof( char[x++]  ) ;

und in der Tat würde so etwas auch funktionieren ( beide live sehen ):

sizeof( char[func()]  ) ;

da sie beide Arrays variabler Länge sind. Obwohl ich in beiden Fällen nicht viel praktischen Nutzen sehe.

Beachten Sie , variabler Länge Arrays werden in der überdachten Entwurf C99 - Standard Abschnitt 6.7.5.2 Array Deklaratoren Absatz 4 :

[...] Wenn die Größe ein ganzzahliger konstanter Ausdruck ist und der Elementtyp eine bekannte konstante Größe hat, ist der Array-Typ kein Array-Typ variabler Länge. Andernfalls ist der Array-Typ ein Array-Typ mit variabler Länge.

Aktualisieren

In C11 ändert sich die Antwort für den VLA-Fall. In bestimmten Fällen ist nicht angegeben, ob der Größenausdruck ausgewertet wird oder nicht. Aus dem Abschnitt 6.7.6.2 Array-Deklaratoren, der besagt:

[...] Wenn ein Größenausdruck Teil des Operanden eines Operators sizeof ist und das Ändern des Werts des Größenausdrucks das Ergebnis des Operators nicht beeinflusst, ist nicht angegeben, ob der Größenausdruck ausgewertet wird oder nicht.

Zum Beispiel in einem Fall wie diesem ( live sehen ):

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

Da der Operand des sizeofOperators nicht ausgewertet wird, können Sie Folgendes tun:

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

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

Online-Demo: http://ideone.com/S8e2Y

Das heißt, Sie müssen die Funktion nicht definieren, fwenn sie sizeofnur in verwendet wird. Diese Technik wird hauptsächlich bei der Metaprogrammierung von C ++ - Vorlagen verwendet, da selbst in C ++ der Operand von sizeofnicht ausgewertet wird.

Warum funktioniert das? Es funktioniert, weil der sizeofOperator nicht mit dem Wert arbeitet , sondern mit dem Typ des Ausdrucks. Wenn Sie also schreiben sizeof(f()), arbeitet es mit dem Typ des Ausdrucks f(), der nichts anderes als der Rückgabetyp der Funktion ist f. Der Rückgabetyp ist immer derselbe, unabhängig davon, welchen Wert die Funktion zurückgeben würde, wenn sie tatsächlich ausgeführt wird.

In C ++ können Sie sogar Folgendes tun:

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

Es sieht jedoch so aus sizeof, als würde ich zuerst eine Instanz von erstellen A, indem ich schreibe A()und dann die Funktion ffür die Instanz aufrufe, indem ich schreibe A().f(), aber so etwas passiert nicht.

Demo: http://ideone.com/egPMi

Hier ist ein weiteres Thema, das einige andere interessante Eigenschaften von erklärt sizeof:

• Größe von zwei Argumenten

Die Ausführung kann während der Kompilierung nicht erfolgen. Also ++i/ i++wird nicht passieren. Auch sizeof(foo())nicht die Funktion ausführen , aber richtige Art zurück.

sizeofwird zur Kompilierungszeit ausgeführt, x++kann jedoch nur zur Laufzeit ausgewertet werden. Um dies zu lösen, schreibt der C ++ - Standard vor, dass der Operand von sizeofnicht ausgewertet wird. Der C-Standard sagt:

Wenn der Typ des Operanden [von sizeof] ein Array-Typ variabler Länge ist, wird der Operand ausgewertet. Andernfalls wird der Operand nicht ausgewertet und das Ergebnis ist eine ganzzahlige Konstante.

sizeof() Der Operator gibt nur die Größe des Datentyps an und wertet keine inneren Elemente aus.