¿Cómo sizeof trabajo para int tipos?

Question

Tengo un pequeño programa que compara

(1) sizeof, (2) numeric_limits::dígitos, (3) y los resultados de un bucle

en un esfuerzo para asegurarse de que todo el informe de la misma cosa con respecto a el tamaño de la "int tipos" en cualquier implementación en C++.Sin embargo, porque yo no sé acerca de las interioridades de sizeof, me pregunto si es sólo un informe de numeric_limits::dígitos.Gracias

Answer 1

Lo más probable sizeof() en la mayoría de los compiladores hace que el compilador para buscar el tipo dado (o tipo de objeto) en su interior el tipo de tabla e insertar un literal para que escriba el tamaño definido en el código que genera. Esto sucedería en tiempo de compilación, no en tiempo de ejecución.

Para responder a la pregunta en los comentarios, no hay ningún lenguaje de acceso definido para el compilador interna en C++ (fuera de cosas como sizeof() sí, por supuesto).El único lenguaje similar sé de que te permite hacer cosas como que es Ada, que proporciona ASIS para escribir el compilador de código independiente de las herramientas de análisis.

Answer 2

El sizeof el operador es un tiempo de compilación construir por el cual el compilador informa de que el tamaño, en bytes, que una instancia del tipo que va a ocupar en la memoria.

Es difícil dar un general", esta es la forma en sizeof obras" respuesta porque es específica para cada compilador de aplicación.En general a pesar de que se calcula el tamaño de cada campo de un tipo y sumándolas, mientras que la contabilidad para la alineación.

Por ejemplo, aquí es un conjunto razonable de salidas [1]

struct S1 {
  int field1;
  int field2;
};

struct S2 {
  int field1;
  bool field2;
  int field3;
}

sizeof(S1) == 8
sizeof(S2) == 12;

La razón por la que muchos compiladores del informe el tamaño de S2 12 frente a 9 es que se debe tener en cuenta los problemas de alineación y, por lo tanto, insertar 3 bytes para compensar la brecha entre field2 y field3

[1] Nota:Me dijo razonable no garantizada :).C compila tiene un montón de flexibilidad en tamaños y es casi imposible para el estado de detalles acerca de los tamaños sin saber el compilador que se está trabajando con

Answer 3

No hay muchos elementos internos a sizeof;es un operador integrado que indica el tamaño de su operando (ya sea de una expresión o de un tipo) en bytes.

El código es bastante complejo, y el uso de typeid me deja pensando...

Tengo un programa bilingüe (escrito en C subconjunto de C++) que produce respuestas tales como:

 1 = sizeof(char)
 1 = sizeof(unsigned char)
 2 = sizeof(short)
 2 = sizeof(unsigned short)
 4 = sizeof(int)
 4 = sizeof(unsigned int)
 8 = sizeof(long)
 8 = sizeof(unsigned long)
 4 = sizeof(float)
 8 = sizeof(double)
16 = sizeof(long double)
 8 = sizeof(size_t)
 8 = sizeof(ptrdiff_t)
 8 = sizeof(time_t)
 8 = sizeof(void *)
 8 = sizeof(char *)
 8 = sizeof(short *)
 8 = sizeof(int *)
 8 = sizeof(long *)
 8 = sizeof(float *)
 8 = sizeof(double *)
 8 = sizeof(int (*)(void))
 8 = sizeof(double (*)(void))
 8 = sizeof(char *(*)(void))
 1 = sizeof(struct { char a; })
 2 = sizeof(struct { short a; })
 4 = sizeof(struct { int a; })
 8 = sizeof(struct { long a; })
 4 = sizeof(struct { float a; })
 8 = sizeof(struct { double a; })
16 = sizeof(struct { char a; double b; })
16 = sizeof(struct { short a; double b; })
16 = sizeof(struct { long a; double b; })
 4 = sizeof(struct { char a; char b; short c; })
16 = sizeof(struct { char a; char b; long c; })
 4 = sizeof(struct { short a; short b; })
 6 = sizeof(struct { char a[3]; char b[3]; })
 8 = sizeof(struct { char a[3]; char b[3]; short c; })
16 = sizeof(struct { long double a; })
32 = sizeof(struct { char a; long double b; })

(Este fue producido por G++ 4.6.0 en mac Os X 10.6.7 - 64-bits compilación).El código que he usado es:

#ifdef __cplusplus
#define __STDC_CONSTANT_MACROS
#endif /* __cplusplus */

#include <stdio.h>
#include <time.h>
#include <stddef.h>
#if __STDC_VERSION__ >= 199901L || HAVE_INTTYPES_H
#include <inttypes.h>
#endif /* __STDC_VERSION__ */

/* Using the simple C code in SPRINT() for structures leads to complaints from G++ */
/* Using the code in TPRINT() for pointers to functions leads to other complaints */
#define TPRINT(x)   do { typedef x y; printf("%2u = sizeof(" #x ")\n", (unsigned int)sizeof(y)); } while (0)
#define SPRINT(x)   printf("%2u = sizeof(" #x ")\n", (unsigned int)sizeof(x))

int main(void)
{
    /* Basic Types */
    SPRINT(char);
    SPRINT(unsigned char);
    SPRINT(short);
    SPRINT(unsigned short);
    SPRINT(int);
    SPRINT(unsigned int);
    SPRINT(long);
    SPRINT(unsigned long);

    SPRINT(float);
    SPRINT(double);
    SPRINT(long double);
    SPRINT(size_t);
    SPRINT(ptrdiff_t);
    SPRINT(time_t);

    /* Fancy integers */
#if __STDC_VERSION__ >= 199901L || HAVE_LONG_LONG
    SPRINT(long long);
    SPRINT(unsigned long long);
#endif /* __STDC_VERSION__ || HAVE_LONG_LONG */
#if __STDC_VERSION__ >= 199901L || HAVE_INTTYPES_H
    SPRINT(uintmax_t);
#ifdef INT8_MAX
    SPRINT(int8_t);
#endif
#ifdef INT16_MAX
    SPRINT(int16_t);
#endif
#ifdef INT32_MAX
    SPRINT(int32_t);
#endif
#ifdef INT64_MAX
    SPRINT(int64_t);
#endif
#ifdef INT128_MAX
    SPRINT(int128_t);
#endif
    SPRINT(int_least8_t);
    SPRINT(int_least16_t);
    SPRINT(int_least32_t);
    SPRINT(int_least64_t);
    SPRINT(int_fast8_t);
    SPRINT(int_fast16_t);
    SPRINT(int_fast32_t);
    SPRINT(int_fast64_t);
    SPRINT(uintptr_t);
#endif /* __STDC_VERSION__ || HAVE_INTTYPES_H */

    /* Pointers */
    SPRINT(void *);
    SPRINT(char *);
    SPRINT(short *);
    SPRINT(int *);
    SPRINT(long *);
    SPRINT(float *);
    SPRINT(double *);

    /* Pointers to functions */
    SPRINT(int (*)(void));
    SPRINT(double (*)(void));
    SPRINT(char *(*)(void));

    /* Structures */
    TPRINT(struct { char a; });
    TPRINT(struct { short a; });
    TPRINT(struct { int a; });
    TPRINT(struct { long a; });
    TPRINT(struct { float a; });
    TPRINT(struct { double a; });
    TPRINT(struct { char a; double b; });
    TPRINT(struct { short a; double b; });
    TPRINT(struct { long a; double b; });
    TPRINT(struct { char a; char b; short c; });
    TPRINT(struct { char a; char b; long c; });
    TPRINT(struct { short a; short b; });
    TPRINT(struct { char a[3]; char b[3]; });
    TPRINT(struct { char a[3]; char b[3]; short c; });
    TPRINT(struct { long double a; });
    TPRINT(struct { char a; long double b; });
#if __STDC_VERSION__ >= 199901L || HAVE_LONG_LONG
    TPRINT(struct { char a; long long b; });
#endif /* __STDC_VERSION__ */
#if __STDC_VERSION__ >= 199901L || HAVE_INTTYPES_H
    TPRINT(struct { char a; uintmax_t b; });
#endif /* __STDC_VERSION__ || HAVE_INTTYPES_H */

    return(0);
}

No recuerdo exactamente por qué tenía que hacer el jugar con __STDC_CONSTANT_MACROS y SPRINT() vs TPRINT(), pero eso parecía ser lo que era necesario (en Marzo de 2010) para hacer que el código sea bilingüe.