我们知道c语言有很多内置类型如下,而对于复杂地事物,这些类型是无法进行描述的,所以c语言引入了自定义类型,让我们根据所需来设置类型:
继内存操作函数,本章来介绍 自定义类型之 结构体 本章重点
结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。
struct tag //tag标签名,根据实际需求自定义 { member-list;//成员变量 }variable-list;//创建结构体类型顺便创建的变量,也是struct tag类型的变量,是全局变量,可以不创建
示例:
struct Book//定义一本书
{
char Book_name[20];//成员变量
char authar[20];//成员变量
int price;//成员变量
char id[15];//成员变量
}sb3, sb4;
//sb3,sb4 也是struct Book类型的结构体变量
//是全局变量
//可以不创建
//描述一个学生
struct stu
{
char mame[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
};//分号不能丢
int main()
{
struct Book sb1;//局部变量;
struct Book sb2;//局部变量;
struct stu ss1;
struct stu ss2;
return 0;
}
在声明结构的时候,可以不完全的声明。 比如:
struct//这里没有定义名称
{
char book_name[20];
char author[20];
int price;
char id[15];
}sb1,sb2;//匿名结构体类型
匿名结构体类型如果没有定义名称,必须在结构体末尾进行声明,下面主函数main中的写法是错误的:
struct//这里没有定义名称
{
char book_name[20];
char author[20];
int price;
char id[15];
}sb1,sb2;//匿名结构体类型
int main()
{
struct sb3;//匿名结构体类型,必须使用上面的声明方式
struct sb4;//匿名结构体类型,必须使用上面的声明方式
return 0;
}
那么,如果成员变量相同,两个匿名结构体的类型是否相同呢? 我们给出如下代码:
struct
{
char book_name[20];
char author[20];
int price;
char id[15];
}sb1;
struct
{
char book_name[20];
char author[20];
int price;
char id[15];
}* ps;//*前是匿名结构体类型,加上*,就是匿名结构体类型的指针,ps是匿名结构体类型的指针变量
int main()
{
ps = &sb1;//如果能够赋值,说明这两个结构体类型是一样的
return 0;
}
//匿名结构体类型,虽然成员相同,但是编译器会认为他俩的类型是不一样的
运行结果:
警告: 编译器会把上面的两个声明当成完全不同的两个类型。 所以是非法的。
在结构中包含一个类型为该结构本身的成员是否可以呢? 这里我们需要涉及数据结构中的链表,下面我们进行简单的介绍:
如果自引用时采取链式结构,在结构中包含一个类型为该结构本身的成员是否可以呢?
//代码1
struct Node
{
int data;
struct Node next;
};
这样的代码设计是否合理呢? 如果可以,那sizeof(struct Node)是多少? 这里是无限套用的,无法确定结构体的大小 写法错误!!
//代码2
struct Node
{
int data;
struct Node* next;//里边包含了一个同类型的结构体指针
};
int main()
{
struct Node n;//这里声明变量时必须写struct,如果不想写,可以使用typedef 将结构体整体重命名为其他的形式 如下面的代码3
return 0;
}
//代码3
typedef struct Node
{
int date;
struct Node* next;
}Node;//将结构体类型重新命名为Node,重命名之前不可以使用
int main()
{
Node n;//这里Node前的struct就可以不写了
return 0;
}
对于是否使用重命名,我认为,尽量还是不要使用重命名,因为这并不会让你少写多少代码,不妨直接按标准来。当然,每个人的看法不同,可以根据自己的想法去选择。
有了结构体类型,那如何定义变量,其实很简单。
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
struct Stu s;
}p1;//声明类型的同时定义变量p1
struct Book p2; //定义结构体变量p2
int main()
{
struct Book p3;//定义结构体变量p3
return 0;
}
有了结构体类型,那如何定义变量,其实很简单,这里我们在代码中可以更容易地理解:
struct Stu
{
char name[20];
int age;
char id[12];
}p4 = {"张三",12,"123"};//声明类型的定义变量p1的同时初始化
struct Stu p2 = { "李四",14,"345" }; //初始化:定义变量的同时赋初值
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
struct Stu s;
}p1 = { "童话","安徒生",88,"ats123",{"liting",30,"ba20220101"} }, p5;///结构体嵌套初始化
int main()
{
struct Book p3 = {"史记","小明",88,"hg0001"};//定义结构体变量
printf("%s %s %d %s %s %d %s\n", p1.book_name, p1.author, p1.price, p1.id, p1.s.name, p1.s.age, p1.s.id);
return 0;
}
注意:如果是整型,不需要加 " "
自定义 成员输入的顺序
struct S
{
char c;
int a;
float f;
};
int main()
{
struct S s = {'w', 10, 3.14f};
printf("%c %d %f\n", s.c, s.a, s.f);
struct S s2 = {.f = 3.14f, .c = 'w', .a = 10};
printf("%c %d %f\n", s2.c, s2.a, s2.f);
return 0;
}
通过代码和运行结果的对比,得出: 不一定按照默认的顺序输入,以上面S2的输入方式可以不按顺序输入。
我们已经掌握了结构体的基本使用了。 现在我们深入讨论一个问题:计算结构体的大小。 这也是一个特别热门的考点:结构体内存对齐 下面代码的结果是什么呢?
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
struct S1 s1;//创建了结构体变量s1,在内存中开辟了空间
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
你的答案是否为6 6; 正确答案:
那到底是为什么呢?这里我们需要用到offsetof函数来进行深入理解
offsetof 宏 用于计算结构体成员相对于起始位置的偏移量
代码如下:
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
#include<stddef.h>
int main()
{
printf("%d\n", offsetof(struct S1,c1));
printf("%d\n", offsetof(struct S1,i));
printf("%d\n", offsetof(struct S1, c2));
printf("%d\n", offsetof(struct S2, c1));
printf("%d\n", offsetof(struct S2, c2));
printf("%d\n", offsetof(struct S2, i));
return 0;
}
得到的偏移量结果:
根据上面sizeof和offsetof的运行结果,我们知道, 结构体S1的大小为12个字节,而结构体S1中的变量c1,i,c2距离初始位置的偏移量分别为0,4,8; 结构体S2的大小为8个字节,而结构体S1中的变量c1,c2,i距离初始位置的偏移量分别为0, 1, 4; 根据这些内容和不同类型所占的字节数,我们可以画出S1,S2内存分布图如下:
根据上图我们发现,内存中并不是连续存放的,而且浪费了一部分空间,那产生这些的原因是什么呢? 这就是我们要探究的知识点了
如何计算? 首先得掌握结构体的对齐规则:
图解:
#include<stdio.h>
#include<string.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;
}
看到这里,如果还是不懂的话,请反复参考图片看定义,也许是哪一小点没有注意到;
总体来说:
结构体的内存对齐是拿空间来换取时间的做法。
上图结构体成员一样就是顺序不同,但所占空间的大小却不同
那在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到:
让占用空间小的成员尽量集中在一起。
上面我们有提到默认对齐数,那这个是否可以修改呢?
之前我们见过了#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));
struct S1结果为8之前我们已经介绍过了,这里我们介绍一下struct S2,通过前面的学习想必你已经看出来了,其实和没有设置对齐数是一样的结果为6。如下图:
结论: 结构在对齐方式不合适的时候,我么可以自己更改默认对齐数。
百度笔试题: 写一个宏,计算结构体中某变量相对于首地址的偏移,并给出说明 考察:offsetof宏的实现 注:这里还没介绍宏,可以放在介绍完宏后再实现。
直接上代码:
#include<stdio.h>
struct S
{
int date[1000];
int num;
};
void print1(struct S s)
{
printf("%d %d %d %d\n", s.date[0], s.date[1], s.date[2], s.num);
}
void print2(struct S* ps)
{
//printf("%d %d %d %d\n", (*ps).date[0], (*ps).date[1], (*ps).date[2], (*ps).num);
printf("%d %d %d %d\n", ps->date[0], ps->date[1], ps->date[2], ps->num);
}
int main()
{
struct S ss = { {1,2,3,4,5},100 };
print1(ss);
print2(&ss);
return 0;
}
上面的print1和print2函数哪个好些? 答案是:首选print2函数。 原因:
函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。 如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的下降。
当然,如果担心这样会更改原来的参数,可以将void print2(struct S* ps) 改为void print2( const struct S* ps)
这里我们关于自定义类型结构体的内容就介绍完了, 文章中某些内容我们之前有介绍,所以只是一笔带过,还请谅解。 希望以上内容对大家有所帮助👀,如有不足望指出🙏