C wyrównanie rozmiaru struktury

Question

Chcę, aby rozmiar struktury C był wielokrotnością 16 bajtów (16B/32B/48B/..). Nie ma znaczenia, jaki rozmiar osiąga, to musi być wielokrotnością 16B. Jak mogę wymusić kompilator, aby to zrobić? Dzięki.

Answer 1

Wielkość struktury C zależy od członków struktury, ich typów i ich liczby. Naprawdę nie ma standardowego sposobu zmuszenia kompilatora do tego, aby struktura była wielokrotnością pewnego rozmiaru. Niektóre kompilatory dostarczają pragmy, która pozwoli ci ustawić granicę wyrównania, ale to naprawdę jest coś innego. I mogą istnieć takie, które będą miały takie ustawienie lub zapewnią taką pragmę.

Jednakże, jeśli nalegasz na tę jedną metodę, to przydzielenie pamięci struktury i wymuszenie przydzielenia pamięci na zaokrąglenie do 16 bajtów.

Więc jeśli masz taką strukturę.

struct _simpleStruct { 
    int iValueA; 
    int iValueB; 
}; 

Następnie można zrobić coś takiego.

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

To, co można zrobić, to przesunąć rozmiar do 16 bajtów o ile dotyczy. Jednak to, co robi alokator pamięci, może, ale nie musi, dać blok, który jest w rzeczywistości tym rozmiarem. Blok pamięci może być w rzeczywistości większy niż twoja prośba.

Jeśli masz zamiar zrobić coś specjalnego z tym, na przykład powiedzmy, że zamierzasz napisać tę strukturę do pliku i chcesz poznać rozmiar bloku, to musiałbyś zrobić to samo obliczenie malloc() zamiast używania operatora sizeof() do obliczenia rozmiaru struktury.

Następną rzeczą byłoby napisanie własnego operatora sizeof() przy użyciu makra takiego jak.

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

O ile wiem, nie ma niezawodny sposób na ciągnięcie rozmiaru przydzielonego bloku od wskaźnika. Zwykle wskaźnik będzie miał blok alokacji pamięci, który jest używany przez funkcje zarządzania pamięcią sterty, które będą zawierać różne informacje zarządzania pamięcią, takie jak przydzielony rozmiar bloku, który może być faktycznie większy niż żądana ilość pamięci. Jednak format tego bloku i jego lokalizacja względem rzeczywistego adresu pamięci będą zależały od czasu działania kompilatora C.

Answer 2

To zależy całkowicie od kompilatora i innych narzędzi, ponieważ wyrównanie nie jest określone tak głęboko w standardzie ISO C (określa, że ​​wyrównanie może się zdarzyć na żądanie kompilatora, ale nie zawiera szczegółowych informacji na temat jego egzekwowania).

Musisz zajrzeć do rzeczy związanych z implementacją łańcucha narzędzi kompilatora. Może dostarczyć #pragma pack (lub align lub coś innego), które można dodać do definicji struktury.

Może to również zapewnić jako rozszerzenie języka. Na przykład, gcc pozwala na dodawanie atrybutów do zdefiniowania, z których jeden steruje wyrównania:

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

Answer 3

dla Microsoft Visual C++:

#pragma pack(push, 16) 

struct _some_struct 
{ 
    ... 
} 

#pragma pack(pop) 

dla GCC:

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

Przykład:

#include <stdio.h> 

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

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

skompilowany z gcc -o main main.c wyświetli 16. To samo dotyczy innych kompilatorów.

Answer 4

Można chyba zrobić podwójne struct, owijając swoje rzeczywiste struct w drugim, który może dodać 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)]; 
}; 

Następnie można pracować z wyściełanym struct:

struct payload_padded a; 

a.p.d = 43.3; 

Oczywiście , możesz skorzystać z faktu, że pierwszy element struktury zaczyna 0 bajtów od miejsca rozpoczęcia struktury i traktuje wskaźnik jako struct payload_padded tak, jakby był wskaźnikiem do struct payload (ponieważ jest):

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);