『C』自定义类型详解

结构体

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

匿名结构体

代码演示

#include <stdio.h>

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

struct {
	char a;
	int b;
	double c;
} *p;

int main(){
	p = &s;

	return 0;
}

运行结果

[sss@aliyun self_type]$ gcc anonymous_struct.c -o anonymous_struct
anonymous_struct.c: In function ‘main’:
anonymous_struct.c:16:4: warning: assignment from incompatible pointer type [enabled by default]
  p = &s;
    ^

结论：上面两个结构体是不同类型的。

结构体的自引用

代码演示

#include <stdio.h>

struct Node{
	int value;
	struct Node next;
};

int main(){

	struct Node node;

	return 0;
}

运行结果

[sss@aliyun self_type]$ gcc self_reference.c -o self_reference
self_reference.c:5:14: error: field ‘next’ has incomplete type
  struct Node next;
              ^

代码修改

#include <stdio.h>

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

int main(){

	struct Node node;

	return 0;
}

运行结果

[sss@aliyun self_type]$ !gcc
gcc self_reference.c -o self_reference

结论：struct Node next;正确的自引用方式*。

再看下面两个代码，哪个是对的。

/*---代码一---*/
typedef struct Node {
	int value;
	Node* next;
} Node;

/*---代码二---*/
typedef struct Node {
	int value;
	struct Node* next;
} Node;

代码二是对的。

结构体内存对齐

内存对齐规则

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。（对齐数 = min（编译器默认的一个对齐数（VS中默认为8，Linux中默认为4），该成员变量大小））。
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍地址处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

为什么存在内存对齐

平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
总体来说，结构体的内存对齐就是空间换时间的一种做法。
设计结构体的时候，让占用空间小的成员尽量集中在一起，既能满足内存对齐，还能节省空间。
现代计算机体系结构中，CPU每次读写内存中的数据，都是按字为一个块来操作的。这个块的大小取决于有多少根数据总线，对于X86架构，系统是32位的，数据总线和地址总线都是32根，所以最大寻址空间为4G，每次读取的块大小为32位即4个字节。
既然如此，如果变量在内存中存储的时候也按这样的规则进行对齐，就可以加快CPU读写内存的速度，当然也就提高了整个程序的性能。虽然当今CPU的处理数据速度（逻辑运算等，不包括取址）远比内存访问的速度快，程序的执行速度的瓶颈往往不是CPU的处理速度不够，而是内存访问的延迟，虽然如今CPU中加入了高速缓存用来掩盖内存访问的延迟，但是如果高密集的内存访问，延迟还是无可避免的，内存地址对齐会给程序带来很大的性能提升。
举例说明：

方案一和方案二的存储方式，哪个读取比较快？（地址仅为方便理解，不要过分纠结。）
显然是方案二。
分析：
方案一，CPU为了读取这个int比那两的值，需要先后读取两个块，分别是0x0000 0000~0x0000 0003和0x0000 0004~0x0000 0007，然后通过移位等一系列的操作来得到，在这个计算的过程中还有可能引起一些总线数据错误。但是CPU对方案二中int型数据的读取只需要读取一个块0x0000 0000~0x0000 0003。明显快了很多。

代码示例

#include <stdio.h>

struct S1{
	char c1;
	int i;
	char c2;
};

struct S2{
	char c1;
	char c2;
	int i;
};

int main(){

	printf("S1: %lu\n", sizeof(struct S1));
	printf("S2: %lu\n", sizeof(struct S2));

	return 0;
}

运行结果

[sss@aliyun self_type]$ gcc struct_design_compare.c -o struct_design_compare
[sss@aliyun self_type]$ ./struct_design_compare 
S1: 12
S2: 8

修改默认对齐数

代码示例

// 修改默认对齐数为8
#pragma pack(8)

struct S1{
	char c1;
	int i;
	char c2;
};

// 还原默认对齐数
#pragma pack()

位段

C语言中允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”。利用位段能够用较少的位数存储数据。

位段的声明

位段的声明和结构体时类似的，有两个不同。
位段的成员必须是int、unsigned int或signed int。
位段的成员名后边有一个冒号和一个数字。

位段的内存分配

位段的成员可以是int、unsigned int、signed int或者char（属于整型家族）类型。
位段的空间还是哪个是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的。
位段设计很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

代码演示

#include <stdio.h>
#include <stdlib.h>

struct S {
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

int main(){

	struct S s = { 0 };

	s.a = 1;
	s.b = 2;
	s.c = 3;
	s.d = 4;

	printf("S: %lu\n", sizeof(struct S));
	
	system("pause");
	return 0;
}

位段的跨平台问题

int位段被当成有符号数还是无符号数是不确定的。
位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32），写成27，在16位机器会出问题。
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结

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

枚举

如果一个变量只有几种可能的取值，则可以定义为枚举类型，所谓枚举类型就是指把可能的值一一列举出来，变量的值只限于列举出来的值的范围内。

枚举类型的定义

enum Week{
	Mon, Tues, Wed, Thur,
	Fri, Sat, Sun
};

enum Sex{
	Male, Female
};

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

enum Sex{
	Male = 5, 
	Female = 2
};

枚举的优点

增加代码的可读性和可维护性。
和#define定义的标识符比较枚举有类型检查，更加严谨。
防止了命名污染（封装）。
便于调试。
使用方便，一次可以定义多个变量。

枚举的使用

enum Sex{
	Male, Female
};

enum Sex sex = Male;

联合体

有时候想用同一段内存单元存放不同类型的变量。例如：把一个短整型变量、一个字符型和一个实型变量存放在同一个地址开始的内存单元中。

以上三个变量在内存中占的字节数不同，但都从同一地址开始（图中设地址为0x73fff467）存放，也就是使用覆盖技术，后一个数据覆盖了前面的数据。这种使几个不同的变量共享同一段内存的结构，称为“联合体”类型的结构。

声明和定义

代码演示

#include <stdio.h>

typedef union Un{
	int i;
	char c;
} Un;

int main(){
	Un un;

	un.i = 1;

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

	printf("i: %d\n", un.i);
	printf("c: %d\n", un.c);

	return 0;
}

运行结果

[sss@aliyun self_type]$ !gcc
gcc union.c -o union
[sss@aliyun self_type]$ ./union 
i: 0x7ffdb7042b40
c: 0x7ffdb7042b40
i: 1
c: 1

联合体大小的计算

联合体大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

代码演示

#include <stdio.h>

union U1{
	char c[5];
	int i;
};

union U2{
	short s[7];
	int i;
};

int main(){

	printf("U1: %lu\n", sizeof(union U1));
	printf("U2: %lu\n", sizeof(union U2));

	return 0;
}

运行结果

[sss@aliyun self_type]$ gcc size_union.c -o size_union
[sss@aliyun self_type]$ ./size_union 
U1: 8
U2: 16