C 结构大小对齐

Question

I want the size of a C struct to be multiple of 16 bytes (16B/32B/48B/..). It does not matter which size it gets to; it only needs to be multiple of 16 bytes.

How could I enforce the compiler to do that?

Answer 1

For Microsoft Visual C++:

#pragma pack(push, 16)

struct _some_struct
{
     ...
}

#pragma pack(pop)

For GCC:

struct _some_struct { ... } __attribute__ ((aligned (16)));

Example:

#include <stdio.h>

struct test_t {
    int x;
    int y;
} __attribute__((aligned(16)));

int main()
{
    printf("%lu\n", sizeof(struct test_t));
    return 0;
}

compiled with gcc -o main main.c will output 16 . The same goes for other compilers.

Answer 2

This depends entirely on the compiler and other tools since alignment is not specified that deeply in the ISO C standard (it specifies that alignment may happen at the compilers behest but does not go into detail as to how to enforce it).

You'll need to look into the implementation-specific stuff for your compiler toolchain. It may provide a #pragma pack (or align or some other thing) that you can add to your structure defininition.

It may also provide this as a language extension. For example, gcc allows you to add attributes to a definition, one of which controls alignment:

struct mystruct { int val[7]; } __attribute__ ((aligned (16)));

Answer 3

The size of a C struct will depend on the members of the struct, their types and how many of them there are. There is really no standard way to force the compiler to make structs to be a multiple of some size. Some compilers provide a pragma that will allow you to set the alignment boundary however that is really a different thing. And there may be some that would have such a setting or provide such a pragma.

However if you insist on this one method would be to do memory allocation of the struct and to force the memory allocation to round up to the next 16 byte size.

So if you had a struct like this.

struct _simpleStruct {
   int iValueA;
   int iValueB;
};

Then you could do something like the following.

{
    struct _simpleStruct *pStruct = 0;
    pStruct = malloc ((sizeof(*pStruct)/16 + 1)*16);
    // use the pStruct for whatever
    free(pStruct);
}

What this would do is to push the size up to the next 16 byte size so far as you were concerned. However what the memory allocator does may or may not be to give you a block that is actually that size. The block of memory may actually be larger than your request.

If you are going to do something special with this, for instance lets say that you are going to write this struct to a file and you want to know the block size then you would have to do the same calculation used in the malloc() rather than using the sizeof() operator to calculate the size of the struct.

So the next thing would be to write your own sizeof() operator using a macro such as.

#define SIZEOF16(x) ((sizeof(x)/16 + 1) * 16)

As far as I know there is no dependable method for pulling the size of an allocated block from a pointer. Normally a pointer will have a memory allocation block that is used by the memory heap management functions that will contain various memory management information such as the allocated block size which may actually be larger than the requested amount of memory. However the format for this block and where it is located relative to the actual memory address provided will depend on the C compiler's run time.

Answer 4

You could perhaps do a double struct, wrapping your actual struct in a second one that can add padding:

struct payload {
  int a;    /*Your actual fields. */
  float b;
  char c;
  double d;
};

struct payload_padded {
  struct payload p;
  char   padding[16 * ((sizeof (struct payload) + 15) / 16)];
};

Then you can work with the padded struct:

struct payload_padded a;

a.p.d = 43.3;

Of course, you can make use of the fact that the first member of a structure starts 0 bytes from where the structure starts, and treat a pointer to struct payload_padded as if it's a pointer to a struct payload (because it is):

float d_plus_2(const struct payload *p)
{
  return p->d + 2;
}

/* ... */

struct payload_padded b;
const double dp2 = d_plus_2((struct payload *) &b);