结构体进阶

内容索引：

• 结构体类型的声明
• 结构的自引用
• 结构体变量的定义和初始化
• 结构体内存对齐
• 结构体传参

除了char short int long float double 等内置类型

C语言允许自己创造一些类型

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

结构体类型的声明

结构的基础知识

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

结构的声明

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

例如定义学生类型:

struct Stu
{
	//成员变量
	char name[20];
	int age;
	float weight;
}s4,s5,s6;//全局变量
int main()
{
	struct Stu s1;//局部变量
	struct Stu s2;
	struct Stu s3;
}

特殊的声明

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

//匿名结构体类型  一次性的
struct 
{
	char c;
	int a;
	double d;
}s1;
struct
{
	char c;
	int a;
	double d;
}*ps;
int main()
{
	//ps = &s1;//err
	//编译器会把上面的两个声明当成完全不同的两个类型。
	//所以是非法的。
	return 0;
}

结构的自引用

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

我们从数据结构（描述的是数据在内存中的存储结构）引入 

比如要存储一行数据  1 2 3 4 5 ，有几种方式         

• 线性数据结构 

1.顺序表   连续存储

2..链表      乱序存放    一个又一个结点

• 树形的数据结构：二叉树

其中 链表的结点不仅要存储本身的数据，还要能够找到下一个结点

那么我们应该如何写代码呢？

//正确的自引用方式
struct Node
{
    int data;
    struct Node* next;
};

//一个结构体要找到另一个跟自己同类型的结构体
int main()
{
    struct Node n1;
    struct Node n2;
    n1.next = &n2;

    return 0;
}

注意

typedef struct
{
    int data;
    Node* next;
}Node;
//这样写代码，可行否？
//解决方案：
typedef struct Node
{
    int data;
    struct Node* next;
}Node;

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

#include <stdio.h>
struct S
{
	int a;
	char c;
}s1;

struct B
{
	float f;
	struct S s;
};
int main()
{
	struct S s2 = { 100,'q' };
	//struct S s3 = { .c = 'r',.a = 2000 };//可以不按指定顺序
	struct B sb = { 3.14f,{200,'w'} };//结构体嵌套初始化
	printf("%f,%d,%c\n", sb.f, sb.s.a, sb.s.c);//结构体成员的访问
	return 0;
}

struct S
{
    char name[10];
    int * ptr;
};

int main()
{
    int a = 100;
    struct S s = {"abcdef",NULL};

    return 0;
}

结构体内存对齐

对齐规则：

1.结构体的第一个成员永远都放在0偏移处

2.从第二个成员开始，以后的每个成员都要对齐到某个对齐数的整数倍处

这个对齐数是：成员自身大小和默认对齐数的较小值

备注：

VS环境下 默认对齐数是8

gcc环境下 没有默认对齐数，没有默认对齐数时，对其书就是成员自身的大小

3.当成员全部存放进去后，

结构体的总大小必须是，所有成员的对齐数中最大对齐数的整数倍

如果不够，则浪费空间对齐

4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整

体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

验证上图结构体偏移量

offsetof 宏的实现

//练习1
struct S2
{
    char c1;
    char c2;
    int i;
};
printf("%d\n", sizeof(struct S2));
//练习2
struct S3
{
    double d;
    char c;
    int i;
};
printf("%d\n", sizeof(struct S3));
//练习4-结构体嵌套问题
struct S4
{
    char c1;
    struct S3 s3;
    double d;
};
printf("%d\n", sizeof(struct S));

 

小试牛刀

#include <stdio.h>
struct S1
{
	int a;
	char c;
};
struct S2
{
	char c1;
	int a;
	char c2;
};
struct S3
{
	char c1;
	int a;
	char c2;
	char c3;
};
int main()
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	printf("%d\n", sizeof(struct S3));
	return 0;
}

为什么存在内存对齐 ?

大部分的参考资料都是如是说的：

1. 平台原因 ( 移植原因 ) ：

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特

定类型的数据，否则抛出硬件异常。

2. 性能原因 ：

数据结构 ( 尤其是栈 ) 应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访

问。

总体来说：

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

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

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

//例如：
struct S1
{
    char c1;
    int i;
    char c2;
};//12
struct S2
{
    char c1;
    char c2;
    int i;
};//8

修改默认对齐数

#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

对齐数一般设2的n次方

结构体传参

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(const struct S* ps)
{
    printf("%d\n", ps->num);
}
int main()
{
    print1(s);  //传结构体
    print2(&s); //传地址
    return 0;
}

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

答案是：首选 print2 函数。

原因：

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

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

下降。

结论：

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