~ pragma Pack effect

#pragma jest używany do wysyłania Nie-przenośnych (jak tylko w tym kompilatorze) Wiadomości do kompilatora. Rzeczy takie jak wyłączenie niektórych ostrzeżeń i struktury pakowania są częstymi przyczynami. Wyłączenie określonych ostrzeżeń jest szczególnie przydatne, jeśli kompilujesz z włączoną flagą warnings as errors.

#pragma pack specific is used to indicate that the struct to packed should not have its members aligned. Jest to przydatne, gdy masz interfejs mapowany pamięcią do elementu sprzętowego i musisz być w stanie kontroluj dokładnie, gdzie wskazują poszczególne elementy struktury. Nie jest to szczególnie dobra optymalizacja prędkości, ponieważ większość maszyn znacznie szybciej radzi sobie z wyrównanymi danymi.

Mówi kompilatorowi, że granica ma wyrównywać obiekty w strukturze do. Na przykład, jeśli mam coś takiego:

struct foo { 
    char a;
    int b;
};

W przypadku typowej maszyny 32-bitowej Zwykle "chcesz" mieć 3 bajty wypełnienia między a A b, Aby b wylądował na granicy 4-bajtów, aby zmaksymalizować prędkość dostępu (i to zwykle będzie się działo domyślnie).

Jeśli jednak musisz dopasować zewnętrznie zdefiniowaną strukturę, chcesz mieć pewność, że kompilator ułoży twoją strukturę dokładnie zgodnie z tą zewnętrzną definicją. W tym przypadku, możesz dać kompilatorowi #pragma pack(1), Aby powiedział mu , a nie , aby wstawił jakiekolwiek odstępy między członkami - jeśli definicja struktury zawiera odstępy między członkami, wstawiasz je jawnie (np. zazwyczaj z członami o nazwie unusedN lub ignoreN, lub coś w tej kolejności).

1. #pragma pack (n) Po prostu ustawia nowe wyrównanie.
2. #pragma pack () ustawia wyrównanie do tego, które miało miejsce w momencie rozpoczęcia kompilacji.
3. #pragma pack (push[,n]) wypycha bieżące ustawienie wyrównania na stosie wewnętrznym, a następnie opcjonalnie ustawia nowe wyrównanie.
4. #pragma pack (pop) przywraca ustawienie wyrównania do Ustawienia zapisanego na górze wewnętrznego stosu(i usuwa ten wpis). Zauważ, że # pragma pack ([n]) nie wpĹ ' ywaj na ten wewnÄ ™ trzny stos; w ten sposĂłb moĹźna mieÄ ‡ #pragma pack(push), a nastÄ ™ pnie kilka wystÄ ™ pĂłw #pragma pack(n) i finalizowaä ‡ pojedynczym #pragma pack(pop).

Przykłady:

#pragma pack(push, 1) // exact fit - no padding
struct MyStruct
{
  char b; 
  int a; 
  int array[2];
};
#pragma pack(pop) //back to whatever the previous packing mode was 

Or

#pragma pack(1) // exact fit - no padding
struct MyStruct
{
  char b; 
  int a; 
  int array[2];
};
#pragma pack() //back to whatever the previous packing mode was 


Or 

#pragma pack(1) // exact fit - no padding
struct MyStruct
{
  char b; 
  int a; 
  int array[2];
}; 

Elementy danych (np. członkowie klas i struktur) są zazwyczaj wyrównywane na granicach WORD lub DWORD dla procesorów obecnej generacji w celu poprawy czasu dostępu. Pobranie DWORDU pod adresem, który nie jest podzielny przez 4, wymaga co najmniej jednego dodatkowego cyklu procesora na procesorze 32-bitowym. Tak więc, jeśli masz np. trzy elementy char char a, b, c;, zajmują one zwykle 6 lub 12 bajtów pamięci.

#pragma pozwala to zastąpić, aby osiągnąć bardziej efektywne wykorzystanie przestrzeni, kosztem szybkości dostępu, lub dla spójności przechowywanych danych pomiędzy różnymi celami kompilatora. Miałem dużo zabawy z tym przechodzeniem z 16-bitowego na 32-bitowy kod; spodziewam się, że przeniesienie do 64-bitowego kodu spowoduje takie same bóle głowy dla niektórych kodów.

Kompilator może umieszczać elementy struktury na określonych granicach bajtów ze względu na wydajność na określonej architekturze. Może to pozostawić niewykorzystaną wyściółkę między członkami. Struktura pakowania zmusza członków do przylegania.

Może to być ważne na przykład, jeśli potrzebujesz struktury, aby była zgodna z konkretnym plikiem lub formatem komunikacji, gdzie dane muszą znajdować się w określonych pozycjach w sekwencji. Jednak takie użycie nie zajmuje się problemy z endian-ness, więc chociaż jest używany, może nie być przenośny.

Może również dokładnie nakładać wewnętrzną strukturę rejestru niektórych urządzeń We/Wy, takich jak na przykład kontroler UART lub USB, aby dostęp do rejestru był przez strukturę, a nie bezpośrednie adresy.

Kompilator może wyrównywać pręty w strukturach, aby osiągnąć maksymalną wydajność na danej platformie. #pragma pack dyrektywa pozwala kontrolować to wyrównanie. Zazwyczaj należy pozostawić go domyślnie dla optymalnej wydajności. Jeśli musisz przekazać strukturę do zdalnego komputera, zazwyczaj używasz #pragma pack 1, aby wykluczyć niechciane wyrównanie.

Prawdopodobnie chcesz tego użyć tylko wtedy, gdy kodujesz na jakimś sprzęcie (np. urządzeniu zmapowanym pamięcią), który miał ścisłe wymagania dotyczące porządkowania i wyrównywania rejestrów.

Jednak wygląda to na dość tępe narzędzie do osiągnięcia tego celu. Lepszym podejściem byłoby zakodowanie mini-drivera w asemblerze i nadanie mu interfejsu wywołującego C, a nie wygłupianie się z tą pragmą.

Używałem go wcześniej w kodzie, ale tylko do interfejsu z kodem starszym. Była to aplikacja Mac OS X Cocoa, która musiała załadować pliki preferencji z wcześniejszej wersji Carbon (która sama była wstecznie kompatybilna z oryginalną wersją systemu M68k 6.5...masz pomysł). Pliki preferencji w oryginalnej wersji były binarnym zrzutem struktury konfiguracyjnej, który używał #pragma pack(1), aby uniknąć zajmowania dodatkowego miejsca i oszczędzania śmieci (tj. bajtów wypełnienia, które w przeciwnym razie byłyby w strukturze).

Oryginalni autorzy kodu używali również #pragma pack(1) do przechowywania struktur, które były używane jako komunikaty w komunikacji między procesami. Myślę, że powodem było uniknięcie możliwości nieznanych lub zmienionych rozmiarów wypełnienia, ponieważ kod czasami patrzył na konkretną część struktury wiadomości, licząc od początku liczbę bajtów (ewww).

Widziałem, jak ludzie używają go, aby upewnić się, że struktura zajmuje całą linię pamięci podręcznej, aby zapobiec fałszywemu udostępnieniu w wielowątkowym kontekście. Jeśli masz zamiar mieć dużą liczbę obiektów, które mają być luźno pakowane domyślnie może zaoszczędzić pamięć i poprawić wydajność pamięci podręcznej, aby spakować je mocniej, choć niepodpisany dostęp do pamięci Zwykle spowolni rzeczy, więc może być minusem.

Zauważ, że istnieją inne sposoby osiągnięcia spójności danych, które oferuje #pragma pack (na przykład niektórzy ludzie używają # pragma pack(1) dla struktur, które powinny być wysyłane przez sieć). Na przykład patrz poniższy kod i jego kolejne wyjście:

#include <stdio.h>

struct a {
    char one;
    char two[2];
    char eight[8];
    char four[4];
};

struct b { 
    char one;
    short two;
    long int eight;
    int four;
};

int main(int argc, char** argv) {
    struct a twoa[2] = {}; 
    struct b twob[2] = {}; 
    printf("sizeof(struct a): %i, sizeof(struct b): %i\n", sizeof(struct a), sizeof(struct b));
    printf("sizeof(twoa): %i, sizeof(twob): %i\n", sizeof(twoa), sizeof(twob));
}

Wyjście jest następujące: sizeof (struct a): 15, sizeof(struct b): 24 sizeof (twoa): 30, sizeof(twob): 48

Zwróć uwagę, jak rozmiar struktury a jest dokładnie taki, jaki jest liczba bajtów, ale struktura b ma dodane wypełnienie (zobacz to dla szczegółów na wyściółce). Robiąc to w przeciwieństwie do pakietu # pragma, możesz mieć kontrolę nad konwersją "formatu drutu" na odpowiednie typy. Na przykład, "char dwa [2]" w "krótki int" et cetera.