结构体类型创建：
结构体的声明：
结构是一些值的集合，这些值称为成员变量，结构体的每个成员可以是不同类型的变量;
eg:
struct Stu
{
char name[20];
int age;
char sex[5];
char tele[12];
};
int main()
{
struct Stu s;
return 0;
}下面我们用一张图来看一下这段代码之间的关系:
特殊的声明:
在声明结构体的时候，可以不完全声明。
eg:
struct
{
char name[20];
int age;
char sex[5];
char tele[12];
}s1;
struct
{
char name[20];
int age;
char sex[5];
char tele[12];
}*p1;
int main()
{
p1 = &s1;
return 0;
}当执行上面的代码时，编译器会把上面的俩个声明当成完全不同的俩个类型，所以是非法的。
结构体的成员：
结构体的成员可以使标量，数组，指针，甚至是其他结构体。
结构体变量访问成员结构变量的成员是通过点操作符（.)访问的。点操作符接受俩个操作数。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
char name[20];
int age;
char sex[5];
char tele[12];
};
int main()
{
struct Stu s;
s.age = 20;
strcpy(s.name, "zhangsan");
strcpy(s.sex, "保密");
printf("name = %s\n", s.name);
printf("age = %d\n", s.age);
printf("sex = %s\n", s.sex);
system("pause");
return 0;
}程序运行结果如下：
从上面的程序运行结果我们很容易看出通过点操作符（.)我们可以很好的访问结构体的每一个成员。
其他访问形式：
struct Stu
{
char name[20];
int age;
char sex[5];
char tele[12];
};
int main()
{
struct Stu s;
struct Stu* ps = &s;
ps->age = 20;
printf("age=%d\n", s.age);
system("pause");
return 0;
}运行结果：
这里我们可以看到我们通过指针的形式，用 “–>”箭头操作符也可以完成对结构体成员的访问。
结构体自引用：
正确的自引用写法：
typedef struct Node
{
int data;
struct Node* next;
};结构体的定义和初始化:
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
char name[20];
int age;
char sex[5];
char tele[12];
};
int main()
{
struct Stu s = { "zhangsan",20,"保密","13576549999" };
printf("%s,%d,%s,%s\n",s.name,s.age,s.sex,s.tele );
system("pause");
return 0;
}
在这里我们通过代码及运行结果就可以看出结构体的定义以及初始化的具体过程。
当然我们也可能会遇到比较复杂的结构体的初始化，比如：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct B
{
int a;
float f;
int arr[10];
};
struct Stu
{
char name[20];
int age;
char sex[5];
struct B sb;
char tele[12];
};
int main()
{
struct Stu s = { "zhangsan",20,"保密",{15,3.14f,{1,2,3}},"13576549999" };
printf("%s,%d,%s,%s|%d %f %d %d %d\n",s.name,s.age,s.sex,
s.tele,s.sb.a,s.sb.f,s.sb.arr[0], s.sb.arr[1], s.sb.arr[2]);
system("pause");
return 0;
}运行结果如图:
结构体内存对齐：
这里我们先看下面俩段代码
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
char c1;
char c2;
int i;
char c3;
};
int main()
{
printf("%d\n", sizeof(struct S));
system("pause");
return 0;
}运行结果：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
struct S
{
char c1;
char c2;
int i;
char c3;
};
int main()
{
/*printf("%d\n", sizeof(struct S));*/
printf("%d\n", offsetof(struct S, c1));
printf("%d\n", offsetof(struct S, c2));
printf("%d\n", offsetof(struct S, i));
printf("%d\n", offsetof(struct S, c3));
system("pause");
return 0;
}运行结果:
接下来我们来详细分析上面俩个代码：
重点注意：
**首先第一段代码我们看到通过运行结果我们看到这个结构体的大小为12个字节。而在我们自己看来很大部分的一部分人都会以为是1+1+4+1=7个字节。之所以这样认为是因为我们还不能更深刻的理解到内存对齐这个概念。
接下来我们看着第二段代码，这里我们首先得清楚 offsetof 这个关键字其实就是一个宏，他其实就是定义的是每个字符相对起始位置的偏移量。
接下来我们用一幅图从内存的角度更加深刻的去了解这俩段代码，以及内存对齐的概念：
内存对齐的原因：
1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因： 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
这里我们清楚的可以看见内存对齐其实就是用空间换取了时间。
内存对齐的规则：
1.结构体的第一个成员永远都对齐到结构体起始位置的0偏移处。
2.从第二个成员开始每个成员都对齐到【对齐数】的整数倍处，对齐数为成员自身大小和【默认对齐数】的较小值。
默认对齐数：
linux—4
win—8
3.结构体的总大小是对齐数中最大对齐数的整数倍。
利用pragma来定义结构体内存对齐的默认对齐数：
eg：
#pragma pack（4）
struct S
{
double i;
int c
};在这里当程序运行后我们可以得到结构体S的大小为12，而不是16，这里我们就通过pragma来改变了结构体内存的默认对齐数，从而节省了内存空间。当我们只想节省空间而不考虑时间时，我们就可以通过这种方式直接将内存的默认对齐数改为1，此时就是不对齐，这种能大量节省内存空间。
特殊的结构体的大小：
看下面这个程序：
struct S
{
int i;
char arr[5];
};这里这个结构体大小为12，而不是10，因为这里char型的数组我们可以理解为5个char型的字符连着放，所以默认对齐数就为4，从而得到我们的结构体的大小为12。
结构体传参：
讲解函数栈帧时，函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能下降。因此，结构体传参的时候，要传结构体的地址。
位段：
位段的成员必须是 int,unsigned int,signed int.但实际我们发现其实位段的成员也可以是char型。
位段成员后边必须有一个冒号和数字。
eg;
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
printf("%d\n",sizeof(struct A））；
return 0；
}运行结果如图：
在这里我们可看到运行结果为8，即这个结构体占8个字节大小。其实在这里我们应该这样理解。当创建a是我们默认会开辟一个int型的大小空间，而int大小为4个字节，即32个比特位。而位段就是每个变量所占的比特位。所以a开辟32个比特位，它用了2个，b用了5位，c用了10，剩余15位，而到d这里已经不够了，所以默认在开辟32个比特位，而在d这里他可以先把前面15位用了，在从新开辟的32个字节里拿15，当然啊也可以选择直接从新开辟的32个比特位中拿30个比特位。
我们在看下一段代码及运行结果：
这里我们用上面所用同样的方法可以得到S的大小为3个字节。
接下来我们从内存的角度深入了解计算机中位段的大小：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
char a : 3;//1
char b : 4;
char c : 5;//1
char d : 4;//1
};
int main()
{
struct S s = { 0 };
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
return 0;
}
然后我们先用一张图来分析一下这段代码：
这里我们看到代码每一步走完之后内存中&s的所存的内容就应为：62 03 04 .
接下来我们按f10进去调试看看内存中&s的内容，如图：
正如我们上面分析的一样，&s内存中此时放的正是
62 03 04
虽然位段能很好的节省空间，但他也有自身的问题。
位段的跨平台问题
1.int位段被当成有符号数还是无符号数是不确定的。
2.位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32）
3.位段中的成员在内存中从左向右分配还是从右向左分配还没有定义。
4.当一个结构体包含两个位段，第二个位段成员较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
枚举：
枚举：在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。是一个被命名的整常数的集合。那么通俗点讲就是一一列举。
同样的，枚举是一种类型，那么我们就来依次看看它的定义即使用方法。
接下来我们来看一个枚举的例子：
enum Day
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun,
};
上面定义的enum Day是枚举类型。
{}中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
例如下面的程序：
enum ENUM_A
{
X1,
Y1,
Z1=255,
A1,
B1,
};
enum ENUM_A enumA = Y1;
enum ENUM_A enumB = B1;此时 :
enumA=1,enumB=257
枚举的优点：
1.增加代码的可读性和可维护性。
2.和#define定义的标识符比较枚举有类型检查，更加严谨。
3.防止了命名的污染（封装）
4.便于调试
5.使用方便，一次可以定义多个常量
联合（共用体）
联合类型的定义
联合也是一种特殊的自定义类型
这种类型定义的变量包括一系列成员，特征是这些成员公用一块空间（所以联合体也叫共用体）。
比如：
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf（"%d\n",sizeof(un));联合的特点：
联合的成员是共用一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小。（因为联合至少得有能力保存最大的那个成员）。
#include<stdio.h>
#include<stdlib.h>
union Un
{
int i;
char c;
};
union Un un;
int main()
{
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
/*printf("%d\n", &(un.i));
printf("%d\n", &(un.c));*/
system("pause");
return 0;
}这里输出结果就为：112233555
因为在计算机内部存储为小端的形式：
具体的存储方式如图：
因为这里计算机里内存是以小端格式存储的，所以 union.i 的存储方式如上图所示，而union 表示共用体所以这里当un.c占一个字节时刚好就会将44覆盖掉，因此输出的结果为 0x11223355.
联合体大小的计算：
**联合体的大小至少是最大的成员。
**当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
比如：
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
int main()
{
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
system("pause");
return 0;
}运行结果： 8 16
解析：这里 union1中有5个char型的数，和一个int ，所以他的大小为5，又因为最大对齐数为4，所以浪费3个字节，总大小为8.
union2里有七个short为14，一个int，大小为14就够了，但最大对齐数为4，所以内存对齐时浪费俩个字节，总大小为16.
扫一扫
789
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
