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

​结构体

​1.结构体类型的声明

结构：是一些值的集合，这些值被称为成员变量。结构的每个成员可以是不同类型的变量

结构的声明

//结构体关键字    结构体标签
//struct stu 
//{ 
//  member - list;//结构体成员变量
//}variable - list;//结构体变量列表

例如描述一个学生：

struct Stu
{ 
      char name[20];//名字
      int age;//年龄
      char sex[5];//性别 
      char id[20];//学号
}；//分号不能丢

特殊的声明

在声明结构的时候可以不完全声明：匿名结构体类型

struct
{
  int a;
  int b;
  int c;
}x;//必须创建结构体变量

struct
{
  int a;
  int b;
  int c;
}*px;//创建结构体指针变量
int main()
{
  px = &x;//非法的
  return 0
}

2.结构体的自引用

结构体成员变量中包含结构体

错误示例：

struct Node
{
  int data;
  struct Node n;//err
};

正确使用：

struct Node
{
  int data;
  struct Node* next;
};

typedef struct Node
{
  int data;
  struct Node* next;
}Node;
//typedef:类型重定义 将struct Node 定义为Node

3.结构体变量的定义和初始化

struct stu
{
  char name[20];
  char tele[11];
  char sex[10];
  int age;

}s4,s5;
struct stu s3;           //全局变量:s3,s4,s5
int main()
{
  //创建的结构体变量
  struct stu s1;      //局部变量:s1,s2
  struct stu s2;

  return 0;
}

struct stu
{
  char name[20];
  char tele[11];
  char sex[10];
  int age;

}s4,s5;
struct stu s3;          
int main()
{
                   //结构体初始化
  struct stu s1 = {"张三","123456","男",20};
  printf("%s %s %s %d", s1.name, s1.tele, s1.sex, s1.age);//结构体成员的访问
  struct stu s2;

  return 0;
}

结构体包含结构体的初始化

struct T
{
  int age;
  char a;

};
struct stu
{
  struct T st;
  char name[20];
  char tele[11];
  char sex[10];
  int age;

}s4,s5;
struct stu s3;          
int main()
{
                 //包含结构体的初始化
  struct stu s1 = { {30,'a'},"张三","123456","男",20};
  printf("%s %s %s %d", s1.name, s1.tele, s1.sex, s1.age);
  printf("%d", s1.st.age);//结构体包含结构体的访问
  struct stu s2;

  return 0;
}

结构体内存对齐

计算结构体的大小

1. 第一个成员在与结构体变量​偏移量为0​的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的​整数倍​的地址处。

对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

VS中默认的值为8

3. 结构体总大小为​最大对齐数​（每个成员变量都有一个对齐数）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到​自己的最大对齐数的整数倍处​，结构体的整体大小就是所有最大对齐数（​含嵌套结构体的对齐数​）的整数倍。

struct s1
{
  char c1;
  int a;
  char c2;
};
struct s2
{
  char c1;
  char c2;
  int a;

};
int main()
{
  struct s1 s1 = { 0 };
  printf("%d\n", sizeof(s1));
  struct s2 s2 = { 0 };
  printf("%d\n", sizeof(s2));


  return 0;
}

存在内存对齐的原因：

1. 平台原因(移植原因)： 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因： 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总体来说是通过内存换取时间

设计内存时如何满足既要满足对齐又要节省空间：让占用小的空间集中在一起

struct s2
{
  char c1;
  char c2;
  int a;

};

修改默认对齐数

之前我们见过了#pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

#include<stdio.h>
struct stu
{
  char c1;
  double d;
};
int main()
{
  struct stu s;
  printf("%d\n", sizeof(s));
  return 0;
}

//设置默认对齐数为4；
#include<stdio.h>/[
#pragma pack(4)
struct stu
{
  char c1;
  double d;
};
#pragma pack()
//取消默认对齐数
int main()
{
  struct stu s;
  printf("%d\n", sizeof(s));
  return 0;
}

offsetof宏的实现

size_t offsetof(structName,memberName);

#include<stdio.h>
#include<stddef.h>
struct s
{
  char c;
  int i;
  double d;
};
int main()
{
  printf("%d\n", offsetof(struct s, c));
  printf("%d\n", offsetof(struct s, i));
  printf("%d\n", offsetof(struct s, d));


  return 0;
}

结构体传参

#include<stdio.h>
struct s
{
  char c;
  int i;
  double d;
};
void Init(struct s* ps)
{
  ps->c = 'w';
  ps->i = 100;
  ps->d = 3.14;
}
void print1(struct s tmp)//传值
{
  printf("%c %d %lf\n", tmp.c, tmp.i, tmp.d);
}
void print2(const struct s* ps)//传址
{
  printf("%c %d %lf\n", ps->c, ps->i, ps->d);
}
int main()
{
  struct s s1 = { 0 };
  Init(&s1);//初始化
  print1(s1);//传值打印
  print2(&s1);//传址打印
  return 0;
}

上面的print1和print2函数哪个好些？

答案是：首选print2函数。

原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能下降。

位段

什么是位段

位段的声明和结构是类似的，有两个不同：

1.位段的成员必须是int、unsigned int 或signed int。

2.位段的成员名后边有一个冒号和一个数字。

#include<stdio.h>
struct A
{
  int a : 2;
  int b : 5;      //一次开辟4个字节
  int c : 10;
  int d : 30;
};
int main()
{
  printf("%d\n", sizeof(struct A));


  return 0;
}

2,5,10,30:表示的是内存中所占的bite位；

位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。

2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

​枚举

​一一列举

枚举类型的定义和使用

//枚举类型
enum sex
{
  //枚举的可能取值-常量
  male,
  female,
  secret
};
int main()
{
  enum sex s = male;
  printf("%d %d %d", male, female, secret);//默认每次加1

  return 0;
}

这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。 例如：

enum sex
{
  //枚举的可能取值
  male = 2,
  female=9,
  secret=8
};
int main()
{
  enum sex s = male;
  printf("%d %d %d", male, female, secret);

  return 0;
}

枚举的优点

为什么使用枚举？

我们可以使用#define 定义常量，为什么非要使用枚举？ 枚举的优点：

1. 增加代码的可读性和可维护性

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

3. 防止了命名污染（封装）

4. 便于调试

5. 使用方便，一次可以定义多个常量

​联合（共用体）​

联合类型的定义

联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间

联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小

#include<stdio.h>
union un
{
  char c;
  int i;

};
int main()
{
  union un u;
  printf("%d\n", sizeof(u));

  printf("%p\n", &u);
  printf("%p\n", &(u.c));
  printf("%p\n", &(u.i));

  return 0;
}

写一个函数判断大小端

1.用指针判断

#include<stdio.h>
int check_sys()
{
  int i = 1;
  //返回1表示小端；
  //返回0表示大端；
  return *(char*)&i;
}
int main()
{
  int i = 1;
  int ret = check_sys();
  if (1 == ret)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }

  return 0;
}

2.用联合体判断

int check_sys()
{
  union un
  {
    char c;
    int i;
  }u;
  u.i = 1;
  //返回1表示小端；
  //返回0表示大端；
  return u.c;
}
int main()
{
  int i = 1;
  int ret = check_sys();
  if (1 == ret)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }

  return 0;
}

联合大小的计算

联合的大小至少是最大成员的大小。

当最大成员大小不是最大对齐数的整数倍的时候，就要​对齐到最大对齐数的整数倍。​

#include<stdio.h>
union un
{
  int a;
  char arr[5];
};
int main()
{
  union un u;
  printf("%d\n", sizeof(u));

  return 0;
}