自定义类型--结构体 枚举 联合

1.结构体
结构体类型的声明

struct tag//标签
{
  member-list;//成员列表
}varibale-list//变量列表

例如：描述一个学生：

struct Stu//标签可以省略但尽量不省略，这样会见名知义
{
  char name[20];
  int age;
  char sex[5];
  char id[20];
};//注意分号不能丢

特殊的声明：在声明结构体时，可以不完全声明，比如：

//匿名结构体
struct
{
  int a;
  char b;
  float c;
}x;
struct 
{
  int a;
  char b;
  float c;
}a[20], *p;

上面的两个结构体在声明的时候省略了结构体标签,但是这里应该注意的是：如果令

p = &x;

编译器会把上面的两个声明当成完全不同的两个类型，这样写是非法的。所以说：一个结构体一种类型，哪怕两个结构体内容一模一样，也是两种类型。
结构体变量的声明

struct stu
{
  char name[20];
  int age;
  char sex[5];
  char id[20];
}Lisi;

或者下面的：

struct stu Zhangsan
{
  char name[20];
  int age;
  char sex[5];
  char id[20];
};

结构的成员
结构体的成员可以是标量、数组、指针，甚至是其他结构体。
结构体成员的访问
结构体变量访问成员 结构变量的成员是通过点操作符(.)。点操作符接受两个操作数。例如：

struct Stu
{
  char name[20];
  int age;
};

struct Stu s;//定义结构体变量，s有成员name和age

如果要访问s的成员，则：

struct S s;
strcpy(s.name, "zhangsan");//使用.访问name的成员
s.age = 20;

结构体访问指向变量的成员 有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针,此时用指向操作符(->)。则应该如下访问：

struct S
{
  char name[20];
  int age;
}s;

void print(struct S* ps)
{
  printf("name = %s  age = %d\n", (*ps).name, (*ps).age);//点操作符
  printf("name = %s  age = %d\n", ps -> name, ps -> age);//指向操作符
}

结构的自引用
在结构体中包含一个类型为该结构本身的成员，又会出现什么后果呢？

//代码1
struct Node
{
  int data;
  struct Node next;
};

//代码2
struct Node
{
  int data;
  struct Node* next;
};

在代码1中，这里应该注意到：如果用该方式自引用结构体的话，sizeof(struct Node)无从知晓，并且Node会显示未定义；代码2才是自引用的正确方式，因为指针的大小可以确定，空间可以开辟。
注意：

typedef struct //类型重定义
{
  int data;
  Node* next;//Node未定义，出错
}Node;//匿名结构体名称为Node

//改正方法
typedef struct Node//标签与类型名称可以一样，但尽量写成不一样的
{
  int data;
  struct Node* next;
}Node;//是一个类型

结构体变量的初始化和重定义
结构体的初始化和数组一样，可以整体初始化，但不可以整体赋值。
直接看代码

struct Point 
{
  int x;
  int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2

struct Point p3 = {x, y};//初始化：定义变量的同时赋初值

struct Stu//类型声明
{
  char name[20];
  int age;
};

struct Stu s = {"zhangsan", 20};//初始化

struct Node 
{
  int data;
  struct Point p;
  struct Node* next;
}n1 = {10, {4,5}, NULL};//结构体嵌套初始化

struct Node n2 = {20, {5,6}, NULL};结构体嵌套初始化

结构体内存对齐
我们要计算结构体的大小，首先要知道结构体内存对齐这一概念，这也是非常重要的，那么，结构体的对齐规则是什么呢？
1.第一个成员在结构体变量偏移量为零的地址处；也就是说第一个元素也有对齐数，只是意义对自身来讲并不大。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数=编译器默认的一个对齐数与该成员大小的较小值。（VS中默认为8，Linux默认为4）。
3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。注意：结构体的对齐数是结构体内所有对齐数的最大值，并不是所有对齐数之和。
其次，为什么存在内存对齐呢？
1.平台原因（移植原因）
不是所有的硬件平台都可以访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常；
2.性能原因
数据结构（尤其是栈）应该尽可能的在自然边界上对齐。原因在于：为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的内存访问仅需要一次。
总体来说：结构体的内存对齐是拿空间来换取时间的做法，这样性能可以提高。看例子：

struct S1
{
  char c1;//1+3
  int i;//4
  char c2;//1
};//整数倍12
printf("%d\n",sizeof(struct S1));//对齐数12


struct S2
{
  char c1;//1
  char c2;//1
  int i;//4
};
printf("%d\n",sizeof(struct S2));//对齐数8


struct S3
{
  double d;//8
  char c;//1+3
  int i;//4
};
printf("%d\n",sizeof(struct S3);//对齐数16


struct S4
{
  char c1;//1+7
  struct S3 s3;//16
  double d;//8
};
printf("%d\n",sizeof(struct S4));//对齐数32

所以在设计结构体的时候，我们既要满足对齐，又要节省空间。那么，就要让占用空间小的成员尽量集中在一起。例如在上述例子中，S1和S2类型的成员一模一样，但是两个占空间的大小有一定的区别。
结构体传参
与数组不同的是：结构体传参不会发生降维问题，形成完整的结构体临时变量。例如：

struct S
{
  int data[1000];
  int num;
};

struct S s = {{1,2,3,4}, 1000};

//结构体传参
void print1(struct S s)
{
  printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
  printf("%d\n",ps->num);
}

int main()
{
  printf1(s);//传结构体
  printf2(&s);//传地址
  return 0;
}

显而易见，首选printf2函数。原因是：函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的话，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。所以呢，结构体传参的时候，要传结构体的地址。
2.位段
什么是位段？
位段的声明和结构体是类似的，有两个不同：
1.位段的成员必须是int / unsigned int / signed int；
2.位段的成员名后面有一个冒号和一个数字。
例如：

struct A//类型相同，都是int;A就是一个位段类型
{
  int _a:2;//占32个bit位的2个，名为_a，位置不固定
  int _b:5;
  int _c:10;
  int _d:30;//前15个可能和上面的17个放在一起，后面剩下15个重新开辟空间；也有可能前17个放一起，后30个放一起
};

//A的大小
printf("%d\n",sizeof(struct A));

位段的内存分配
1.位段的成员可以是int / unsigned int / signed int 或者是char，（属于整型家族）类型；
2.位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式开辟的；
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
位段的跨平台问题
1.int位段被当成有符号数还是无符号数是不确定的；
2.位段中最大位的数目不能确定（16位机器最大16，32位机器最大32，写成27在16位机器会出问题）；
3.位段中的成员在内存中从左向右分配，还是从右向左分配并没有标准的定义；
4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是无法确定的。
总结： 跟结构相比，位段可以达到同样的效果，但是可以很好地节省空间，但是有跨平台的问题存在。
3.枚举
枚举顾名思义就是一一列举。
枚举类型的定义

enum Day
{
  Mon,//0
  Tues,
  Wed,//2
  Thur,
  Fri,//4
  Sat,
  Sun//6
};

enum Sex
{
  MALE,//0
  FEMALE,//1
  SECRET//2
};

enum Color
{
  RED,//0
  BLUE,//1
  BLACK//2
};

以上都是枚举类型。{ }中的内容是枚举常量，本质上是整数，这些取值都是有值的，默认从零开始。
枚举的优点有哪些呢？它和宏定义又有什么区别呢？
1.增加代码的可读性和可维护性；
2.和宏定义相比较，枚举是一种类型，会进行检查，更加严谨，而宏定义只是简单的文本替换，不做检查；
3.防止了命名污染（封装）；
4.便于调试；
5.使用统一，一次可以定义多个常量。
枚举的使用

enum Color
{
  RED = 1,
  BLUE = 2,
  BLACK = 4
};
enum Color clr = BLUE;
clr = 5;

所以这里应该注意的是：只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
4.联合（共用体）
联合是一种聚合类型，用typedef可以重定义。联合也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员公用一快空间，所以联合也叫共用体。
例如：

union Un
{
  char c;
  int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n",sizeof(un));

联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小，因为联合至少得有能力保存最大的那个成员。同时应该注意的是，联合体中每个地址（每个成员的地址和联合体的地址）在数值上是一样的。

union Un
{
  int i;
  char c;
};
union Un un;
//下面两个输出结果一样
printf("%d\n",&(un.i));
printf("%d\n",&(un.c));

联合大小的计算
1.联合的大小至少是最大成员的大小；
2.当最大成员大小不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍。

#include<windows.h>
#include<stdio.h>

union Un1
{
    char c[5];
    int i;
};
union Un2
{
    short c[7];
    int i;
};

int main()
{
    printf("%d\n", sizeof(union Un1));//8
    printf("%d\n", sizeof(union Un2));//16

    system("pause");
    return 0;
}