C\C++ 结构类型

本质

把不同类型的变量聚合在一起，方便使用

struct x1 
{
  char a;
  float b;
  int c;
  double d [10];
};

这段代码是一个声明，声明了一个结构类型(就和int一样，它也是一种类型)：struct x1
关键字struct：结构类型的标志
标识符x1：结构类型的标记
{ char a; float b; int c; double d [10]; } -> 成员列表
char a; float b; int c; double d [10]; ->成员
成员列表，成员的存储顺序和声明的存储顺序是一致的。
结构类型是派生类型，派生自它的成员类型，且结构类型的成员也可以是结构类型（联合类型也可以），派生的递归的。

struct x2
{
  int c;
  struct x1 d;
};
//声明结构类型的变量
struct x1 i; struct x1 j;

声明及初始化

声明结构类型“struct xxx”；
结构成员“a, b, c”
struct xxx { int a; int b; int c; };

声明结构类型“struct xxx”；
结构成员“a, b, c”；
结构类型变量d
struct xxx { int a; int b; int c; } d;

声明结构类型“struct xxx”；
结构成员“a, b, c”；
结构类型变量d；
初始化变量d

struct xxx { int a; int b; int c; } d = {1, 2, 3};
d = {1,2,3};//报错，只能在声明中初始化

声明结构类型“struct xxx”；
结构成员“a, b, c”；
结构类型变量d、e、f；
初始化变量d
struct xxx { int a; int b; int c; } d = {1, 2, 3}, e, f ;

声明未命名的结构类型；
结构成员“a, b, c”
struct { int a; int b; int c; };

声明未命名的结构类型；
结构成员“a, b, c”
未命名结构类型变量d（只能声明一次）
struct { int a; int b; int c; } d;

访问成员

int main(void)
{
  struct abc{char a; float b; int c; double d[10] };
  struct abc s;
  int i = s.c;
  s.d[0] = 1.0;
  double f = s.d[0];
}

字节数、对齐

struct A
{
  int a;
  char b;
  short c;
};
struct B
{
  char b;
  int a;
  short c;
};

结果：
sizeof(struct A)值为8，sizeof(struct B)值为12。
分析：
假设B从地址空间0x0000开始存放，且指定对齐值默认为4(4字节对齐)。成员变量b的自身对齐值是1，比默认指定对齐值4小，所以其有效对齐值为1，其存放地址0x0000符合0x0000%1=0。成员变量a自身对齐值为4，所以有效对齐值也为4，只能存放在起始地址为0x0004~0x0007四个连续的字节空间中，符合0x0004%4=0且紧靠第一个变量。变量c自身对齐值为 2，所以有效对齐值也是2，可存放在0x0008~0x0009两个字节空间中，符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。

再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0000到0x0009=10字节，(10＋2)％4＝0。所以0x0000A~0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节，sizeof(struct B)=12。

之所以编译器在后面补充2个字节，是为了实现结构数组的存取效率。试想如果定义一个结构B的数组，那么第一个结构起始地址是0没有问题，但是第二个结构呢？按照数组的定义，数组中所有元素都紧挨着。如果我们不把结构体大小补充为4的整数倍，那么下一个结构的起始地址将是0x0000A，这显然不能满足结构的地址对齐。因此要把结构体补充成有效对齐大小的整数倍。其实对于char/short/int/float/double等已有类型的自身对齐值也是基于数组考虑的，只是因为这些类型的长度已知，所以他们的自身对齐值也就已知。

满足准则：

• 结构体变量的首地址能够被其最宽基本类型成员的大小所整除
• 结构体每个成员相对结构体的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）
• 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节{tralling padding}

位字段成员

C99引入：被“指定了比特数”的成员，我们称之为“位字段成员”

//成员a、b都是被分别指定为1个比特数（:数量）的位字段成员。
struct ab {_Bool a:1; _Bool b:1;};

1.C语言规定，位字段成员的类型必须是_Bool、signed int、unsigned int，以及它们的限定版本。
2.部分C实现支持其他的类型，但这不利于程序的可移植性。
3.如果位字段成员的类型为int，他可能等价于signed int，也可能等价于unsigned int。
4.“指定的比特数”不能超过类型本身的宽度（_Bool类型的宽度为1bit，注意是类型的宽度，不是实际占用内存的大小）。
5.两个相邻的位字段成员：a、b
1）如果用来存储a的存储单元还有剩余，并足以容纳b，那么a和b会被存储到同一个存储单元中

struct x1 {_Bool a; _Bool b; };
int f1 = sizeof(struct x1);//2个byte
int f2 = _Alignof(struct x1);//对齐1个byte

image.png

struct x1 {_Bool a:1; _Bool b:1; };
int f1 = sizeof(struct x1);//1个byte
int f2 = _Alignof(struct x1);//对齐1个byte

image.png

2）如果用来存储a的存储单元还有剩余，但是不足以容纳b，那么C实现将会进行二选一
- 将b的一部分放在a所剩余的空间，使b跨单元存储
- 给b另外分配一个新的存储单元
6.位字段成员可以没有变量名（未命名位字段），可以用于结构类型变量的内部填充，用以实现想要的内存布局。

struct x2 { char c; int :16; };

7.比特数为0的未命名字段（比特数为0，且必须使未命名的位字段），用于它前面的字段不与其他位字段成员共享一个存储单元。

struct x1 {int i :2; int j:6; };
int f1 = sizeof(struct x1);//4个byte
int f2 = _Alignof(struct x1);//对齐4个byte

image.png

struct x1 {int i :2; int :0 int j:6; };
int f1 = sizeof(struct x1);//8个byte
int f2 = _Alignof(struct x1);//对齐4个byte

image.png

匿名结构

结构体一

struct xxx { 
  int a; 
  struct yyy { char c; float f; } b; 
} x1;

结构体二

struct xxx 
{ 
  int a; 
  struct { char c; float f; } 
} x1;

struct { char c; float f; }就是一个匿名结构，匿名结构的成员属于他所在的结构或联合。可通过x1.c、x1.f这种方式访问匿名结构的成员。

例：

struct x1
{
    int 1;
    struct x2{ int a; } s;
    struct {int b; };
};
struct x1 t;
t.i = 1;//正确
t.a = 1;//错误
t.s.a = 1;//正确
t.b = 1;//正确

//这种情况是递归的
struct x1
{
    int 1;
    struct { struct {int a; }; int b; };
}
struct x1 t;
t.a = 1;//正确

匿名结构体的3个条件：

• 它是另外一个结构或者联合的成员
• 它没有变量名
• 没有标记