sizeof operator

Ermittelt die Größe des Objekts oder Typs.

Wird verwendet, wenn die tatsächliche Größe des Objekts bekannt sein muss.

Syntax

Das Ergebnis eines sizeof -Ausdrucks ist eine konstante Expression vom Typ std::size_t .

Hinweise

Abhängig von der Computerarchitektur kann ein Byte aus 8 oder mehr Bits bestehen, wobei die genaue Anzahl in CHAR_BIT festgehalten ist.

Die folgenden sizeof Ausdrücke ergeben immer 1 :

• sizeof ( char )
• sizeof ( signed char )
• sizeof ( unsigned char )

sizeof kann nicht mit Funktionstypen, unvollständigen Typen oder Bitfeld- Lvalues (bis C++11) Glvalues (seit C++11) verwendet werden.

Bei Anwendung auf einen Referenztyp ist das Ergebnis die Größe des referenzierten Typs.

Wenn auf einen Klassentyp angewendet, ist das Ergebnis die Anzahl der Bytes, die von einem vollständigen Objekt dieser Klasse belegt werden, einschließlich jeglicher zusätzlicher Auffüllung, die erforderlich ist, um ein solches Objekt in einem Array zu platzieren. Die Anzahl der Bytes, die von einem potenziell überlappenden Unterobjekt belegt werden, kann geringer sein als die Größe dieses Objekts.

Das Ergebnis von sizeof ist immer ungleich null, selbst wenn es auf einen leeren Klassentyp angewendet wird.

Wenn auf einen Ausdruck angewendet, sizeof wertet den Ausdruck nicht aus (d.h. der Ausdruck ist ein nicht ausgewerteter Operand) (seit C++11) , und selbst wenn der Ausdruck ein polymorphes Objekt bezeichnet, ist das Ergebnis die Größe des statischen Typs des Ausdrucks. Lvalue-zu-Rvalue-, Array-zu-Zeiger- oder Funktion-zu-Zeiger-Konvertierungen werden nicht durchgeführt. Temporäre Materialisierung wird jedoch (formal) für Prvalue-Argumente durchgeführt: Das Programm ist fehlerhaft, wenn das Argument nicht zerstörbar ist. (seit C++17)

Schlüsselwörter

sizeof

Beispiel

#include <cstdlib>
#include <iostream>
struct Empty          { };
struct Base           { int a; };
struct Derived : Base { int b; };
struct Bit            { unsigned bit: 1; };
struct CharChar       { char c; char c2; };
struct CharCharInt    { char c; char c2; int i; };
struct IntCharChar    { int i;  char c;  char c2; };
struct CharIntChar    { char c; int i;   char c2; };
struct CharShortChar  { char c; short s; char c2; };
int main()
{
    Empty e;
    Derived d;
    Base& b = d;
    [[maybe_unused]] Bit bit;
    int a[10];
    auto f = [&]() { return sizeof(int[10]) == sizeof a ? throw 1 : e; };
//  f(); // der Rückgabetyp ist Empty, wirft aber immer 1
    auto println = [](auto rem, std::size_t size) { std::cout << rem << size << '\n'; };
    println( "1) sizeof leere Klasse:              ", sizeof e                     );
    println( "2) sizeof Zeiger:                    ", sizeof &e                    );
    println( "3) sizeof(Bit) Klasse:               ", sizeof(Bit)                  );
    println( "4) sizeof(int[10]) Array von 10 int: ", sizeof(int[10])              );
    println( "5) sizeof a        Array von 10 int: ", sizeof a                     );
    println( "6) Länge des Arrays von 10 int:      ", ((sizeof a) / (sizeof *a))   );
    println( "7) Länge des Arrays von 10 int (2):  ", ((sizeof a) / (sizeof a[0])) );
    println( "8) sizeof der abgeleiteten Klasse:   ", sizeof d                     );
    println( "9) sizeof abgeleitet durch Basis:    ", sizeof b                     );
    println( "A) sizeof(unsigned):                ", sizeof(unsigned)             );
    println( "B) sizeof(int):                     ", sizeof(int)                  );
    println( "C) sizeof(short):                   ", sizeof(short)                );
    println( "D) sizeof(char):                    ", sizeof(char)                 );
    println( "E) sizeof(CharChar):                ", sizeof(CharChar)             );
    println( "F) sizeof(CharCharInt):             ", sizeof(CharCharInt)          );
    println( "G) sizeof(IntCharChar):             ", sizeof(IntCharChar)          );
    println( "H) sizeof(CharIntChar):             ", sizeof(CharIntChar)          );
    println( "I) sizeof(CharShortChar):           ", sizeof(CharShortChar)        );
    println( "J) sizeof f():                      ", sizeof f()                   );
    println( "K) sizeof Base::a:                  ", sizeof Base::a               );
//  println( "sizeof Funktion:        ", sizeof(void()) ); // Fehler
//  println( "sizeof unvollständiger Typ: ", sizeof(int[])  ); // Fehler
//  println( "sizeof Bitfeld:        ", sizeof bit.bit ); // Fehler
}

1) sizeof leere Klasse:              1
2) sizeof Zeiger:                    8
3) sizeof(Bit) Klasse:               4
4) sizeof(int[10]) Array von 10 int: 40
5) sizeof a        Array von 10 int: 40
6) Länge des Arrays von 10 int:      10
7) Länge des Arrays von 10 int (2):  10
8) sizeof der abgeleiteten Klasse:   8
9) sizeof der abgeleiteten Klasse über Basis: 4
A) sizeof(unsigned):                 4
B) sizeof(int):                      4
C) sizeof(short):                    2
D) sizeof(char):                     1
E) sizeof(CharChar):                 2
F) sizeof(CharCharInt):              8
G) sizeof(IntCharChar):              8
H) sizeof(CharIntChar):              12
I) sizeof(CharShortChar):            6
J) sizeof f():                       1
K) sizeof Base::a:                   4

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch