/** Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
struct logvol_integrity_desc_s
{
  udf_tag_t       tag;
  udf_timestamp_t recording_time;
  udf_Uint32_t    integrity_type;
  udf_extent_ad_t next_integrity_ext;
  udf_Uint8_t     logvol_contents_use[32];
  udf_Uint32_t    i_partitions;
  udf_Uint32_t    imp_use_len;
  udf_Uint32_t    freespace_table[0];
  udf_Uint32_t    size_table[0];
  udf_Uint8_t     imp_use[0]; 
} GNUC_PACKED;

struct logvol_integrity_desc_s
{
  udf_tag_t       tag;
  udf_timestamp_t recording_time;
  udf_Uint32_t    integrity_type;
  udf_extent_ad_t next_integrity_ext;
  udf_Uint8_t     logvol_contents_use[32];
  udf_Uint32_t    i_partitions;
  udf_Uint32_t    imp_use_len;
  union {
  udf_Uint32_t    freespace_table[0];
  udf_Uint32_t    size_table[0];
  udf_Uint8_t     imp_use[0]; 
  };
} GNUC_PACKED;

struct Foo
{
    int x;
    union
    {
        int y[0];
        char z[0];
    };
};

struct FooBar
{
    char data[sizeof(Foo) + sizeof(int)*3];
    Foo* foo() { return (Foo*)data; }
    int* yyy() { return (int*)(data + sizeof(Foo)); }
};

int main()
{
    FooBar fb;
    Foo& f = *fb.foo();
    int* y =  fb.yyy();
    
    f.y[0] = 123456789;
    f.y[1] = 987654321;
    f.y[1] = 555555555;
    printf("%d : %d %d", sizeof(Foo), y[0], y[1]);
    // VC  --> 8 : 987654321 555555555
    // gcc --> 4 : 123456789 987654321
}

stract foo
{
    int a;
    int b[0];
    short c[0];
};

foo f;
f.b == f.c;
f.b == int(&f) + sizeof(foo);

struct X
{
  char foo [1];
  char bar [0];
  int  baz [0];
};

struct X
{
  char foo [1];
  //char bar [0];
  //int  baz [0];
};

R>struct X
R>{
R>  char foo [1];
R>  char bar [0];
R>  int  baz [0];
R>};
R>

struct Foo
{
    int a;
    long long k[0];
    int b[0];
    short c[0];
    char d[0];
};

struct Bar
{
    int a;
};


int main()
{
    Foo f;
    if((int)&f + sizeof(Foo) == int(f.k) &&
       (int)&f + sizeof(Foo) == int(f.b) &&
       (int)&f + sizeof(Foo) == int(f.c) &&
       (int)&f + sizeof(Foo) == int(f.d) &&
       sizeof(Bar) == sizeof(Foo))
        std::cout << "no difference" << std::endl;
    return 0;
}

R>struct X
R>{
R>  char foo [1];
R>  //char bar [0];
R>  //int  baz [0];
R>};
R>

R>

#include <stdio.h>
#include <stdint.h>

struct Y
{
  char ch;
};

struct X
{
  char ch;
  uint64_t arr [0];
};

int main()
{
  printf("sizeof(Y)=%u\n", sizeof(Y));
  printf("sizeof(X)=%u\n", sizeof(X));
}

g++ -v
gcc version 4.1.2 20080704 (Red Hat 4.1.2-46)

sizeof(Y)=1
sizeof(X)=4

S>Я вот не понимаю зачем несколько таких нулевых массивов может понадобиться

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>

struct Y
{
  char ch;
};

struct X
{
  char     ch;
  char     arr1 [0];
  int      arr2 [0];
  double   arr3 [0];
};

typedef struct X X_t;

int main()
{
  printf("sizeof(Y)=%u\n", sizeof(struct Y));
  printf("sizeof(X)=%u\n", sizeof(struct X));
  printf("offsetof(arr1)=%u\n", offsetof(X_t, arr1));
  printf("offsetof(arr2)=%u\n", offsetof(X_t, arr2));
  printf("offsetof(arr3)=%u\n", offsetof(X_t, arr3));
  return 0;
}

[test]$ gcc -v
gcc version 4.1.2 20080704 (Red Hat 4.1.2-46)
[test]$ gcc test.c -o test -malign-double
[test]$ ./test
sizeof(Y)=1
sizeof(X)=8
offsetof(arr1)=1
offsetof(arr2)=4
offsetof(arr3)=8

struct rgb555  { unsigned char r:5, g:6, b:5; }; // 16-bit
struct rgb888  { unsigned char r, g, b; };
struct rgba888 { unsigned char r, g, b, a; };

struct my_bitmap_header
{
  unsigned short signature;
  enum { monochrome, palette, hicolor, truecolor, alphatruecolor } type;
  int width, height;

  // union {
    unsigned short bits[0]; // в монохромной картинке пикселы сгруппированы по 2 байта
    unsigned char  pixels_pal[0];
    rgb565         pixels_hc[0];
    rgb888         pixels_tc[0];
    rgba888        pixels_tca[0];
  // };
};

unsigned char *raw_bmp;
// грузим его из файла

my_bitmap_header* bmp = (my_bitmap_header*)raw_bmp;
switch(bmp->type)
{
case truecolor:
   // работаем с bmp->pixels_tc[]
}

#define MmGetMdlPfnArray(Mdl) ((PPFN_NUMBER)(Mdl + 1))

#define NDIS_PACKET_EXTENSION_FROM_PACKET(_P)       ((PNDIS_PACKET_EXTENSION)((PUCHAR)(_P) + (_P)->Private.NdisPacketOobOffset + sizeof(NDIS_PACKET_OOB_DATA)))
#define NDIS_PER_PACKET_INFO_FROM_PACKET(_P, _Id)   ((PNDIS_PACKET_EXTENSION)((PUCHAR)(_P) + (_P)->Private.NdisPacketOobOffset + sizeof(NDIS_PACKET_OOB_DATA)))->NdisPacketInfo[(_Id)]
#define NDIS_GET_ORIGINAL_PACKET(_P)                NDIS_PER_PACKET_INFO_FROM_PACKET(_P, OriginalPacketInfo)
#define NDIS_SET_ORIGINAL_PACKET(_P, _OP)           NDIS_PER_PACKET_INFO_FROM_PACKET(_P, OriginalPacketInfo) = _OP
#define NDIS_GET_PACKET_CANCEL_ID(_P)               NDIS_PER_PACKET_INFO_FROM_PACKET(_P, PacketCancelId)
#define NDIS_SET_PACKET_CANCEL_ID(_P, _cId)         NDIS_PER_PACKET_INFO_FROM_PACKET(_P, PacketCancelId) = _cId

class type_info
{
// ...
  private:
    mutable void* data;
    char    mname[1];
};

class type_info
{
// ...
  private:
    mutable void* data;
    const char* mname() const { return reinterpret_cast<const char*>(this + 1); }
};
#if defined(_MSC_VER) && !defined(__ICL)
///\warning break this to get `Unresolved external : const type_info::'vftable' (??_7type_info@@6B@)`
static_assert(sizeof _TypeDescriptor == sizeof type_info, "broken type");
#endif

S>>Я вот не понимаю зачем несколько таких нулевых массивов может понадобиться

sizeof(Y)=1
sizeof(X)=4
offsetof(arr1)=1
offsetof(arr2)=4
offsetof(arr3)=4

struct X
{
  char     ch;
  char     arr1 [0];
  int      arr2 [0];
  double   arr3 [0];
  int      arr4 [0];
  char     arr5 [0];
};

typedef struct X X_t;

int main()
{
  printf("sizeof(Y)=%u\n", sizeof(struct Y));
  printf("sizeof(X)=%u\n", sizeof(struct X));
  printf("offsetof(arr1)=%u\n", offsetof(X_t, arr1));
  printf("offsetof(arr2)=%u\n", offsetof(X_t, arr2));
  printf("offsetof(arr3)=%u\n", offsetof(X_t, arr3));
  printf("offsetof(arr3)=%u\n", offsetof(X_t, arr4));
  printf("offsetof(arr3)=%u\n", offsetof(X_t, arr5));
  return 0;
}

sizeof(Y)=1
sizeof(X)=8
offsetof(arr1)=1
offsetof(arr2)=4
offsetof(arr3)=8
offsetof(arr4)=8
offsetof(arr5)=8

struct Foo
{
   char ch;
   char a[0]; //будет содержать адрес куда можно записывать char
   int b[0]; //будет содержать адрес куда можно записывать int
   double c[0]; //будет содержать адрес куда можно записывать double
   ...
};

R>