结构体讲解

星纭

于 2024-03-25 17:45:25 发布

阅读量955

点赞数 28

分类专栏： C 文章标签： c语言开发语言

本文链接：https://blog.csdn.net/CNDS_lili/article/details/136988341

版权

C 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一.结构体类型的声明

(1)结构体的声明

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

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

例如使用结构体描述一个学生：

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
};//这里可以不写

(2)结构体的创建和初始化

#include<stdio.h>
struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
};//这里可以不写

int main()
{
	struct Stu s1 = { "张三",18 ,"男"};
	//结构体成员的初始化要按顺序进行。	
	// struct Stu s1 = { "张三","男"，18};
	//这样就是不行的。
	printf("%s ",s1.name);
	printf("%d ",s1.age);
	printf("%s ",s1.sex);
	printf("\n");
	//也可以指定进行初始化
	struct Stu s2 = {.age = 18,.name = "李四",.sex = "女"};
	printf("%s ", s2.name);
	printf("%d ", s2.age);
	printf("%s ", s2.sex);
	return 0;
}

(3)匿名结构体

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

struct
{
	int a;
	char b;
	float c;
}x;

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

这两个结构体就省略掉了结构体标签（tag）

那么问题来了？

第一个结构体和第二个结构体的成员变量都是一模一样的。

p = &x;

这个代码是否有问题？

warning C4133: “=”: 从“*”到“*”的类型不兼容

编译器会发生警告，这两个结构体是不同的类型，所以是非法的。

匿名的结构体类型，如果没有对结构体类型进行重命名的话，基本上是只能使用一次。

(4)结构体的自引用

在一个结构体中包含一个类型为结构体本身的成员是否可以呢？
比如定义一个链表的节点：

struct Node
{
    int val;
    struct Node next;
};

上面的代码正确吗？

结构体的大小应该是固定的，一个结构体包含自己和另一个整形变量，这肯定是不合理的，这样的变量会无穷大。正确的自引用应该是包含一个结构体指针指向下一个结构体。

typedef struct
{
	int val;
	Node* next;
}Node;

这个代码可行吗？

答案是不行的，因为Node是对前面的匿名结构体进行了重命名，但是在匿名结构体内存提前使用了Node类型的变量来创建成员变量，这是不行的。

所以在定义结构体的过程中尽量不要使用匿名结构体。

二.结构体内存对齐

我们已经掌握了结构体的基本使用，现在我们可以深入讨论一个问题：结构体的大小？

#include<stdio.h>
struct s1
{
	int a;
	char b;
};
struct s2
{
	char a;
	int b;
	char c;
};
int main()
{
	printf("%zd\n",sizeof(struct s1));
	printf("%zd\n",sizeof(struct s2));
	return 0;
}

思考一下s1和s2所占字节是多少？

输出结果：

struct s1的大小是8个字节，为什么不是4（int）+ 1(char)=5个字节呢？？？

同理为什么struct s2不是6个字节呢？

说明在这个结构体中内存是存在一定的浪费的。

(1)对齐规则

偏移量就是距离结构体第一个字节的距离，第一个字节的偏移量是0，第二个偏移量是1，同理依次类推。

struct s1
{
	int a;
	char b;
};

我们先来计算这个结构体的大小。

规则1：就是结构体的第一个成员要放在最前面的位置

也就是int占据前4个字节。

什么是对齐数呢？

除了第一个成员变量之外，其他的结构体成员是需要对齐到某个数字开始存储的。

在vs2022中的对齐数是8，在Linux，gcc中是没有默认对齐数的，对齐数是成员自身的大小。

对齐数 = 编译器默认的一个对齐数和该成员变量大小的较小值

例如在vs2022中 char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8);

讲解完了对齐数，回到上面那个问题。

第二个成员变量char 是要对齐到它的对齐数的整数倍处。而任何数都是1的整数倍，所以char就放在int的后面即可。

第三条规则：结构体的总大小为最大对齐数的整数倍。

最大对齐数是所有结构体成员变量的对齐数的最大值。

通过前两个规则我们知道， char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8)，所以最大对齐数是4;而且已经占据了5个字节，但是并不是4的整数倍，所以这个结构体的大小要自动补齐到八个字节。

所以这个结构体的大小是8个字节。

那么我们现在来计算struct s2 的字节

struct s2
{
	char a;
	int b;
	char c;
};

第一个结构体成员变量发在第一个字节，而第二个结构体成员int对齐到4的整数倍处也就是从偏移量4的字节开始占据4个字节，然后第三个结构体成员变量char对齐1的整数倍处，也就是偏移量8的字节，最大对齐数是4，根据第三条规则结构体的大小就应该是4的整数倍，也就是12了。

结构体嵌套问题

我们把结构体struct s2 改变一下，

struct s1
{
	int a;
	char b;
};
struct s2
{
	char a;
	int b;
	char c;
	struct s1 d;
};

那么此时的struct s2 的大小是多少？

规则4：嵌套的结构体要对齐到该结构体成员变量中最大对齐数的整数倍处。

结构体s1的最大对齐数是4，所以d应该对齐到4的整数倍处

这时候已经占据了20个字节，再根据规则三:整个结构体的最大对齐数4，而20刚好是4的倍数，所以不再变大了，这个结构体的大小就是20.

#include<stdio.h>
struct S3
{
	double d; 
	char c;
	int i;
};
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%zd\n", sizeof(struct S3));
	printf("%zd\n", sizeof(struct S4));
}

struct s3:

不难推断处结构体s3的大小是16；

结构体s3的最大对齐数是8，故对齐到偏移量为8的位置，大小16个字节。s4的最大对齐数就是8，也要对齐，刚好32就是8的倍数，所以这个结构体的大小就是32；

(2)为什么存在内存对齐？

平台原因：
不是所有的硬件平台都能够访问任意的地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的类型的数据，否则会抛出硬件异常。
性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要进行两次内存的访问；而对齐的内存访问只需要一次。假设一个处理器总是从内存中取八个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作做来读或者写值了。否则，计算机可能需要执行两次内存访问，因为对象可能会被分放在两个8字节的内存块中。

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

那么在我们设计结构体时候，我们既要满足对齐，又要尽可能的节省空间

struct S 
{
	char a;
	int b;
	char c;
};
struct S 
{
	char a;
	char c;
	int b;
};

我们发现第二个结构体的大小明显小于第一个。

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

(3)修改默认对齐数

#pragma这个预处理指令可以修改编译器的默认对齐数

#include<stdio.h>
#pragma pack(1)//将默认对齐数设置为1
struct S3
{
	double d; 
	char c;
	int i;
};
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%zd\n", sizeof(struct S3));
	printf("%zd\n", sizeof(struct S4));
}

再次运行代码我们就会发现结果已经不一样了。

#pragma pack()

再加上这个就可以取消对齐数，还原为默认值。

结构体在对齐方式不合适的时候，我们就可以自己更改默认对齐数。

(3)结构体传参

#include<stdio.h>
struct S
{
	int arr[1000];
	int n;
	double d;
};
void print1(struct S tmp)
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", tmp.arr[i]);
	}
	printf("%d ", tmp.n);
	printf("%lf\n", tmp.d);
}
void print2(const struct S* ps)
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("%d ", ps->n);
	printf("%lf ", ps->d);
}
int main()
{
	struct S s = { {1,2,3,4,5}, 100, 3.14 };
	print1(s);
	print2(&s);
	return 0;
}

观察print1和print2函数，这两个函数都是在打印这个结构体，那么这两个结构体有什么区别呢？或者他们两个哪一个更好？

答案是print2函数

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

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

所以为了避免这样的情况，结构体传参的时候，要传结构体的地址。

三.结构体实现位段

不是段位

(1)什么是位段

位段的声明和结构是类似的，有两个不同：

位段的成员必须是int 或者unsigned int或者signed int ,在C99中位段成员的类型也可以选择其他类型
位段的成员名后面后一个冒号和一个数字。

struct A
{
    int a:2;
    int b:5;
    int c:10;
    int d:30;
};

A就是一个位段类型

那么位段A所占内存的大小是多少？

答案是8.为什么呢？

变量名的后面跟着一个冒号数字代表这个数字只占多少个bit位。

比如int c:10,表示这个c变量占据了10个bit位。

而我们知道正常的一个int类型的变量是4个字节，占据32个bit位。

所以这样位段可以节省内存。

首先分配4个字节的空间存储a,还剩30个bit，然后在把b放进去，还剩25个bit，再把c放进去，只剩15个bit了不够容纳d了，所以再分配4个字节的空间，然后把d放进去。总共使用了8个字节，所以这个结构体的大小是8个字节。

(2)位段的内存分配

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main() {
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
}

在vs2022上，申请到的一块空间是从右向左使用的。但是不同的平台这是不确定的。

10的二进制是1010，但是a只有3位，所以存入010，

12的二进制是1100，b有4位，存入1100

3的二进制是0011，c有5位存入0011

4的二进制0100，存入0100

所以从低到高，十六进制0x62 0x03 0x04，总共占据三个字节

(3)位段的跨平台问题

int位段被当成有符号数还是无符号数是不确定。
位段中的最大位数是不能确定的。（16位机器最大是16，32位机器最大32，写成27，在16位机器就会出问题）
位段中的成员在内存中从左向右，还是从右向左分配这个是标准为定义的。
当一个结构体包含两个位段的时候，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总的来说：更结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

(4)位段使用的注意事项

位段的成员共有一个字节，这样有些成员的起始地址并不是某个字节的起始位置，那么这些位置处是没有地址的，内存中的每一个字节分配一个地址，一个字节内部的bit位是没有地址

所以不能使用取地址操作符&利用scanf直接给位段的成员输入值，只是先输入放在一个变量中然后赋值给位段的成员。

#include<stdio.h>
struct A
{
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
};
int main()
{
    struct A sa = { 0 };
    //scanf("%d", &(sa._b));//这是错误的

    //正确的示范
    int b = 0;
    scanf("%d", &b);
    sa._b = b;

    return 0;
}

星纭

关注

28
点赞
踩
28

收藏

觉得还不错? 一键收藏
4
评论
结构体讲解

位段的成员必须是int 或者unsigned int或者signed int ,在C99中位段成员的类型也可以选择其他类型位段的成员名后面后一个冒号和一个数字。int b:5;int c:10;int d:30;A就是一个位段类型那么位段A所占内存的大小是多少？答案是8.为什么呢？变量名的后面跟着一个冒号数字代表这个数字只占多少个bit位。比如int c:10,表示这个c变量占据了10个bit位。
复制链接

扫一扫