首页 > 其他分享> > 入门学习计算机第十八天——自定义数据类型（结构体）

入门学习计算机第十八天——自定义数据类型（结构体）

2021-05-15 19:29:17 作者：互联网

入门学习计算机第十八天——自定义数据类型（结构体）

编译器：Microsoft Visual Studio 2019

自定义类型：

结构体
枚举
联合体

结构体

结构体类型的声明

结构的基础知识
结构是一些值的集合，这些值称为成员变量

结构的声明

struct tag
{
  member-list;//成员列表
}variable-list;//变量列表

例如：

//声明一个结构体类型
//声明一个学生类型，是想通过学生类型来创建学生变量（变量）
//描述学生： 属性+名字+电话+性别+年龄
struct Stu
{
	char name[20];
	char tele[12];
	char sex[10];
	int age;
}s4,s5,s6;//全局变量，与s3同理
struct Stu s3;//全局变量
int main()
{
	struct Stu s1;
	struct Stu s2;//创建结构体变量
	return 0;
}

特殊的声明:
匿名结构体类型

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

struct 
{
	int a;
	int c;
}sa;
struct
{
	int a;
	int c;
}*psa;
int main()
{
	psa = &sa;
	return 0;
}

编译器此时会报警告：
在这里插入图片描述
编译器会把上述两个声明当成完全不同的两个类型，所以是非法的

结构体的自引用

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

struct Node
{
  int data;
  struct Node next;
};

是否可行？
编译器此时也会报错。无法确认结构体类型的大小

正确的自引用方式

struct Node
{
  int data;
  struct Node* next;//指针，大小为4或者8个字节0
};

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

struct S//结构体变量的定义
{
	char c;
	int a;
	double b;
	char arr[20];
};

int main()
{
	struct S s = { 'c',100,3.0,"hello bit" };//结构体变量的初始化
	printf("%c %d %lf %s\n", s.c, s.a, s.b, s.arr);//结构体成员的访问

输出的结果：
在这里插入图片描述

结构体内存对齐

已经掌握了结构体的基本使用了
现在深入讨论一个问题：计算结构体的大小
这也是一个特别热门的考点：结构体内存对齐

以下输出的结果是？

struct S1
{
	char c1;
	int a;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int a;
};
int main()
{
	struct S1 s1 = { 0 };
	printf("%d\n", sizeof(s1));//
	struct S2 s2 = { 0 };
	printf("%d\n", sizeof(s2));
	return 0;
}

在这里插入图片描述
为什么是12和8？
如何计算？首先要掌握结构体的对齐规则

第一个成员在与结构体变量为0的地址处
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
（对齐数 = 编译器默认的一个对齐数与该成员大小的较小值
vs的中默认值为8）
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

在struct s1中

struct S1
{
	char c1;
	int a;
	char c2;
};

第一个成员变量要对齐到结构体变量为0的地址处，也就是最一开始的地址，类型是char，所以只占1个字节
第二个成员变量要对齐到对齐数的整数倍的地址处，第二个变量是int ，该成员的大小是4，小于vs的默认值，所以对齐数就是4，所以要在上一个成员的地址处空出到地址为4的地址，此时是1倍的关系。
第三个成员变量同理，变量类型是char，对齐数是1，倍数为1，所以在第二个成员变量的下一个地址处。
此时3个成员的大小为9，
但又因为结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，最大的对齐数是4，只有当是12的时候，大小才是最大对齐数的整数倍。
在这里插入图片描述
同理s2

struct S2
{
	char c1;
	char c2;
	int a;
};

第一个成员变量要对齐到结构体变量为0的地址处，也就是最一开始的地址，类型是char，所以只占1个字节.
第二个成员变量要对齐到对齐数的整数倍的地址处，第二个变量是char，该成员的大小是1，小于vs的默认值，所以对齐数就是1，所以要在上一个成员的地址处空出到地址为1的地址，此时是1倍的关系。
第三个成员变量要对齐到对齐数的整数倍的地址处，第三个变量是int，该成员的大小是4，小于vs的默认值，所以对齐数就是4，所以要在上一个成员的地址处空出到地址为4的地址，此时是1倍的关系。
此时，占用的大小是8，已经是最大对齐数的整数倍，所以8就是结构体变量S2的大小。
在这里插入图片描述

struct S3
{
	double d;
	char c;
	int a;
};
struct S4
{
	char c1;
	struct S3;
	double d;
};
int main()
{
	struct S3 s3 = { 0 };
	printf("%d\n", sizeof(s3));
	struct S4 s4 = { 0 };
	printf("%d\n", sizeof(s4));
	return 0;
}

输出的结果是 16\32
主要讲s4的大小，因为其中有嵌套
首先是第一个成员在与结构体变量为0的地址处，因为是char类型，占一个字节。
第二个成员嵌套了结构体，其中嵌套的struct s3最大对齐数是其中的double对应的8，所以第二个成员在8的地址对齐，第二个成员的大小又是16。
第三个成员是double类型，前两个成员的地址加起来是8+16，是8的倍数，所以直接在后面加入8个字节。
8+16+8=32
为什么存在内存对齐？
1，平台原因（移植原因）
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
2.性能原因
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
在这里插入图片描述
在32位机器下，一次可以访问4个字节的内容，如果没有内存对齐，c与a是紧挨着存储的，在一次访问时，访问了c以及a的一部分内存，读取一次就可以得到c。再读取a时，先从读取过的部分再向后读取4个字节，但只有a的后半部分，需要再读取一次，获取a的前半部分。所以再读取a的时候需要两次。
如果有内存对齐，再牺牲了一定的内存之后，a与c都只需要一次访问即可。

那么在设计结构体的时候，既要满足对齐，又要节省空间：

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

修改默认对齐数
#pragma 这个预处理指令，可以用来改变默认对齐数

#pragma pack(4)
//设置默认对齐数为4
struct S
{
	char c1;
	double d;
};
#pragma ()
//取消设置的默认对齐数
int main()
{
	return 0;
}

offsetof宏需要引头文件<stddef.h>
求结构体成员偏移量

struct S
{
	char c1;
	int a;
	double d;
};

int main()
{
   printf("%d\n",offsetof(struct S,c1));
   printf("%d\n",offsetof(struct S,a));
   printf("%d\n",offsetof(struct S,d));
	return 0;
}

输出的结果是 0，4，8

结构体传参

struct S
{
	char c1;
	int a;
	double d;
};
void Inits(struct S tmp)
{
	tmp.c1 = 'w';
	tmp.a = 100;
	tmp.d = 3.14;
}
void Inits1(struct S* ps)
{
	ps->c1 = 'w';
	ps->a = 100;
	ps->d = 3.14;
}
void print(struct S tmp)
{
	printf("%c %d %lf\n", tmp.c1, tmp.a, tmp.d);
}
void print1(const struct S* ps)
{
	printf("%c %d %lf\n",ps->c1,ps->a,ps->d);
}
int main()
{
	struct S s = { 0 };
	Inits(s);
	Inits1(&s);
	print(s);
	print1(&s);
	return 0;
}

函数Inits 传的是s的值，函数中tmp改变只是tmp本身的值，没有对s进行改变，
函数Inits1 传的是s的地址，函数中ps指向s的值，对s直接进行改变。
函数print函数传的是s的值，函数中tmp是s的临时拷贝，对其可以打印出s的值，但是拷贝占用新的空间
函数print1函数传的是s的地址，函数中ps指向s对其进行打印，没有占用额外的空间。但是可能会把s的值进行修改，所以需要const修饰

结构体实现位段（结构体的填充&可移植性）

什么是位段？

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

位段的成员必须是int , unsigned int 或 signed int
位段的成员名后边有一个冒号和一个数字

//位段：二进制位
struct A
{
	int _a : 2;//只需要2个bit
	int _b : 5;//只需要5个bit
	int _c : 10;//只需要10个bit
	int _d : 30;//只需要30个bit
};
//47bit 一共是6个字节，但是答案是8个字节？
//
int main()
{
	struct A a;
	printf("%d\n", sizeof(a));//8
	return 0;
}

位段的内存分配

位段的成员可以是int , unsigned int , signed int 或者是char（属于整形家族）类型
位段的空间是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段

结构体变量首先开辟一个整形大小的空间（32个bit），首先分配给a 2个bit,b 5个bit,c 10个bit，一共先分配了17个bit，剩下的15个bit无法存放d，所以剩下的空间浪费掉了。再开辟新的整形大小空间用来存放d，分配给d 30个bit，剩下2个bit也浪费掉了。所以一共是开辟了两个整形大小的空间，一共8个字节
在这里插入图片描述

位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的
位段中最大位的数目不能确定
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

在这里插入图片描述

枚举

枚举类型的定义

enum Day//enum 枚举关键字
{
   Mon,
   Tues,
   ...
};

枚举的优点

可以使用#define 定义常量，为什么非要使用枚举？

增加代码的可读性和可维护性
和#define定义的标识符比较枚举有类型检查，更加严谨
防止了命名污染（封装）
便于调试
使用方便，一次可以定义多个常量

枚举的使用

enum color//颜色
{
	RED = 1,
    GRERN = 2,
	BLUE = 4,

};
int main()
{
	enum color clr = GRERN;
	return 0;
}

联合

联合类型的定义

联合也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（所以联合也叫共用体）

union Un
{
	char c;
	int i;
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	printf("%p\n", &(u.c));
	printf("%p\n", &(u.i));
	printf("%p\n", &u);
	return 0;
}

在这里插入图片描述

联合的特点

联合的成员是共用同一块内存空间的，这样的一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）
用联合的特点求出该机器的字节序存储模式

int check_sys()
{
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	int ret = check_sys();
	if (1 == ret)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
}

输出的结果是小端

联合大小的计算

联合的的大小至少是最大成员的大小
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

union Un
{
	int a;//对齐数是4
	char arr[5];//对齐数是1，而不是5
};
int main()
{
	union Un u = { 0 };
	printf("%d\n", sizeof(u));
	return 0;
}

输出的结果是8

标签：第十八天,struct,自定义,int,成员,数据类型,char,位段,对齐
来源： https://blog.csdn.net/xiaotangyu7dong/article/details/116797709