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

目录

 

一、结构体

结构体的声明

(1)结构体的基础知识

(1)结构的声明

特殊的声明 

结构体的自引用

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

结构体内存对齐 

---

一、结构体

结构体的声明

(1)结构体的基础知识

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

(1)结构的声明

struct tag
{
    member-list;
}variable-list;

例如定义一个学生

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

特殊的声明 

 在声明结构的时候，可以不完全的声明

比如

//匿名机构体类型
struct
{
    int a;
    int b;
    flout c;
}x;
struct
{
    int a;
    int b;
    flout c;
}a[20],*p;

上面的两个结构在声明的时候省略掉了结构体标签（tag）。
那么问题来了？

//在上面代码的基础上，下面的代码合法吗？
p = &x;

 警告： 编译器会把上面的两个声明当成完全不同的两个类型

结构体的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

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

可行否？
如果可以，那sizeof(struct Node)是多少？

正确的自引用方式：

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

注意： 

//代码3
typedef struct
{
    int data;
    Node* next;
}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[15];//名字
    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、自定义类型有一个对齐值（内部成员最大的一个）

3、程序有一个指定的对齐值（#pragma pack（n）  n为2^x，若为1，则结构体大小为自定义类型之和，默认为8）

4、程序有一个有效对齐值（较小值）

#include<stdio.h>
void fun()
{
	struct s3
	{
		double d;
		char c;
		int i;
	};
	printf("%d\n", sizeof(struct s3));
}
int main()
{
	fun();
	return 0;
}

 输出结果：

结构体嵌套：

#include<stdio.h>
void fun()
{
	struct s3
	{
		double d;
		struct s4
		{
			int a;
			char b;
			long c;
		};
		int i;
	};
	printf("%d\n", sizeof(struct s4));
}
int main()
{
	fun();
	return 0;
}

运行结果：

 

结构体传参

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()
{
    print1(s); //传结构体
    print2(&s); //传地址
    return 0;
}

 上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。

原因：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能
的下降。
结论： 结构体传参的时候，要传结构体的地址

位段
结构体讲完就得讲讲结构体实现 位段 的能力。
什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。
比如：

struct A
{
    int _a:2;
    int _b:5;
    int _c:10;
    int _d:30;
};

 A就是一个位段类型。

那么位段A的大小是多少？

答案：

位段的内存分配
1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

//一个例子
struct S
{
    char a:3;
    char b:4;
    char c:5;
    char d:4;
};
struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
//空间是如何开辟的

位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的。
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

枚举

举顾名思义就是一一列举。
把可能的取值一一列举。
比如我们现实生活中：
一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举
这里就可以使用枚举了。

枚举类型的定义

enum Day//星期
{
    Mon,
    Tues,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};
enum Sex//性别
{
    MALE,
    FEMALE,
    SECRET
}；
enum Color//颜色
{
    RED,
    GREEN,
    BLUE
};

 以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。 {}中的内容是枚举类型的可能取
值，也叫 枚举常量 。
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。 例如：

enum Color//颜色
{
    RED=1,
    GREEN=2,
    BLUE=4
};

枚举的优点

为什么使用枚举？
我们可以使用 #define 定义常量，为什么非要使用枚举？ 枚举的优点：
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常

枚举的使用

enum Color//颜色
{
    RED=1,
    GREEN=2,
    BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5; //ok?