sizeof operator

Consulta el tamaño del objeto o tipo.

Se utiliza cuando se debe conocer el tamaño real del objeto.

Sintaxis

El resultado de una expresión sizeof es una expresión constante de tipo std::size_t .

Notas

Dependiendo de la arquitectura del computador, un byte puede consistir de 8 o más bits, siendo el número exacto registrado en CHAR_BIT .

Las siguientes expresiones sizeof siempre se evalúan como 1 :

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

sizeof no puede utilizarse con tipos de función, tipos incompletos, o campos de bits lvalues (hasta C++11) glvalues (desde C++11) .

Cuando se aplica a un tipo de referencia, el resultado es el tamaño del tipo referenciado.

Cuando se aplica a un tipo de clase, el resultado es el número de bytes ocupados por un objeto completo de esa clase, incluyendo cualquier relleno adicional requerido para colocar dicho objeto en un array. El número de bytes ocupados por un subobjeto potencialmente superpuesto puede ser menor que el tamaño de ese objeto.

El resultado de sizeof siempre es distinto de cero, incluso si se aplica a un tipo de clase vacío.

Cuando se aplica a una expresión, sizeof no evalúa la expresión (es decir, la expresión es un operando no evaluado) (desde C++11) , e incluso si la expresión designa un objeto polimórfico, el resultado es el tamaño del tipo estático de la expresión. Las conversiones de lvalue-a-rvalue, array-a-puntero o función-a-puntero no se realizan. La materialización temporal , sin embargo, se realiza (formalmente) para argumentos prvalue: el programa está mal formado si el argumento no es destructible. (desde C++17)

Palabras clave

sizeof

Ejemplo

#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(); // el tipo de retorno es Empty, pero siempre lanza 1
    auto println = [](auto rem, std::size_t size) { std::cout << rem << size << '\n'; };
    println( "1) tamaño de clase vacía:              ", sizeof e                     );
    println( "2) tamaño de puntero:                  ", sizeof &e                    );
    println( "3) tamaño de clase (Bit):              ", sizeof(Bit)                  );
    println( "4) tamaño de int[10] (arreglo de 10 int): ", sizeof(int[10])              );
    println( "5) tamaño de a (arreglo de 10 int):     ", sizeof a                     );
    println( "6) longitud de arreglo de 10 int:       ", ((sizeof a) / (sizeof *a))   );
    println( "7) longitud de arreglo de 10 int (2):   ", ((sizeof a) / (sizeof a[0])) );
    println( "8) tamaño de la clase Derived:         ", sizeof d                     );
    println( "9) tamaño de Derived a través de Base: ", sizeof b                     );
    println( "A) tamaño de unsigned:                 ", sizeof(unsigned)             );
    println( "B) tamaño de int:                      ", sizeof(int)                  );
    println( "C) tamaño de short:                    ", sizeof(short)                );
    println( "D) tamaño de char:                     ", sizeof(char)                 );
    println( "E) tamaño de CharChar:                 ", sizeof(CharChar)             );
    println( "F) tamaño de CharCharInt:              ", sizeof(CharCharInt)          );
    println( "G) tamaño de IntCharChar:              ", sizeof(IntCharChar)          );
    println( "H) tamaño de CharIntChar:              ", sizeof(CharIntChar)          );
    println( "I) tamaño de CharShortChar:            ", sizeof(CharShortChar)        );
    println( "J) tamaño de f():                      ", sizeof f()                   );
    println( "K) tamaño de Base::a:                  ", sizeof Base::a               );
//  println( "tamaño de función:        ", sizeof(void()) ); // error
//  println( "tamaño de tipo incompleto: ", sizeof(int[])  ); // error
//  println( "tamaño de campo de bits:   ", sizeof bit.bit ); // error
}

1) sizeof clase vacía:              1
2) sizeof puntero:                  8
3) sizeof clase Bit:                4
4) sizeof matriz int[10] de 10 int: 40
5) sizeof matriz a        de 10 int: 40
6) longitud de matriz de 10 int:     10
7) longitud de matriz de 10 int (2): 10
8) sizeof clase Derivada:           8
9) sizeof Derivada a través de Base: 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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también