¿Puedo obtener el tamaño de un campo de estructura sin crear una instancia de la estructura?

Question

Es trivial obtener el tamaño del campo de una estructura en C++ si tiene una instancia de la estructura. P.ej. (Sin compilar):

typedef struct Foo { 
    int bar; 
    bool baz; 
} Foo; 

// ... 

Foo s; 
StoreInSomething(s.bar, sizeof(s.bar)); // easy as pie 

Ahora todavía se puede hacer algo como esto, pero con la interfaz estoy poniendo en práctica (I conseguir un BOOL que indica cuál debe ser el estado de un bit específico en un campo de bits), I Estaría creando la estructura únicamente para obtener el tamaño del miembro de datos. ¿Hay alguna manera de indicar al compilador que debe usar el tamaño del campo de una estructura sin crear una instancia de la estructura? Sería el equivalente filosófico de:

SetBit(bool val) { 
    StoreInSomething(
     BITFIELD_POSITION_CONSTANT, // position of bit being set 
     val,      // true = 1, false = 0 
     sizeof(Foo::bar));   // This is, of course, illegal. (The method I've been told I must use req's the size of the target field.) 
} 

Creación de la estructura en la pila debe ser rápido y barato, pero sospecho que me van a dinged para él en una revisión de código, por lo que estoy buscando una mejor manera que no introduce una carga de mantenimiento adicional (como #defines para tamaños).

Answer 1

Usted puede utilizar una expresión como:

sizeof Foo().bar 

Como no se evalúa el argumento de sizeof, única en su tipo, no es en realidad temporal creado.

Editar

Si no se Foo defecto construible (a diferencia de su ejemplo), que tendría que utilizar una expresión diferente, tal como uno que implica un puntero. (Gracias a Mike Seymour)

sizeof ((Foo*)0)->bar 

Answer 2

typedef struct Foo { 
    typedef BarType int; 
    BarType bar; 
    bool baz; 
} Foo; 

...

sizeof(Foo::BarType) 

Answer 3

Puede usar sizeof de con un puntero a la estructura. Considere algo como lo siguiente:

#include <stdio.h> 

typedef struct Foo { 
    char   cbar; 
    short  sbar; 
    int   bar; 
    bool   baz; 
    long long llbar; 
} Foo; 




int main (void) 
{ 
    struct Foo *p_foo = 0; 

    printf("Size of cbar: %d\n", sizeof(p_foo->cbar)); 
    printf("Size of sbar: %d\n", sizeof(p_foo->sbar)); 
    printf("Size of bar: %d\n", sizeof(p_foo->bar)); 
    printf("Size of baz: %d\n", sizeof(p_foo->baz)); 
    printf("Size of llbar: %d\n", sizeof(p_foo->llbar)); 
} 

que da resultados como:

163> size.exe 
Size of cbar: 1 
Size of sbar: 2 
Size of bar: 4 
Size of baz: 1 
Size of llbar: 8