0
点赞
收藏
分享

微信扫一扫

C语言进阶4:自定义类型:结构体+枚举+结合

Xin_So 2024-11-18 阅读 8
初始化#define#includeC/C++后端开发

本章重点

  1. 结构体：

    • 结构体类型的声明
    • 结构的自引用
    • 结构体变量的定义和初始化
    • 结构体内存对齐
    • 结构体传参
    • 结构体实现位段（位段的填充&可移植性）

  2. 枚举

    • 枚举类型的定义
    • 枚举的优点
    • 枚举的使用

  3. 联合

    • 联合类型的定义
    • 联合的特点
    • 联合大小的计算

1.结构体

1.1 结构体的声明

1.1.1 结构体的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
对比 数组: 一些值的集合,类型相同。

1.1.2 结构的声明

//结构体的声明
struct tag
{
	member_list;
}variable_list;

结构体关键字：struct
结构体的标签：tag
结构体的类型：struct tag
结构的成员列表：member_list
结构体变量列表：variable_list>

例:描述一个学生：

struct Stu
{
 char name[20];//名字
 int age;//年龄
 char sex[5];//性别
 char id[20];//学号
}st1,st2;//分号不能丢
//这里定义的st1，st2类型是全局变量，可选项
struct Stu st3;//全局变量
int main()
{
	struct Stu s1;//局部的临时变量
	struct Stu s2;
	return 0;
}

1.1.3 特殊的声明

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

struct
{
    char book_name[20];
    char author[20];
    int price;
    char id[15];
}sb1, sb2;//匿名结构体类型,只能在这里创建类型，不能在main（）函数里面创建

语法上可以省略名字，单注意只能在后面创建类型，不能在main（）函数里面创建

匿名结构体类型

struct
{
    char book_name[20];
    char author[20];
    int age;
}sb1;
 
struct
{
    char book_name[20];
    char author[20];
    int age;
}*ps;
 
int main()
{
    ps = &sb1;
 
    return 0;
}
//在匿名结构题类型下，虽然成员一模一样，但编译器认为是不一样的,用的时候会出错

1.1.4 结构的自引用

拓展

链表 :
数据结构--->数据在内存中存储的结构

自引用

把图中节点定义为结构体

//struct Node
//{
//    int data;
//    struct Node* next;
//};
//这是极其危险的,你不知道next Node的大小
struct Node
{
    int data;
    struct Node* next;
};
 
int main()
{
    struct Node n;//struct必须写
    
    return 0;
}

如果想省略主函数int main（）中的struct 可以对struct 进行typedef重命名，如下：

typedef struct Node
{
    int data;
    struct Node* next;
}Node;
//typedef struct Node
//{
//    int data;
//    Node* next; 不行,因为最后才命名的
//}Node;
 
int main()
{
    Node n1;//struct 可以省
    Node n2;
  	n1.next=&n2;
    return 0;
}

1.1.5 结构体变量定义与初始化

有了结构体类型，那如何定义变量？

struct Point
{
    int x;
    int y;
}p0,p1={3，6}; //声明类型的同时定义变量p1
 
struct Point p2; //定义结构体变量p2
 
//初始化：定义变量的同时赋初值。
struct Point p3 = { 1, 2 };
 
struct Stu        //类型声明
{
    char name[15];//名字
    int age;      //年龄
};
 
struct Stu s = { "zhangsan", 20 };//初始化
 
struct Node
{
    int data;
    struct Point p;
    struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化
struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化
 
int main()
{
    printf("%s %d", s.name, s.age);
    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;
}

1.1.6 结构体内存对齐

struct S1
{
    char c1;
    int i;
    char c2;
};
 
struct S2
{
    char c1;
    char c2;
    int i;
};
 
int main()
{
    printf("%d\n", sizeof(struct S1));       //12
    printf("%d\n", sizeof(struct S2));       //8
    return 0;
}

结构体内存对齐规则：

1.第一个成员在与结构体变量偏移量为O的地址处。
2.其他成员变量要对齐到某个数字(对齐数）的整数倍的地址处。

我们用 offsetof（）函数 可以对其结构体内存进行查看：

#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));
 
}
//得到结果为：0 4 8  和 0 1 4

来做一个练习：

struct S3
{
    double d;
    char c;
    int i;
};

答案: 16
再来看一练习（嵌套式的）：

struct S3
{
    double d;
    char c;
    int i;
};
struct S4
{
     char c1;
     struct S3 s3;
     int d;
};

答案: 32

为什么存在内存对齐 ?
大部分的参考资料都是如是说的 :

  1. 平台原因(移植原因)∶不是所有的硬件平台都能访问任意地址上的任意数据的; 某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
  2. 性能原因∶数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问; 而对齐的内存访问仅需要一次访问。
    总体来说︰ 结构体的内存对齐是拿空间来换取时间的做法。
    那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到?
    让占用空间小的成员尽量集中在—起。

1.1.6 修改默认对齐数

之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

#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;
}
//得到12  6

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

1.1.8 结构体传参

直接上代码：

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)
{
    //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);
 
    return 0;
}

一般会选择printf2

因为：

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

1.1.9 练习:通讯录

通讯录:

  1. 人的信息: 姓名+年龄+性别+地址+电话
  2. 可以存100人信息
  3. 功能
    • 增加联系人
    • 删除联系人
    • 查找指定联系人信息
    • 修改指定联系人信息
    • 显示所有人信息
    • 排序(名字,年龄)(未实现)

test.c - 测试通讯录
contact.c - 通讯录实现
contact.h - 函数声明

contact.h - 函数声明
#pragma once
#include<stdio.h>
#include<string.h>
#include<assert.h>
#define MAX 100
#define NAME_MAX 20
#define SEX_MAX 5
#define ADDR_MAX 30
#define TELE_MAX 30
typedef struct PeoInfo
{
	char name[NAME_MAX];
	int age;
	char sex[SEX_MAX];
	char addr[ADDR_MAX];
	char tele[TELE_MAX];
}PeoInfo;

typedef struct Contact
{
	PeoInfo data[MAX];//存放人的信息
	int sz;//当前已经存放信息个数
}Contact;

//初始化通讯录
void InitContact(Contact* pc);

//增加联系人
void ADDContact(Contact* pc);

//删除指定联系人
void DelContact(Contact* pc);

//显示通讯录中的信息
void ShowContact(const Contact* pc);

//查找指定联系人
void SearchContact(const Contact* pc);

//修改指定联系人
void ModifyContact(const Contact* pc);
contact.c - 通讯录实现
#define _CRT_SECURE_NO_WARNINGS 1
#include"contact.h"
void InitContact(Contact* pc)
{
	assert(pc);
	pc->sz = 0;
	memset(pc->data, 0, sizeof(pc->data));
}

int FindByName(const Contact* pc, char name[])
{
	assert(pc);
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		if (strcmp(pc->data[i].name, name) == 0)
		{
			return i;
		}
	}
	return -1;
}

void ADDContact(Contact* pc)
{
	assert(pc);
	if (pc->sz == MAX)
	{
		printf("通讯录已满,无法添加\n");
	}
	//增加一个人信息
	printf("请输入名字:>");
	scanf("%s", pc->data[pc->sz].name);
	printf("请输入年龄:>");
	scanf("%d", &(pc->data[pc->sz].age));
	printf("请输入性别:>");
	scanf("%s", pc->data[pc->sz].sex);
	printf("请输入地址:>"); 
	scanf("%s", pc->data[pc->sz].addr);
	printf("请输入电话:>");
	scanf("%s", pc->data[pc->sz].tele);
	pc->sz++;
	printf("添加成功!\n");
}

void ShowContact(const Contact* pc)
{
	assert(pc);
	int i = 0;
	printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n","名字","年龄","性别","地址","电话");
	printf("|--------------------|----------|-------|-----------------------|------------|\n");
	for (i = 0; i < pc->sz; i++)
	{
		printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[i].name, pc->data[i].age, pc->data[i].sex, pc->data[i].addr, pc->data[i].tele);
	}
}

void DelContact(Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	if (pc->sz == 0)
	{
		printf("通讯录为空,无法删除\n");
		return;
	}
	//删除
	//找到要删除的人
	printf("请输入要删除的人:>");
	scanf("%s",name);
	int ret=FindByName(pc, name);
	if (-1 == ret)
	{
		printf("删除信息不存在\n");
		return;
	}
	int i = 0;
	//删除
	for (i = ret; i < pc->sz - 1; i++)
	{
		pc->data[i] = pc->data[i + i];
	}
	printf("删除成功!\n");
}

void SearchContact(const Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	printf("请输入查找人姓名:>");
	scanf("%s", name);
	int pos = FindByName(pc, name);
	if (-1 == pos)
	{
		printf("查找信息不存在\n");
		return;
	}
	printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n", "名字", "年龄", "性别", "地址", "电话");
	printf("|--------------------|----------|-------|-----------------------|------------|\n");
	printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[pos].name, pc->data[pos].age, pc->data[pos].sex, pc->data[pos].addr, pc->data[pos].tele);
}

void ModifyContact(const Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	printf("请输入修改人姓名:>");
	scanf("%s", name);
	int pos = FindByName(pc, name);
	if (-1 == pos)
	{
		printf("查找信息不存在\n");
		return;
	}
	printf("请输入名字:>");
	scanf("%s", pc->data[pos].name);
	printf("请输入年龄:>");
	scanf("%d", &(pc->data[pos].age));
	printf("请输入性别:>");
	scanf("%s", pc->data[pos].sex);
	printf("请输入地址:>");
	scanf("%s", pc->data[pos].addr);
	printf("请输入电话:>");
	scanf("%s", pc->data[pos].tele);
	printf("修改成功!\n");
}
test.c - 测试通讯录
#define _CRT_SECURE_NO_WARNINGS 1

#include"contact.h"

void menu()
{
	printf("***********************************\n");
	printf("*****   1. add      2. del    *****\n");
	printf("*****   3. search   4. modify *****\n");
	printf("*****   5. show     6. sort   *****\n");
	printf("*****   0. exit               *****\n");
	printf("***********************************\n");
}
int main()
{
	int input;
	//创建通讯录
	Contact con;
	//初始化通讯录
	InitContact(&con);
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			ADDContact(&con);
			break;
		case 2:
			DelContact(&con);
			break;
		case 3:
			SearchContact(&con);
			break;
		case 4:
			ModifyContact(&con);
			break;
		case 5:
			ShowContact(&con);
			break;
		case 6:
			break;
		case 0:
			printf("退出通讯录\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

1.2 位段

1.2.1 什么是位段

位段的位代表的是计算机中的二进制位

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

  1. 位段的成员必须是 int、unsigned int 或signed int 。
  2. 位段的成员名后边有一个冒号和一个数字。

比如:

struct A
{
    int _a:2;
    int _b:5;
    int _c:10;
    int _d:30;
};
int main()
{
	printf("%d\n", sizeof(struct A));//占八个字节
	return 0;
}

1.2.2 位段的内存分配

  1. 位段的成员可以是int unsigned intsigned int或者是char(属于整形家族）类型
  2. 位段的空间上是按照需要以4个字节([int)或者1个字节(char)的方式来开辟的。
  3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段
#include<stdio.h>
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;
	return 0;
}

1.2.3 位段的跨平台问题

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

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

1.2.4 位段的应用

网络传输上面的封装过程

2.枚举

枚举顾名思义就是一一列举。 把可能的取值一一列举。

比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举

2.1枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
}；
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。
{ }中的内容是枚举类型的可能取值，也叫 枚举常量 。

这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。 比如：

enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};
int main()
{
	printf("%d\n", RED);
	printf("%d\n", GREEN);
	printf("%d\n", BLUE);
 
	printf("%d\n", sizeof(enum Color));
 
	return 0;
}

打印结果为：0，1，2，4

赋值：
enum Color//颜色
{
    RED = 1,
    GREEN = 2,
    BLUE = 4
};

2.2 枚举的优点

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

枚举的优点：

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

2.3 枚举的使用

enum Color//颜色
{
    RED=1,
    GREEN=2,
    BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

3.联合(共用体)

3.1 联合类型的定义

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

//联合类型的声明
union Un
{
    char c;
    int i;
    double d;
};
int main()
{
    //联合变量的定义
    union Un un;
    //计算连个变量的大小
    printf("%d\n", sizeof(un));//8
    printf("%d\n", sizeof(union Un));//8
 
    printf("%p\n", &(un.c));      
    printf("%p\n", &(un.i));
    printf("%p\n", &(un.d));
    //打印的地址一样
    return 0;
}

3.2 联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小， 至少是最大成员的大小（因为联 合至少得有能力保存最大的那个成员）。

判断当前计算机的大小端存储：

地址法：

int check_sys()
{
	int num = 1;
	if (*(char*)&num == 1)
		return 1;
	else
		return 0;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	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 (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

3.3 联合大小的计算

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

比如：

union Un1
{
	char c[5];
	int i;
};
union Un2
{
	short c[6];
	int i;
};
int main()
{
	//下面输出的结果是什么？
	printf("%d\n", sizeof(union Un1));
	printf("%d\n", sizeof(union Un2));
 
	return 0;
}

会打印：8，12

举报

相关推荐

【C语言进阶】四.自定义类型：结构体，枚举，联合

#include#pragma成员变量C/C++编程语言

C进阶-自定义类型：结构体、枚举、联合

javascript前端react.js

自定义类型【结构体+枚举+联合】详解【C语言的进阶结构体】

c语言

C语言自定义类型：结构体，枚举，联合

c语言

C语言——自定义类型（结构体+枚举+联合）

#include位段嵌套C/C++编程语言yyds干货盘点

C语言---自定义类型：结构体，枚举，联合

数据结构java开发语言图论算法

c语言—自定义类型（结构体，枚举，联合）进阶篇—笔记

位段结构体枚举联合C/C++编程语言

详解C语言自定义类型(结构体，枚举，联合)

c语言windows开发语言

C语言自定义类型——【结构体，枚举，联合】（二）

c语言c++c#

【C语言】——自定义类型详解：结构体，枚举，联合

服务器vue.jsjavascript
0 条评论