構造とユニオン

struct s { int x; }; // 's' is the identifier
union u { int x; };  // 'u' is the identifier

// No identifier
struct { int x; } z; // 'z' is a tag
union { int x; } w; // 'w' is a tag

struct a { // Regular struct, has identifier 'a'
  struct { int x; }; // Anonymous struct, no identifier and no tag
  union { int y; }; // Anonymous union, no identifier and no tag
};

struct { int x; } x, y; // 'x' and 'y' are tags
union { int x; } z, w;  // 'z' and 'w' are tags

struct s { inx x; } y;         // 'y' is a tag
typedef struct s { inx x; } y; // 'y' is an alias
union u { inx x; } y;          // 'y' is a tag
typedef union u { inx x; } y;  // 'y' is an alias

#include <stdio.h>

struct s { int x; } S; // 'S' is a tag
typedef struct s SS;   // 'SS' is an alias

int main(void) {
  SS myStruct;
  myStruct.x = 10;

  S.x = 15;

  printf("Tag: %d\n", S.x);
  printf("Alias: %d\n", myStruct.x);

  return 0;
}

// 💩
struct s { int x }
union u { int x }
struct s { int x; }
union u { int x; }

// 💩
struct s {
  int x;
  char z
};

union u {
  int x;
  char z
};

// Some compilers accept this style if you have only 1 member
struct s { int x };
union u { int x };

// 👍
struct s { int x; };
union u { int x; };

struct s1;          // Incomplete type
union u1;           // Incomplete type
typedef struct s1 S;    // Incomplete type, 'S' is only an alias to incomplete struct 's1'
typedef union u1 U;     // Incomplete type, 'U' is only an alias to incomplete struct 'u1'
struct s2 { int x; };   // Complete
union u2 { int x; };    // Complete
struct { int x; } s3;   // Also complete, 's3' is a tag
struct { int x; } u3;   // Also complete, 'u3' is a tag

// Valid, but 👎 💩 😠
struct s { int x; };
typedef struct { int x; } s;
union u { int x; };
typedef union { int x; } u;

// 💩
struct s { int x; };
typedef struct s { int x; };
union u { int x; };
typedef union u { int x; };

// 💩
typedef struct s { int x; };
typedef union u { int x; };

#include <stdio.h>

struct a { int x; };
typedef struct a aa; // Alias 'aa' for the struct 'a'
struct { int x; } b; // Tag 'b'
typedef struct b bb; // Compile, but unusable.
struct c { int x; } C; // struct 'c' and tag 'C'
typedef struct { int x; } d; // Alias 'd'
typedef struct e { int x; } ee; // struct 'e' and alias 'ee'

int main(void) {
  struct a a1; // 'a1' is a variable of struct type 'a'
  a1.x = 1;

  aa a2; // 'a2' is a variable of struct type 'a'. 'aa' is an alias of 'struct a'
  a2.x = (++a1.x);

  b.x = (++a2.x); // You can't do 'b b1', because 'b' is not a type, but has a type.

  struct c c1;
  c1.x = (++b.x);

  C.x = (++c1.x);

  d d1;
  d1.x = (++C.x);

  struct e e1;
  e1.x = (++d1.x);

  ee e2;
  e2.x = (++e1.x);

  printf("%d\n", e2.x);    
  return 0;
}

#include <stdio.h>

union e {
  int x;
  char y;
};

int main(void) {    
  union e u;

  u.x = 30200; // Remember not to cause signed integer overflow
  printf("%d\n", u.x);
  u.y = 'a'; // After this point, you will get garbage trying to read u.x
  printf("%c\n", u.y);
  printf("%d\n", u.x);
  u.x = 11111; // After this point, you will get garbage trying to read u.y
  printf("%d\n", u.x);
  printf("%c\n", u.y);
  return 0;
}

struct s {
  int x;
  char y;
};

union u {
  int x;
  char y;
};

struct s { // Regular struct
  struct { int x; };     // Anonymous struct, no identifier and no tag
  union { int y; };      // Anonymous union, no identifier and no tag

  struct a { int x; };   // NOT Anonymous struct, has an identifier 'a'
  union b { int x; };    // NOT Anonymous union, has an identifier 'b'
  struct { int x; } c;   // NOT Anonymous struct, has a tag 'c'
  union { int x; } d;    // NOT Anonymous union, has a tag 'd'
  struct e { int x; } E; // NOT Anonymous struct, has an identifier and a tag
  union f { int x; } F;  // NOT Anonymous union, has an identifier and a tag
};

union u { // Regular union
  struct { int x; };    // Anonymous struct, no identifier and no tag
  union { int y; };     // Anonymous union, no identifier and no tag
};

struct {
  int x;
  struct { int x; };   // 💩, same name of parent member identifier
  struct { int z; };   // 👍
  struct { int x; } y; // 👍, regular struct
} s;

#include <stdio.h>

struct {
  int x;
  struct { int z; };
  struct { int x; } y;
} s;

int main(void) {
  s.x = 5;
  s.z = 10; // Access the same way as any parent member
  s.y.x = 15;

  printf("%d, %d, %d\n", s.x, s.z, s.y.x);

  return 0;
}

enum conType { USB, SERIAL, WIFI, };

struct usbConnection { int x; };
struct serialConnection { int x; };
struct wifiConnection { int x; };

struct connection {
  enum conType type;
  union {
    struct usbConnection usb;
    struct serialConnection serial;
    struct wifiConnection wifi;
  };
};

int main(void) {
  struct connection con;    
  con.usb.x = 10; // Anonymous union allow easy access
  con.type = USB;

  return 0;
}

#include <stdio.h>

#define LENGHT 10
enum NumberType { INT, FLOAT, DOUBLE };

struct saveData {
  enum NumberType type;
  union {
    int     iNumbers[LENGHT];
    float   fNumbers[LENGHT];
    double  dNumbers[LENGHT];
  };
};

struct wasteData {
  enum    NumberType type;
  int     iNumbers[LENGHT];
  float   fNumbers[LENGHT];
  double  dNumbers[LENGHT];
};

void ProcessData( struct saveData *d ){
  switch(d->type) {
    case INT:
      printf("Int\n");
      break;
    case FLOAT:
      printf("Float\n");
      break;
    case DOUBLE:
      printf("Double\n");
      break;
  };
}

int main(void) {
  struct saveData sData;    
  sData.type = DOUBLE;    
  ProcessData(&sData);

  struct saveData sData1;
  struct wasteData sData2;    
  printf("sData1: %ld\nsData2: %ld\n", sizeof(sData1), sizeof(sData2));

  return 0;
}