Po co tablica z zerowymi elementami?

To jest właśnie hack, dla GCC (C90 ) w rzeczywistości.

Nazywa się również strukturą hack .

Więc następnym razem powiem:

struct bts_action *bts = malloc(sizeof(struct bts_action) + sizeof(char)*100);

Będzie równoznaczne z powiedzeniem:

struct bts_action{
    u16 type;
    u16 size;
    u8 data[100];
};

I mogę utworzyć dowolną ilość takich obiektów struct.

Chodzi o to, aby pozwolić na tablicę o zmiennej wielkości na końcu struktury. Prawdopodobnie bts_action jest pakietem danych z nagłówkiem o stałej wielkości (pola type i size) i członkiem o zmiennej wielkości data. Deklarując ją jako tablicę o długości 0, może być indeksowana tak jak każda inna tablica. Następnie przydzieliłbyś bts_action strukturę, powiedzmy 1024-bajtowądata O rozmiarze, tak:

size_t size = 1024;
struct bts_action* action = (struct bts_action*)malloc(sizeof(struct bts_action) + size);

Zobacz też: http://c2.com/cgi/wiki?StructHack

Kod nie jest prawidłowy C (Zobacz to ). Jądro Linuksa, z oczywistych powodów, nie jest w najmniejszym stopniu związane z przenośnością, więc używa dużo niestandardowego kodu.

To, co robią, to niestandardowe rozszerzenie GCC o rozmiarze tablicy 0. Program zgodny ze standardem napisałby u8 data[]; i oznaczałby to samo. Autorzy jądra Linuksa najwyraźniej uwielbiają robić rzeczy niepotrzebnie skomplikowane i niestandardowe, jeśli taka opcja ujawni siebie.

W starszych standardach C zakończenie struktury pustą tablicą było znane jako "Hack struktury". Inni już wyjaśnili jej cel w innych odpowiedziach. Hack struktury, w standardzie C90, był niezdefiniowanym zachowaniem i mógł powodować awarie, głównie dlatego, że kompilator C może swobodnie dodawać dowolną liczbę bajtów wypełnienia na końcu struktury. Takie bajty wypełnienia mogą kolidować z danymi, które próbowałeś "włamać"na końcu struktury.

GCC na początku wykonało niestandardowe rozszerzenie aby zmienić to z niezdefiniowanego na dobrze zdefiniowane zachowanie. Standard C99 zaadaptował tę koncepcję i każdy nowoczesny program C może korzystać z tej funkcji bez ryzyka. Jest znany jako flexible array member w C99/C11.

Innym zastosowaniem tablicy o zerowej długości jest nazwana Etykieta wewnątrz struktury, która pomaga w sprawdzaniu przesunięcia struktury w czasie kompilacji.

Załóżmy, że masz jakieś duże definicje struktur (obejmujące wiele linii pamięci podręcznej), które chcesz upewnić się, że są wyrównane do granicy linii pamięci podręcznej zarówno na początku, jak i w środku, gdzie przekracza granicę.

struct example_large_s
{
    u32 first; // align to CL
    u32 data;
    ....
    u64 *second;  // align to second CL after the first one
    ....
};

W kodzie można je zadeklarować używając rozszerzeń GCC takich jak:

__attribute__((aligned(CACHE_LINE_BYTES)))

Ale nadal chcesz się upewnić, że jest to egzekwowane w runtime.

ASSERT (offsetof (example_large_s, first) == 0);
ASSERT (offsetof (example_large_s, second) == CACHE_LINE_BYTES);

To zadziała dla pojedynczej struktury, ale trudno byłoby pokryć wiele struktur, każda z nich ma inną nazwę Członka do wyrównania. Najprawdopodobniej otrzymasz kod jak poniżej, gdzie musisz znaleźć nazwy pierwszego członu każdej struktury:

assert (offsetof (one_struct,     <name_of_first_member>) == 0);
assert (offsetof (one_struct,     <name_of_second_member>) == CACHE_LINE_BYTES);
assert (offsetof (another_struct, <name_of_first_member>) == 0);
assert (offsetof (another_struct, <name_of_second_member>) == CACHE_LINE_BYTES);

Zamiast iść w ten sposób, Można zadeklarować tablicę o zerowej długości w strukturze działającą jako nazwana Etykieta o spójnej nazwie, ale nie zajmuje żadnej spacji.

#define CACHE_LINE_ALIGN_MARK(mark) u8 mark[0] __attribute__((aligned(CACHE_LINE_BYTES)))
struct example_large_s
{
    CACHE_LINE_ALIGN_MARK (cacheline0);
    u32 first; // align to CL
    u32 data;
    ....
    CACHE_LINE_ALIGN_MARK (cacheline1);
    u64 *second;  // align to second CL after the first one
    ....
};

Wtedy kod twierdzenia runtime byłby znacznie łatwiejsze w utrzymaniu:

assert (offsetof (one_struct,     cacheline0) == 0);
assert (offsetof (one_struct,     cacheline1) == CACHE_LINE_BYTES);
assert (offsetof (another_struct, cacheline0) == 0);
assert (offsetof (another_struct, cacheline1) == CACHE_LINE_BYTES);