Visual C++ equivalente de __attribute__ de GCC ((__packed__))

Question

Para algunos compiladores, hay un especificador de relleno para estructuras, por ejemplo ::

 
RealView ARM compiler has "__packed" 
Gnu C Compiler has "__attribute__ ((__packed__))" 
Visual C++ has no equivalent, it only has the "#pragma pack(1)" 

Necesito algo que me puedo poner en la definición struct .

¿Alguna información/truco/sugerencia? TIA ...

Answer 1

no sé una forma de mancha de hacerlo, pero lo que pueda hacer algo horrible como esto:

#include "packed.h" 
struct Foo { /* members go here */ } PACKED; 
#include "endpacked.h" 

Luego de MSVC, packed.h:

#define PACKED 
#pragma pack(push,1) 

endpacked. h

#pragma pack(pop) 
#undef PACKED 

Para gcc, packed.h:

#define PACKED __attribute__ ((__packed__)) 

endpacked.h:

#undef PACKED 

Fundamentalmente, el embalaje es demasiado dependiente de la plataforma. Supongamos que su estructura empaquetada tiene campos de 8 bits y considera algún sistema con un byte de 16 bits. No puede tener una estructura que represente los datos simplemente empaquetando; debería saber cómo los bytes de 8 bits se convierten en bytes de 16 bits cuando se transfieren entre los dos sistemas. La estructura en la máquina de 16 bits puede necesitar campos de bits, en cuyo caso debe saber cómo la implementación los establece.

Por lo tanto, si el código está destinado a ser generalmente portátil, puede que simplemente tenga que definir las estructuras empaquetadas que necesita en una sección específica de la plataforma de su archivo de encabezado. O más bien, estructure su código para que un puerto futuro pueda hacer eso si es necesario.

Answer 2

¿Por qué necesitas algo para entrar en la estructura?

Creo que #pragma pack(1) es lo mismo o me estoy perdiendo algo?

Usted puede hacer esto:

struct Foo 
{ 
#pragma pack(push, 1) 
int Bar; 
#pragma pack(pop) 
}; 

Pero se ve feo.

Answer 3

Puede definir PAQUETE como este para GNU gcc

#define PACK(__Declaration__) __Declaration__ __attribute__((__packed__)) 

y como este para Visual C++:

#define PACK(__Declaration__) __pragma(pack(push, 1)) __Declaration__ __pragma(pack(pop)) 

Y utilizar de esta manera:

PACK(
struct myStruct 
{ 
    int a; 
    int b; 
}); 

Answer 4

Sé que esto la pregunta es vieja ahora, pero creo que hay una solución mejor que las publicadas anteriormente. Es posible poner el pragma en el caso de MSVC en la línea de declaración de estructura después de todo.Considere lo siguiente:

#ifdef _MSC_VER 
# define PACKED_STRUCT(name) \ 
    __pragma(pack(push, 1)) struct name __pragma(pack(pop)) 
#elif defined(__GNUC__) 
# define PACKED_STRUCT(name) struct __attribute__((packed)) name 
#endif 

Entonces esto puede ser usado de esta manera:

typedef PACKED_STRUCT() { short a; int b } my_struct_t; 
PACKED_SRUCT(my_other_struct) { short a; int b }; 

etc.

La clave aquí es que el uso de la __pragma sólo tiene que ser alrededor de la línea de declaración de la estructura Esto necesita incluir el nombre de la estructura si se le da uno, de ahí que el nombre sea un parámetro para la macro. Por supuesto, esto es fácil de extender a enum/class, ¡que dejaré como ejercicio para el lector!

El programa de prueba en el pack documentation MSDN page es útil para verificar esto.

EDITAR

Resulta que en mi prueba de que estaba usando el compilador de Intel en Windows. Usando icl.exe, este enfoque funciona sin problemas, pero con el compilador de Microsoft (cl.exe), no (probado con 2010 y 2013).

Answer 5

Otra solución, según los compiladores que necesita admitir, consiste en observar que GCC ha admitido los pragmas de empaquetado al estilo Microsoft al menos desde la versión 4.0.4 (la documentación en línea está disponible en gnu.org para las versiones 3.4.6 y 4.0.4 - los pragmas no se describen en el primero y están en este último). Esto le permite simplemente usar #pragma pack(push,1) antes de una definición de estructura y #pragma pack(pop) después de la definición y se compilará en cualquiera de ellos.

Answer 6

Puede hacerlo al revés, ya que GCC es compatible con los pragmas relacionados con el paquete VC++. Mire here para más información.

Extraer ...

Para compatibilidad con los compiladores de Microsoft Windows, GCC soporta un conjunto de #pragma directivas que cambian el alineamiento máximo de miembros del estructuras (que no sean campos de bits de ancho cero), los sindicatos, y las clases definidas posteriormente. Siempre se requiere que el valor n de debajo sea una pequeña potencia de y especifica la nueva alineación en bytes.

#pragma pack(n) simplemente establece la nueva alineación.

#pragma pack() establece la alineación a la que estaba en vigor cuando se inició la compilación (ver opción de línea de comando también -fpack-struct[=<n>] ver Opciones Código GEN).

#pragma pack(push[,n]) empuja la configuración de alineación actual en una pila interna y luego establece opcionalmente la nueva alineación.

#pragma pack(pop) restaura la configuración de alineación a la guardada en la parte superior de la pila interna (y elimina esa entrada de la pila).

Tenga en cuenta que #pragma pack([n]) no influye en esta pila interna; por lo que es posible tener #pragma pack(push) seguido de múltiples #pragma pack(n) instancias y finalizado por un solo #pragma pack(pop).

Algunos objetivos, p.i386 y powerpc, admite el ms_struct#pragma que establece una estructura como la documentada __attribute__((ms_struct)).

#pragma ms_struct on activa el diseño de las estructuras declaradas.

#pragma ms_struct off desactiva el diseño de las estructuras declaradas.

#pragma ms_struct reset vuelve al diseño predeterminado.