align (C++)align (C++)

En Visual Studio 2015 y versiones posteriores, use el especificador estándar de C++ 11 alignas para controlar la alineación.In Visual Studio 2015 and later, use the C++11 standard alignas specifier to control alignment. Para obtener más información, vea alignment.For more information, see Alignment.

Específicos de MicrosoftMicrosoft Specific

Use __declspec(align(#)) para controlar con precisión la alineación de datos definidos por el usuario (por ejemplo, asignaciones estáticas o datos automáticos en una función).Use __declspec(align(#)) to precisely control the alignment of user-defined data (for example, static allocations or automatic data in a function).

SintaxisSyntax

declarador __declspec (Align ( # )) declarator__declspec( align( # ) ) declarator

ObservacionesRemarks

Las aplicaciones de escritura que utilizan las últimas instrucciones de procesador presentan nuevas restricciones y problemas.Writing applications that use the latest processor instructions introduces some new constraints and issues. Muchas instrucciones nuevas requieren datos que se alineen con límites de 16 bytes.Many new instructions require data that's aligned to 16-byte boundaries. Además, al alinear los datos usados con frecuencia en el tamaño de la línea de caché del procesador, se mejora el rendimiento de la memoria caché.Additionally, by aligning frequently used data to the processor's cache line size, you improve cache performance. Por ejemplo, si define una estructura cuyo tamaño es inferior a 32 bytes, es posible que desee una alineación de 32 bytes para asegurarse de que los objetos de ese tipo de estructura se almacenan en caché de forma eficaz.For example, if you define a structure whose size is less than 32 bytes, you may want 32 byte alignment to make sure that objects of that structure type are efficiently cached.

#es el valor de alineación.# is the alignment value. Las entradas válidas son potencias enteras de dos desde 1 hasta 8192 (bytes), como 2, 4, 8, 16, 32 o 64.Valid entries are integer powers of two from 1 to 8192 (bytes), such as 2, 4, 8, 16, 32, or 64. declaratorson los datos que se están declarando como alineados.declarator is the data that you're declaring as aligned.

Para obtener información sobre cómo devolver un valor de tipo size_t que es el requisito de alineación del tipo, vea alignof .For information about how to return a value of type size_t that is the alignment requirement of the type, see alignof. Para obtener información sobre cómo declarar punteros no alineados al establecer como destino procesadores de 64 bits, vea __unaligned .For information about how to declare unaligned pointers when targeting 64-bit processors, see __unaligned.

Puede usar __declspec(align(#)) cuando defina struct , union o class , o cuando declare una variable.You can use __declspec(align(#)) when you define a struct, union, or class, or when you declare a variable.

El compilador no garantiza ni intenta conservar el atributo de alineación de los datos durante una operación de copia o transformación de datos.The compiler doesn't guarantee or attempt to preserve the alignment attribute of data during a copy or data transform operation. Por ejemplo, memcpy puede copiar un struct declarado con __declspec(align(#)) en cualquier ubicación.For example, memcpy can copy a struct declared with __declspec(align(#)) to any location. Los asignadores ordinarios (por ejemplo, malloc , C++ operator new y los asignadores de Win32) normalmente devuelven memoria que no está suficientemente alineada para __declspec(align(#)) estructuras o matrices de estructuras.Ordinary allocators (for example, malloc, C++ operator new, and the Win32 allocators) typically return memory that isn't sufficiently aligned for __declspec(align(#)) structures or arrays of structures. Para garantizar que el destino de una operación de transformación de datos o copia está correctamente alineado, use _aligned_malloc .To guarantee that the destination of a copy or data transformation operation is correctly aligned, use _aligned_malloc. O bien, escriba su propio asignador.Or, write your own allocator.

No se puede especificar la alineación de los parámetros de función.You can't specify alignment for function parameters. Al pasar datos que tienen un atributo Alignment por valor en la pila, la alineación se controla mediante la Convención de llamada.When you pass data that has an alignment attribute by value on the stack, its alignment is controlled by the calling convention. Si la alineación de los datos es importante en la función llamada, copie el parámetro en la memoria alineada correctamente antes de su uso.If data alignment is important in the called function, copy the parameter into correctly aligned memory before use.

Sin __declspec(align(#)) , el compilador generalmente alinea los datos en los límites naturales según el procesador de destino y el tamaño de los datos, hasta los límites de 4 bytes en los procesadores de 32 bits y los límites de 8 bytes en procesadores de 64 bits.Without __declspec(align(#)), the compiler generally aligns data on natural boundaries based on the target processor and the size of the data, up to 4-byte boundaries on 32-bit processors, and 8-byte boundaries on 64-bit processors. Los datos de las clases o estructuras se alinean en la clase o estructura en el mínimo de su alineación natural y el valor de empaquetado actual (de #pragma pack o la /Zp opción del compilador).Data in classes or structures is aligned in the class or structure at the minimum of its natural alignment and the current packing setting (from #pragma pack or the /Zp compiler option).

Este ejemplo muestra el uso de __declspec(align(#)):This example demonstrates the use of __declspec(align(#)):

__declspec(align(32)) struct Str1{
   int a, b, c, d, e;
};

Ahora, este tipo tiene un atributo de alineación de 32 bytes.This type now has a 32-byte alignment attribute. Significa que todas las instancias estáticas y automáticas se inician en un límite de 32 bytes.It means that all static and automatic instances start on a 32-byte boundary. Los tipos de estructura adicionales declarados con este tipo como un miembro conservan el atributo de alineación de este tipo, es decir, cualquier estructura con Str1 como un elemento tiene un atributo de alineación de al menos 32.Additional structure types declared with this type as a member preserve this type's alignment attribute, that is, any structure with Str1 as an element has an alignment attribute of at least 32.

Aquí, sizeof(struct Str1) es igual a 32.Here, sizeof(struct Str1) is equal to 32. Implica que, si se crea una matriz de Str1 objetos y la base de la matriz tiene una alineación de 32 bytes, cada miembro de la matriz también tiene una alineación de 32 bytes.It implies that if an array of Str1 objects is created, and the base of the array is 32-byte aligned, each member of the array is also 32-byte aligned. Para crear una matriz cuya base esté alineada correctamente en la memoria dinámica, use _aligned_malloc .To create an array whose base is correctly aligned in dynamic memory, use _aligned_malloc. O bien, escriba su propio asignador.Or, write your own allocator.

El sizeof valor de cualquier estructura es el desplazamiento del miembro final, más el tamaño de ese miembro, redondeado al múltiplo más próximo del mayor valor de alineación de miembros o del valor de alineación de estructura completo, el que sea mayor.The sizeof value for any structure is the offset of the final member, plus that member's size, rounded up to the nearest multiple of the largest member alignment value or the whole structure alignment value, whichever is larger.

El compilador utiliza estas reglas para la alineación de la estructura:The compiler uses these rules for structure alignment:

  • A menos que se reemplace con __declspec(align(#)), la alineación de un miembro de estructura escalar es el mínimo de su tamaño y empaquetado actual.Unless overridden with __declspec(align(#)), the alignment of a scalar structure member is the minimum of its size and the current packing.

  • A menos que se reemplace con __declspec(align(#)), la alineación de una estructura es el máximo de las alineaciones individuales de sus miembros.Unless overridden with __declspec(align(#)), the alignment of a structure is the maximum of the individual alignments of its member(s).

  • Un miembro de estructura se coloca en un desplazamiento desde el inicio de su estructura primaria que es el múltiplo más pequeño de su alineación mayor o igual que el desplazamiento del final del miembro anterior.A structure member is placed at an offset from the start of its parent structure that's the smallest multiple of its alignment greater than or equal to the offset of the end of the previous member.

  • El tamaño de una estructura es el múltiplo más pequeño de su alineación, que es mayor o igual que el desplazamiento del final de su último miembro.The size of a structure is the smallest multiple of its alignment greater than or equal to the offset of the end of its last member.

__declspec(align(#)) solo puede aumentar restricciones de alineación.__declspec(align(#)) can only increase alignment restrictions.

Para más información, consulte:For more information, see:

Ejemplos de alignalign Examples

En los ejemplos siguientes se muestra cómo __declspec(align(#)) afecta al tamaño y la alineación de estructuras de datos.The following examples show how __declspec(align(#)) affects the size and alignment of data structures. En los ejemplos se suponen las definiciones siguientes:The examples assume the following definitions:

#define CACHE_LINE  32
#define CACHE_ALIGN __declspec(align(CACHE_LINE))

En este ejemplo, la S1 estructura se define mediante el uso de __declspec(align(32)).In this example, the S1 structure is defined by using __declspec(align(32)). Todos los usos de S1 para una definición de variable o en otro tipo de declaraciones tienen una alineación de 32 bytes.All uses of S1 for a variable definition or in other type declarations are 32-byte aligned. sizeof(struct S1) devuelve 32 y S1 tiene 16 bytes de relleno a continuación de los 16 bytes necesarios para contener los cuatro enteros.sizeof(struct S1) returns 32, and S1 has 16 padding bytes following the 16 bytes required to hold the four integers. Cada int miembro requiere una alineación de 4 bytes, pero la alineación de la propia estructura se declara como 32.Each int member requires 4-byte alignment, but the alignment of the structure itself is declared to be 32. La alineación general es 32.Then the overall alignment is 32.

struct CACHE_ALIGN S1 { // cache align all instances of S1
   int a, b, c, d;
};
struct S1 s1;   // s1 is 32-byte cache aligned

En este ejemplo, sizeof(struct S2) devuelve 16, que es exactamente la suma de los tamaños de miembro, porque es un múltiplo del mayor requisito de alineación (un múltiplo de 8).In this example, sizeof(struct S2) returns 16, which is exactly the sum of the member sizes, because that is a multiple of the largest alignment requirement (a multiple of 8).

__declspec(align(8)) struct S2 {
   int a, b, c, d;
};

En el ejemplo siguiente, sizeof(struct S3) devuelve 64.In the following example, sizeof(struct S3) returns 64.

struct S3 {
   struct S1 s1;   // S3 inherits cache alignment requirement
                  // from S1 declaration
   int a;         // a is now cache aligned because of s1
                  // 28 bytes of trailing padding
};

En este ejemplo, observe que a tiene la alineación de su tipo natural, en este caso, 4 bytes.In this example, notice that a has the alignment of its natural type, in this case, 4 bytes. Sin embargo, S1 debe tener una alineación de 32 bytes.However, S1 must be 32-byte aligned. 28 bytes de relleno siguientes a : s1 empieza en el desplazamiento 32.28 bytes of padding follow a, so that s1 starts at offset 32. S4hereda el requisito de alineación de S1 , porque es el requisito de alineación mayor de la estructura.S4 then inherits the alignment requirement of S1, because it's the largest alignment requirement in the structure. sizeof(struct S4) devuelve 64.sizeof(struct S4) returns 64.

struct S4 {
   int a;
   // 28 bytes padding
   struct S1 s1;      // S4 inherits cache alignment requirement of S1
};

Las tres declaraciones de variable siguientes también utilizan __declspec(align(#)).The following three variable declarations also use __declspec(align(#)). En cada caso, la variable debe tener una alineación de 32 bytes.In each case, the variable must be 32-byte aligned. En la matriz, la dirección base de la matriz, no cada miembro de la matriz, tiene una alineación de 32 bytes.In the array, the base address of the array, not each array member, is 32-byte aligned. El sizeof valor de cada miembro de la matriz no se ve afectado cuando se usa __declspec(align(#)) .The sizeof value for each array member is unaffected when you use __declspec(align(#)).

CACHE_ALIGN int i;
CACHE_ALIGN int array[128];
CACHE_ALIGN struct s2 s;

Para alinear cada miembro de una matriz, se debe utilizar código como el siguiente:To align each member of an array, code such as this should be used:

typedef CACHE_ALIGN struct { int a; } S5;
S5 array[10];

En este ejemplo, observe que la alineación de la propia estructura y la alineación del primer elemento tienen el mismo efecto:In this example, notice that aligning the structure itself and aligning the first element have the same effect:

CACHE_ALIGN struct S6 {
   int a;
   int b;
};

struct S7 {
   CACHE_ALIGN int a;
               int b;
};

S6 y S7 tienen características de alineación, asignación y tamaño idénticas.S6 and S7 have identical alignment, allocation, and size characteristics.

En este ejemplo, la alineación de las direcciones iniciales de a, b, c y d son 4, 1, 4 y 1, respectivamente.In this example, the alignment of the starting addresses of a, b, c, and d are 4, 1, 4, and 1, respectively.

void fn() {
   int a;
   char b;
   long c;
   char d[10]
}

La alineación cuando la memoria se asignó en el montón depende de qué función de asignación se invoque.The alignment when memory is allocated on the heap depends on which allocation function is called. Por ejemplo, si utiliza malloc, el resultado depende del tamaño de operando.For example, if you use malloc, the result depends on the operand size. Si arg >= 8, la memoria devuelta tiene una alineación de 8 bytes.If arg >= 8, the memory returned is 8 byte aligned. Si arg < 8, la alineación de la memoria devuelta es la primera potencia de 2 inferior a arg.If arg < 8, the alignment of the memory returned is the first power of 2 less than arg. Por ejemplo, si usa malloc(7) , la alineación es de 4 bytes.For example, if you use malloc(7), the alignment is 4 bytes.

Definir nuevos tipos con__declspec(align(#))Defining new types with __declspec(align(#))

Puede definir un tipo con una característica de alineación.You can define a type with an alignment characteristic.

Por ejemplo, puede definir un struct con un valor de alineación de esta manera:For example, you can define a struct with an alignment value this way:

struct aType {int a; int b;};
typedef __declspec(align(32)) struct aType bType;

Ahora, aType y bType tienen el mismo tamaño (8 bytes) pero las variables de tipo bType tienen una alineación de 32 bytes.Now, aType and bType are the same size (8 bytes) but variables of type bType are 32-byte aligned.

Alinear datos en el almacenamiento local de subprocesosAligning data in thread local storage

El almacenamiento local de subprocesos estáticos (TLS) creado con el atributo __declspec(thread) y colocado en la sección de TLS en la imagen funciona para la alineación exactamente igual que los datos estáticos normales.Static thread-local storage (TLS) created with the __declspec(thread) attribute and put in the TLS section in the image works for alignment exactly like normal static data. Para crear datos TLS, el sistema operativo asigna a la memoria el tamaño de la sección de TLS y respetando el atributo de la alineación de la sección de TLS.To create TLS data, the operating system allocates memory the size of the TLS section and respects the TLS section alignment attribute.

En este ejemplo se muestran diversas maneras de colocar datos alineados en el almacenamiento local para el subproceso.This example shows various ways to place aligned data into thread local storage.

// put an aligned integer in TLS
__declspec(thread) __declspec(align(32)) int a;

// define an aligned structure and put a variable of the struct type
// into TLS
__declspec(thread) __declspec(align(32)) struct F1 { int a; int b; } a;

// create an aligned structure
struct CACHE_ALIGN S9 {
   int a;
   int b;
};
// put a variable of the structure type into TLS
__declspec(thread) struct S9 a;

Cómo align funciona con el empaquetado de datosHow align works with data packing

La /Zp opción del compilador y la pack pragma tienen el efecto de empaquetar datos para miembros de estructura y de Unión.The /Zp compiler option and the pack pragma have the effect of packing data for structure and union members. En este ejemplo se muestra cómo /Zp y __declspec(align(#)) trabajan juntos:This example shows how /Zp and __declspec(align(#)) work together:

struct S {
   char a;
   short b;
   double c;
   CACHE_ALIGN double d;
   char e;
   double f;
};

En la tabla siguiente se muestra el desplazamiento de cada miembro en /Zp valores distintos (o #pragma pack ), que muestra cómo interactúan los dos.The following table lists the offset of each member under different /Zp (or #pragma pack) values, showing how the two interact.

VariableVariable /Zp1/Zp1 /Zp2/Zp2 /Zp4/Zp4 /Zp8/Zp8
aa 00 00 00 00
bb 11 22 22 22
cc 33 44 44 88
dd 3232 3232 3232 3232
ee 4040 4040 4040 4040
ff 4141 4242 4444 4848
sizeof(S)sizeof(S) 6464 6464 6464 6464

Para obtener más información, vea /Zp (alineación de miembros de estructura).For more information, see /Zp (Struct Member Alignment).

El desplazamiento de un objeto se basa en el desplazamiento del objeto anterior y el valor actual de empaquetado, a menos que el objeto tenga un atributo __declspec(align(#)), en cuyo caso la alineación se basa en el desplazamiento del objeto anterior y el valor __declspec(align(#)) para el objeto.The offset of an object is based on the offset of the previous object and the current packing setting, unless the object has a __declspec(align(#)) attribute, in which case the alignment is based on the offset of the previous object and the __declspec(align(#)) value for the object.

FIN de Específicos de MicrosoftEND Microsoft Specific

Vea tambiénSee also

__declspec
Información general sobre las convenciones ABI de ARMOverview of ARM ABI Conventions
Convenciones de software x64x64 software conventions