结构体
1 结构体的声明
1.1 结构的基础知识
结构是一些值得集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。
1.2 结构的声明
struct tag
{
member - list;
}variable-list;
//方式一:
struct Stu
{
char name[20];
int age;
};// ; 不能丢
//方式二:
struct Stu
{
char name[20];
int age;
} s1,s2;//s1和s2是结构体类型全局变量
int main()
{
struct Stu s3;//s3是局部变量
return 0;
}
1.3 特殊的声明
在声明结构的时候,可以不完全的声明。
比如:
//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20],*p;
上面两个结构在声明的时候省略了结构体标签(tag)。
那么在上面代码的基础上,下面的代码合法吗?
p = &x;
警告:
编译器会把上面的两个声明当成完全不同的两个类型,所以是非法的。
1.4 结构体的自引用
在结构体中包含一个类型为该结构本身的成员是否可以呢?
//代码1
struct Node
{
int date;
struct Node next;
};
//上面这种写法可行吗?
//如果可以,那sizeof(struct Node)是多少?
答案是不可行的,每一个next里面包含下一个next,无限套娃。
正确的自引用方式:
//代码2
struct Node
{
int date;
struct Node* next;
};
那么下面的代码可行吗?
//代码3
typedef struct
{
int date;
Node* next;
}Node;
答案是不可行,这样匿名创建变量是冲突的。
正确代码:
typedef struct Node
{
int data;
struct Node* next;
}Node;
1.5 结构体变量的定义和初始化
struct Point
{
int x;
int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2
//初始化:定义变量的同时赋初值
struct Point p3 = { 1,3 };
struct Stu//类型声明
{
char name[20];//名字
int age;//年龄
};
struct Stu s = { "zhangsan",20 };//初始化
struct Node
{
int date;
struct Point p;
struct Node* next;
}n1 = { 10,{ 4, 5 },NULL };//结构体嵌套初始化
struct Node n2 = { 20,{5,6},NULL };//结构体嵌套初始化
示例:
#include <stdio.h>
struct score
{
int n;
char ch;
};
struct Stu
{
char name[20];
int age;
struct score s;
};
int main()
{
struct Stu s1 = { "zhangsan",20,{100,'q'} };
printf("%s %d %d %c\n", s1.name, s1.age, s1.s.n, s1.s.ch);
return 0;
}
1.6 结构体内存对齐
掌握了结构体的基本使用后,我们讨论一个问题:计算结构体的大小。
这也是一个特别热门的考点:结构体内存对齐
#include <stdio.h>
//练习1
struct s1
{
char c1;
int i;
char c2;
};
//练习2
struct s2
{
char c1;
char c2;
int i;
};
//练习3
struct s3
{
double d;
char c;
int i;
};
//练习4-结构体嵌套问题
struct s4
{
char c1;
struct s3 s;
double d;
};
int main()
{
printf("%d\n", sizeof(struct s1));
printf("%d\n", sizeof(struct s2));
printf("%d\n", sizeof(struct s3));
printf("%d\n", sizeof(struct s4));
return 0;
}
考点:如何计算?
首先要掌握结构体的对齐规则:
1、第一个成员位于结构体变量偏移量为0的地址处。
2、其他成员要对齐到某个数字(对齐数)的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
vs中默认的值为8
3、结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
4、如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
练习1:
1、把c1放到起始位置,称它偏移量为0
2、编译器默认值为8,int类型大小为4,所以变量i的对齐数为4,i要到4的整数倍的地址处,所以变量 i 跨过三个字节到(相对于起始位置)偏移量为4的地址处,int类型占4个字节
3、编译器默认值为8,char类型大小为1,所以变量c2的对齐数为1,变量c2到偏移量为8的地址处
4、结构体的最大对齐数为4,而结构体的总大小是最大对齐数的整数倍,现在函数是9个字节,不满足,所以跳过三个字节,到达偏移量为11的地址处,此时结构体的大小为12字节
验证:
利用offsetof
(宏)函数来求一个变量在类型中的偏移量
#include <stdio.h>
#include <stddef.h>
//练习1
struct s1
{
char c1;
int i;
char c2;
};
int main()
{
printf("%d\n", offsetof(struct s1, c1));
printf("%d\n", offsetof(struct s1, i));
printf("%d\n", offsetof(struct s1, c2));
return 0;
}
输出结果:
练习2:
1、第一个成员c1放在与结构体变量偏移量为0的地址处
2、编译器默认值为8,c2变量大小为1,所以对齐数为1,c2放在1的倍数处,放在偏移量为1的地址处
3、i变量大小为4,所以对齐数为4,i变量放在4的倍数处,所以跳过两个字节,放在偏移量为4的地址处
4、结构体总大小为最大对齐数4的整数倍,此时结构体大小为8,是4的倍数,所以结构体总大小为8
练习3:
练习4:
最终运行结果:
为什么存在内存对齐?
1、平台原因(移植原因):
不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取得某些特定类型的数据,否则抛出硬件异常。
2、性能原因:
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;二对齐的内存访问仅需一次访问。
总体来说:
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到?
让占用空间小的成员尽量集中在一起
//例如:
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
S1和S2类型的成员一模一样,但是S1和S2所占空间的大小有了一些区别。
1.7 修改默认对齐数
我们可以利用#pragma
这个预处理指令来改变我们的默认对齐数
#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
int main()
{
//输出的结果是什么?
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
输出结果:
结论:
结构在对齐方式不合适的时候,我们可以自己更改默认对齐数
1.8 结构体传参
#include <stdio.h>
struct S
{
int data[1000];
int num;
};
void print1(struct S ss)
{
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d \n", ss.data[i]);
}
printf("%d", ss.num);
}
void print2(struct S* ps)
{
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d \n", ps->data[i]);
}
printf("%d", ps->num);
}
int main()
{
struct S s = { {1,2,3},100 };
print1(s);//传值调用
print2(&s);//传址调用
return 0;
}
上面的print1
和print2
函数哪个好一些?
答案是:print2好一些
原因:
函数传参的时候,参数是需要压栈的,会有时间和空间上的系统开销。
如果传递一个结构体对象的时候,结构体过大,参数压栈的系统开销比较大,所以会导致性能的下降。
结论:
结构体传参的时候,尽可能要传结构体的地址。