C语言——自定义类型详解(1)

1.什么是自定义类型？

我们知道C语言中有int 、char、 long 、float 、double内置数据类型，自定义类型就是：允许自己创造一些类型，自定义类型:结构体、枚举、 联合体等....

2.结构体（结构的声明与基础知识）

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

结构体的声明
struct tag
{
member-list;
}variable-list;

例如描述一个学生
#include<stdio.h>
struct Stu
{
char name[20]; 名字
int age; 年龄
char sex[5]; 性别
char id[20]; 学号
float weight; 体重
};  分号不能丢

int main()
{
struct stu s1; 学生1 变量
struct stu s2; 学生2 变量
struct stu s3; 学生3 变量
return 0;
}
也可以这样写
#include<stdio.h>
struct Stu
{
char name[20]; 名字
int age; 年龄
char sex[5]; 性别
char id[20]; 学号
float weight; 体重
}s4,s5,s6; 跟下面的s1 s2 s3相同，只不过s4 s5 s6是全局变量

int main()
{
struct stu s1; 学生1 变量   下面是局部变量
struct stu s2; 学生2 变量
struct stu s3; 学生3 变量
return 0;
}

特殊声明

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

匿名结构体类型
struct 
{
char a;
int b;
double c;
}s1;
当省略struct后面结构体的标签名时，这时的结构体是匿名结构体类型

struct 
{
char a;
int b;
double c;
}s1;

int main()
{
   struct s2; 这是错误的，因为匿名结构体没有标签名，不能直接定义变量strcut s2,但可以在匿名结构后面定义s2全局变量后，才能使用。
}

#include <stdio.h>
struct
{
	char c;
	int a;
	double d;
}s1;
struct
{
	char c;
	int a;
	double d;
}*ps;
int main()
{
	ps = &s1; error
	return 0;
}
当我们这样写时编译器会报错，在我们看来两个结构体是一样的，但在编译器眼中它们两是不同类型的结构体
不推荐这种写法，是非法的。

 3.结构体的自引用

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

数据结构：描述的是数据在内存中的存储结构。

 

#include <stdio.h>
//错误示范
struct Node
{
	int data;
	struct Node n;
};
int main()
{
	
	return 0;
}

 把数据分成两部分，第一部分放数据，第二部分放下一个数据结点，以此类推，到最后一个数据的时候，第二部分放个空指针不再往后找。

struct Node
{
	int data; 4
	struct Node *next; 4or8
};
int main()
{
	struct Node n1;
	struct Node n2;
	n1.next = &n2; n1和n2串起来了 next存放的是n2的地址
	return 0;
}

typedef struct 
{
	int data;
	char c;
	
}S;
typedef可以给匿名结构体起个类型名叫S 这里S不是全局变量 而是匿名结构体的类型名


typedef struct
{
int data;
Node* next;
}Node;  可行吗？ error

因为Node是在最后一步定义的，而node*next早一步，有个先后顺序的问题


typedef struct Node
{
int data;
struct Node* next;
}Node;  正确写法

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

有了结构体类型，那如何定义变量，其实很简单。
 

定义
#include <stdio.h>
struct S
{
	char a;
	int b;

}s1; //全局
struct  S s2; //全局
int main()
{
	struct S s3;//局部
	return 0;
}


初始化
#include <stdio.h>
struct S
{
	char a;
	int b;

}s1; //全局
struct  S s2; //全局
int main()
{
	struct S s3 = { 'Q',100 };
	return 0;
}

#include <stdio.h>
struct S
{
	char a;
	int b;

}s1; 
struct  S s2; 
struct B
{
	float f;
	struct S s;
};

int main()
{
	struct S s3 = { 'Q',100 };
	struct B sb = { { 3.14f }, { 'Z',400 } };
    struct S s4 = { .a = 'A',.b = 500 };
    printf("%f %c %d\n", sb.f, sb.s.a, sb.s.b);
	return 0;
}

 

 

 

#include <stdio.h>
struct S
{
	char name[100];
	int* ptr;
};

int main()
{
	struct S s = { "what's up",NULL };
	或者
	int a = 10;
	struct S s = { "what's up",&a };
	return 0;
}

5.结构体内存对齐(重点!)

我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点： 结构体内存对齐

#include <stdio.h>
struct S1
{
	int a;
	char b;
};
struct S2
{
	char c;
	int a;
	char c1;
};
struct S3
{
	char c;
	int a;
	char c1;
	char c2;
};

int main()
{
	printf("%d\n", sizeof(struct S1)); ？
	printf("%d\n", sizeof(struct S2)); ？
	printf("%d\n", sizeof(struct S3)); ？
	return 0;
}

 

 为什么会是 8 12 12呢？

结构体内存对齐

 

#include <stdio.h>
struct S1
{
	char b;
	int a; 只要得出 b=0 a=4 就能知道中间是不是浪费了空间
};
int main()
{
	struct S1 s = {0};
	return 0;
}

 d4到d8相差4个字节

我们也可以用库函数offsetof验证一下，这个函数就是专门求返回成员偏移量的。

offsetof - C++ Reference

#include <stdio.h>
#include<stddef.h>
struct S1
{
	char b;
	int a; //只要得出 b=0 a=4 就能知道中间是不是浪费了空间
};
int main()
{
	struct S1 s = {0};
	printf("%d\n",offsetof(struct S1, b));
	printf("%d\n", offsetof(struct S1, a));
	return 0;
}

 

#include <stdio.h>
struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n",sizeof(struct S2)); 输出多少？
	return 0;
}

 

 

 

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

 

 

 

结构体嵌套问题
#include <stdio.h>
struct S3
{
	double d;
	char c;
	int i;
};
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%d\n", sizeof(struct S4));？？？
	return 0;
}

 为什么存在内存对齐？

1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。

 

总体来说：
结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占用空间小的成员尽量集中在一起。

struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};
S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

 

 修改默认对齐数

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

#include <stdio.h>
#pragma pack(1) 设置默认对齐数为8 对齐数是2^n 不能是奇数
struct S1
{
	char c1;//1 1 1
	int i;//4 1 1
	char c2;//1 1 1
};
#pragma pack()  取消设置的默认对齐数，还原为默认
int main()
{
	printf("%d ", sizeof(struct S1));
	return 0;
}

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。

 

 6.结构体传参

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

结论：
结构体传参的时候，要传结构体的地址。

7.位段

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

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

 

 

 

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. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的。
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

位段的应用

 

 在传输数据的时候，把字节弄小，可以更好的传输信息，不会堵塞。

8.枚举

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

#include<stdio.h>
enum Sex
{
	枚举的可能取值，默认是从0开始的，递增1的;
	枚举常量
	MALE,
  FEMALE,  枚举后面是，不是;
  SECRET,

};

int main()
{
	enum Sex s = MALE;
	printf("%d\n", MALE);0
	printf("%d\n", FEMALE);1
	printf("%d\n", SECRET);2

	return 0;
}

#include<stdio.h>
enum Sex
{
	枚举的可能取值，默认是从0开始的，递增1的;
	枚举常量
	MALE=5,
	FEMALE,  枚举后面是，不是;
	SECRET,

};

int main()
{
	enum Sex s = MALE;
	printf("%d\n", MALE);5
	printf("%d\n", FEMALE);6
	printf("%d\n", SECRET);7

	return 0;
}



#include<stdio.h>
enum Sex
{
	//枚举的可能取值，默认是从0开始的，递增1的;
	//枚举常量
	MALE ,
	FEMALE=5,  //枚举后面是，不是;
	SECRET,

};

int main()
{
	enum Sex s = MALE;
	printf("%d\n", MALE);0
	printf("%d\n", FEMALE);5
	printf("%d\n", SECRET);6

	return 0;
}

 

 

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

#define是没有类型的  而枚举有类型 当我们用enum做目录时，可以定义变量exit和play，因为默认是0和1 更符合调试。