自定义类型----结构体

scanf_楼

已于 2022-09-21 17:55:15 修改

阅读量158

点赞数

文章标签：开发语言 c语言链表

于 2022-09-21 17:46:36 首次发布

本文链接：https://blog.csdn.net/D_H964/article/details/126975339

版权

As we all know - （如我们所知）

C语言中有很多类型比如char、short 、int 、long 、long long 这些属于什么类型呢内置类型

我们从字面意思上理解就是一个东西里面就有的。看到这，一般都会有阴对阳上对下天对地

雨对风大陆对长空 ... stop

就应该也有自定义类型 -- 确实有

如结构体类型、联合类型、枚举类型

今天我们着重讲一下结构体类型：

struct tag
{
 member-list; //成员变量
}variable-list;//结构体变量

结构的基础知识：

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

结构的声明：

格式如上代码段：

例如我们形容一个人 “姓名”、“年龄”、“身高”、“性别”...都是组成这个人的成员变量

于是我们就可以为之创建一个结构体类型

struct people

{

char name[10];//名字

int age ;//年龄

int h;//身高

char sex[5];//性别

} ;//分号不要丢掉

结构的特殊声明：

即不完全声明：

struct
{
 int a;
 char b;
 float c; 
}x;//只能在这里创建变量

若此时存在一个指针p

struct
{
 int a;
 char b;
 float c; }a[20], *p;

我们给p = &x;能否合法

我们为此进行编译：

显然虽然这两个声明具有相同的成员列表但是编译器还是认为他们是两个截然不同的类型

是非法的。

这两个声明属于匿名结构体类型

结构的自引用：

这个自引用会应用在特定的场景例如链表

我们把链表的每个结点想象成这样的一个长方体上面是数据下面链接下一个结点

由此我们可以创建声明

struct Node  
{
	int data;
    struct Node n;

}Node;

这样OK吗？看似是可以的上面存着数据下面是第二个结点

但是我们在计算结构体的大小时发现了问题？这不是套娃吗？kuakua套娃一个接一个

我们可以修改一下怎么技能链接下一个又可以使结构体大小可计

struct Node  
{
    int data;
    struct Node* next;

};

我们将其换为地址之后可以实现同样的效果

于是我们写入主函数：

int main()
{
struct Node Node;
return 0;
}

不得不说这个类型名真长要是能简化一下就好了

此时我们可以使用重命名。

typedef struct Node  
{
	int data;
	struct Node* next;
}Node;
int main()
{
Node n;//可以使用简化的类型名
return 0;
}

结构体类型定义和初始化

struct Book
{
    char name[20];
    int price;
};

我们可以给成员变量初始化

int main()
{ 
   struct Book s1 = { "书",30 };
   return 0;
}

同时结构体也可以嵌套初始化

struct Stu;
struct Stu
{
	char name[20];
	int age;
};
struct Book
{
	char name[20];
	int price;
	struct Stu s;//嵌套
}s2 = {"书",20};

int main()
{
	struct Book s1 = { "补课",30 ,{"lisi",18}};//结构体嵌套初始化
	struct Book s2;

   //打印的两种方法
	printf("%s %d %s %d", s1.name, s1.price,s1.s.name,s1.s.age);
	//printf("%s %d", (&s1)->name, (&s1)->price);

	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 = { .a = 10,.f = 3.14f,.c = 'w' };//可以乱序初始化
   printf("%c %d %f\n", s.c, s.a, s.f);
}

**结构体内存对齐（*）**

结构体内存对齐规则：

结构体内存对齐规则
1.结构体第一个成员直接对齐到相对于结构体变量起始位置为0的偏移处
2.从第二个成员开始要对齐到某个对齐数的整数倍的偏移处 -- 对齐数是成员结构体自身大小和默认对齐数的较小值 --VS环境默认对齐数为8 LINUX默认对齐数为结构体成员自身大小
3.结构体的总大小必须是最大对齐数的整数倍每个结构体成员都有一个对齐数其中最大的对齐数就是最大对齐数
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

我们根据规则结合代码来看：

struct S1
{
	char a;
	int b;
	char c;
};
struct S2
{
	char a;
	char c;
	int b;
};
int main()
{
//结构体内存对齐
//引用一个宏   offsetof   需要引头文件 #include<stddef.h>
//用来计算结构体成员相对起始位置的偏移量

	//printf("%d\n", offsetof(struct S1, a));
	//printf("%d\n", offsetof(struct S1, b));
	//printf("%d\n", offsetof(struct S1, c));

	//printf("%d\n", offsetof(struct S2, a));
	//printf("%d\n", offsetof(struct S2, c));
	//printf("%d\n", offsetof(struct S2, b));


	//printf("%d\n", sizeof(struct S1));
	//printf("%d\n", sizeof(struct S2));
	return 0;
}

首先我们模拟S1在内存中的存储

一共开辟了12个字节的空间

再来模拟实现S2在内存中的存储

一共开辟了8个字节的空间

为什么结构体对齐？

1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总体来说：结构体内存对齐是用空间换时间的做法

对于性能原因解释一下

如何优化：

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

2.修改默认对齐数。

第一条不再详细解释，来看下第二条

如何设置默认对齐数

#pragma pack(n)

恢复默认对齐数

#pragma

我们看下具体效果

所占空间由12 缩减为 6 所以实现了空间上的优化（但因为是1 实际上并没有对齐）

结构体传参：

struct S
{
    int data[1000];
    int num;
};

void print1(struct S s)  //结构体传参传的是结构体本身
{
    printf("%d %d %d %d\n", s.data[0], s.data[1], s.data[2], s.num);
}

void print2(const struct S* ps)//加const后 也不会通过ps改变结构体  也很安全
{
    //printf("%d %d %d %d\n", (*ps).data[0], (*ps).data[1], (*ps).data[2], (*ps).num);
    printf("%d %d %d %d\n", ps->data[0], ps->data[1], ps->data[2], ps->num);
}

int main()
{
    struct S ss = { {1,2,3,4,5}, 100 };
    print1(ss);//实参传给形参 会开辟一份一样的空间 空间浪费比较严重  导致性能下降
    print2(&ss);//只传4/8个字节 效率较高 尽量传地址
    return 0;
}

之前都有了解结构体传参，这里重要知识点是：

《传址比传值效率更高》