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

No sé una mancha de la manera de hacerlo, pero se podría hacer algo tan terrible como esto:

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

A continuación, para MSVC, lleno de.h:

#define PACKED
#pragma pack(push,1)

endpacked.h

#pragma pack(pop)
#undef PACKED

Para gcc, lleno de.h:

#define PACKED __attribute__ ((__packed__))

endpacked.h:

#undef PACKED

Fundamentalmente, el embalaje es demasiado dependiente de la plataforma. Supongamos que el empaque de tu estructura es de 8 bits de los campos, y considerar algunos con un sistema de 16 bits byte. No puede tener una estructura que representa los datos sólo por embalaje – tendrías que saber cómo de 8 bits, bytes son convertidos a 16 bits, bytes cuando se transfieren entre los dos sistemas. La estructura en la 16 bits de la máquina puede ser que necesite campos de bits, en cuyo caso tendrías que saber cómo la aplicación dispone.

Así que si el código está destinado a ser generalmente portátil, usted sólo tiene que definir lo que sea lleno de estructuras que usted necesita en una plataforma específica de la sección de encabezado de archivo. O más bien, la estructura de su código para que un futuro puerto puede hacer eso si tiene que ser así.

Puede definir PACK 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 utilizarlo como este:

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

Sé que esta pregunta es viejo ahora, pero creo que hay una mejor solución que los publicados anteriormente. Es posible poner el pragma en el MSVC caso en la declaración struct línea, 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 utilizado como:

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 necesita estar cerca de la línea de declaración de la estructura. Esto debe incluir la estructura struct nombre si se da uno, de ahí el nombre de un parámetro de la macro. Por supuesto, esto es fácil de extender enum/clase, que te dejo como ejercicio para el lector!

El programa de prueba en el paquete de documentación de la página de MSDN es útil para comprobar esto.

EDITAR

Resulta que en mis pruebas de que estaba usando el Compilador de Intel en Windows. El uso de icl.exe este enfoque funciona sin problema, pero con el compilador de Microsoft (cl.exe), no (probado con 2010 y 2013).

Que usted puede hacer al revés, ya GCC apoya el VC++ pack relacionados con pragmas. Buscar aquí para obtener más información.

Extraer…

Para la compatibilidad con Microsoft Windows compiladores GCC admite un conjunto
de #pragma directivas que cambiar el número máximo de alineación de los miembros de
estructuras (distinto de cero-el ancho de los campos de bits), los sindicatos y las clases
posteriormente se define. El valor de n a continuación siempre que se requiere para ser un
de pequeña potencia de dos y especifica la nueva alineación de bytes.

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

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

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

#pragma pack(pop) restaura la configuración de alineación a la que uno guarda en
la parte superior de la pila interna (y lo elimina de la pila de entrada).

Nota que #pragma pack([n]) no influye en esta pila interna;
por lo tanto es posible tener #pragma pack(push) seguido por varios
#pragma pack(n) instancias y finalizado por un solo #pragma pack(pop).

Algunos de los objetivos, por ejemplo, i386 y powerpc, de apoyo a la ms_struct #pragma
el cual establece una estructura como la documentada __attribute__((ms_struct)).

#pragma ms_struct on activa en el diseño de las estructuras, declaró.

#pragma ms_struct off apaga el diseño de estructuras declarado.

#pragma ms_struct reset vuelve a la configuración por defecto.

Otra solución, en función de lo que los compiladores necesita apoyo, es un aviso de que GCC ha apoyado el Microsoft-estilo de embalaje pragmas, 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 antiguo y en el segundo caso). Esto permite que usted sólo tiene que utilizar #pragma pack(push,1) antes de una definición de la estructura y #pragma pack(pop) después de la definición y se compilará en cualquiera de los dos.

Qué necesitas algo para ir en la estructura?

Creo #pragma pack(1) es el 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.