死磕C语言结构体

太过爱你忘了你带给我的痛 2023-06-19 14:26 8阅读 0赞

学习之前要先看电影，治愈不想学习的心

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

因为总这样做，所以我现在还在搬砖

**目录**

1 枚举

1.1 常量符号化

1.2 枚举系乜水

1.3 Show 出我们灵活的手指

2 结构

2.1 结构体是啥么东东

2.2 结构体变量

2.2.1 先声明结构体类型再定义结构体变量

2.2.2 定义结构体类型的同时定义结构体变量

2.2.3 直接定义结构体类型变量

2.3 结构体数组

2.4 结构体指针

2.4.1 结构体变量指针

2.4.2 结构体数组指针

2.5 函数之间结构体变量的数据传递

2.5.1 结构体变量在函数间的传递

2.5.2 结构体数组在函数间的传递

2.6 结构体的应用-链表

2.6.1 开场白

2.6.2 我敲，我敲，我敲敲敲

3 共用体（联合）

3.1 共用体类型的声明

3.2 没有例子瞎说什么大实话

4 用户定义类型

--------------------

# 1 枚举 #

## 1.1 常量符号化 ##

⽤符号⽽不是具体的数字来表⽰程序中的数字

const int RED = 0;
    const int YELLOW = 1;
    const int GREEN= 2;

用枚举替换

enum color{RED,YELLOW,GREEN}

## 1.2 枚举系乜水 ##

枚举是⼀种⽤户定义的数据类型，它⽤关键字 enum 以如下语法来声明：

> enum 枚举类型名字 \{名字0, …, 名字n\} ;

• 枚举类型名字通常并不真的使⽤，要⽤的是在⼤括号⾥的名字， 因为它们就是就是常量符号，它们的类型是int，值则依次从0 到n。如：

> enum color\{RED,YELLOW,GREEN\}; 创建了三个常量，RED 的值是0，YELLOW 是1，⽽ GREEN 是2。

也可以在声明时指定值

enum color{RED=2,YELLOW,GREEN=5}

## 1.3 Show 出我们灵活的手指  ##

#include<stdio.h> 
    
    enum color{RED,YELLOW,GREEN=4};
    
    int main(){
    	printf("RED is %d\n",RED);
    	printf("YELLOW is %d\n",YELLOW);
    	printf("GREEN is %d\n",GREEN);
    	return 0;
    }

**结果：**

![20191207103226856.png][]

# 2 结构 #

## 2.1 结构体是啥么东东 ##

数组是具有相同数据类型的数据序列，而结构体是不同数据类型的数据序列。一个结构体变量占用的的内存空间是所有成员占用内存空间的总和。

struct 结构体名
    {
          数据类型 成员名1;
          数据类型 成员名2;
          ......
    };
    
    struct date{
        int month;
        int day;
        int year;
    }

## 2.2 结构体变量 ##

### 2.2.1 先声明结构体类型再定义结构体变量 ###

struct 结构体名 结构体变量名表;
    
    struct Student st1,st2;

### 2.2.2 定义结构体类型的同时定义结构体变量 ###

struct 结构体名{
          结构体成员表;
    }结构体变量名表;
    
    struct Student
    {
           int num;
           char name[12];
           char sex;
           int age;
    } st1,st2;

### 2.2.3 直接定义结构体类型变量 ###

struct 
    {
          结构体成员表;
    } 结构体变量名表;
    
    struct 
    {
           int num;
           char name[12];
           char sex;
           int age;
    } st1, st2;

## 2.3 结构体数组 ##

结构体数组的每一个元素都是结构体变量。

struct 结构体名 结构体数组名[元素个数];
    struct Student st[10]; // st 是一个含 10 个元素的结构体数组

## 2.4 结构体指针 ##

结构体指针用来指向一个结构体变量，还可以指向结构体数组中的元素。

### 2.4.1 结构体变量指针 ###

**(1) 定义**

结构体变量指针是一个指向结构体变量的指针

struct 结构体类型名 *结构体指针名;
    
    struct Student st,*p = &st; // p 是指向结构体变量 st 首地址的指针

p 不是结构体变量，不能写成 p.age，要写成(\*p).age，或 p -> age

**(2) 动手**

#include<stdio.h> 
    
    struct Student{
    	int num;
    	char name[20];
    }st={101,"apple"},*p;
    
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",st.num,st.name);
    	printf("num=%d,name=%s\n",(*p).num,(*p).name);
    	printf("num=%d,name=%s\n",p->num,p->name);
    }

**结果**

![20191207134745690.png][]

### 2.4.2 结构体数组指针 ###

**(1) 定义**

结构体数组指针用来指向结构体数组，即将该数组的起始地址赋值给该指针变量。

struct Student s[40],*p=s;

**(2) 第一回合-敲代码**

#include<stdio.h> 
    
    struct Student{
    	int num;
    	char name[20];
    }st[2]={
       {101,"apple"},{102,"peach"}}, *p;
    
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",p->num,p->name);
    	printf("num=%d,name=%s\n",(p++)->num,p->name); // 先取得p->num的值，再进行p自增1，指向下一个元素st[1] 
    	printf("num=%d,name=%s\n",p->num,p->name);
    }

**结果**

![20191207135610924.png][]

**(3) 第二回合- 敲代码**

#include<stdio.h> 
    
    struct Student{
    	int num;
    	char name[20];
    }st[2]={
       {101,"apple"},{102,"peach"}}, *p;
    
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",p->nump->name);
    	printf("num=%d,name=%s\n",(++p)->num,p->name); // 先进行p自增1，指向下一个元素st[1] ，再取成员 num 的值 
    }

**结果**

![20191207135948934.png][]

## 2.5 函数之间结构体变量的数据传递 ##

### 2.5.1 结构体变量在函数间的传递 ###

#include<stdio.h> 
    
    struct Student{
    	int num;
    	char name[20];
    };
    /**
    * 传值方式，形参为结构体变量 
    */
    void f1(struct Student c){
            //c.name="apple"; 报错
    	struct Student s = {101,"apple"};
    	c = s;
    }
    /**
    * 传地址方式，形参为结构体指针变量 
    */
    void f2(struct Student *c){
    	struct Student s = {102,"peach"};
    	*c = s; 
    } 
    
    int main(){
    	struct Student a={103,"pair"},b={104,"lemon"};
    	f1(a); // 只把值传过去了 
    	f2(&b); // 把地址传过去了 
    	printf("a.num=103,now=%d,b.num=104 but now=%d\n",a.num,b.num);
    }

**结果：**

![20191207163352315.png][]

### 2.5.2 结构体数组在函数间的传递 ###

把做个结构体组织成结构体数组，作为一个参数向函数传递，即把结构体数组的存储首地址作为实参

#include<stdio.h> 
    
    struct Student{
    	int num;
    	char name[20];
    };
    
    void func(struct Student *p){
    	printf("%d\n",(*p).num);
    	printf("%d\n",(*++p).num);
    }
    
    void main(){
    	struct Student stu[2]={
       {101,"apple"},{102,"peach"}};
    	func(stu);// 数组名代表数组的首元素 
    }

**结果：**

![20191207165748803.png][]

## 2.6 结构体的应用-链表 ##

### 2.6.1 开场白 ###

链表的具体定义参考：[数据结构线性表之吐血攻略][Link 1]

为了实现链表操作，需要动态地分配和释放内存空间。

动态分配内存空间：malloc()

动态释放内存空间：free()

由于 malloc 函数返回的指针为无值型指针，调用函数时，必须将其转成所需的类型。

float *p;
    p = (float *)malloc(sizeof(float));

以学生链表为例，学生链表的结构如下：

struct Student  
    {
        int num;
        int score;
        struct Student *next;
    }

### 2.6.2 我敲，我敲，我敲敲敲 ###

#include<stdio.h> 
    #include<malloc.h> 
    #include<stdlib.h>
    
    struct Student
    {
    	int num;
    	int score;
    	struct Student *next;
    	
    };
    
    /**
    * 建立一个带头结点的单链表 
    */
    struct Student *create()
    {
    	struct Student *head,*tail,*p;
    	int num,score;
    	head = (struct Student *)malloc(sizeof(struct Student));
    	tail = head; /*tail 始终指向新建链表的尾结点*/
    	while(1){
    		printf("学号 分数："); 
    		scanf("%d %d",&num,&score);
    		
    		if(num == 0 && score == 0)  /*输入 0,0 时退出循环*/
    			break;
    		else
    		{
    			p = (struct Student *)malloc(sizeof(struct Student)); /*新建结点*/
    			p->num = num;
    			p->score = score;
    			tail->next = p;
    			tail = p; 
    		} 
    	} 
    	tail->next = NULL;  /*将尾结点的 next 域置为 NULL*/
    	return head;        /*返回头结点指针*/ 	
    }
    
    /**
    * 显示链表 
    */
    void display(struct Student *head)
    {
    	struct Student *p = head->next; /* p指向链表的第一个数据结点 */
    	printf("输出链表：\n");
    	if(p == NULL) printf("空表\n");
    	else
    	{
    		while( p != NULL )
    		{
    			printf("(%d,%d)\n",p->num,p->score);
    			p = p->next;
    		}	
    	} 	
    } 
    
    /**
    * 释放链表 
    */
    void freeList(struct Student *head) 
    {
    	struct Student *p = head, *q = head->next;
    	while(q != NULL) 
    	{
    		free(p);
    		p=q;
    		q=q->next;
    	}
    	free(q);  /*释放最后一个结点*/
    } 
    
    int main()
    {
    	struct Student *head = create();
    	display(head);
    	freeList(head); 
    	return 0;
    }

**结果：**

![20191207185420632.png][]

# 3 共用体（联合） #

联合 union 是一种数据类型，它能在一个内存空间中存储不同的数据类型（不是同时存储）。

## 3.1 共用体类型的声明 ##

union 共用体类型名
    {
        数据类型 成员名1;
        数据类型 成员名1;
        ......
    
    }
    
    union Common
    {
        int a;
        double b;
        char c;
    };
    union Common common;
    
    common.a=23;  // 把 23 存储在 common,占 2 字节
    common.b=2.0 // 清除 23，存储 2.0，占 8 字节
    common.c='h' // 清除 2.0，存储 h，占 1 字节

sizeof(union) = 占字节数最多的那个成员的字节数

一个共用体不能同时存放其所有成员

## 3.2 没有例子瞎说什么大实话 ##

#include<stdio.h>
    
    union Common
    {
    	long l;
    	int i;
    	double b;
    }common;
    
    int main()
    {
    	printf("%d\n",sizeof(common));
    }

**结果：8**

# 4 用户定义类型 #

c 语言允许用 typedef 声明一种新的类型标识符

typedef 类型名1,类型名2;
    
    typedef int Integer; // Integer 成为 int 类型的别名
    
    typedef struct node {
        int data;	 	 	
        struct node *next;
    } aNode;	
    或
    typedef struct node aNode; // 这样⽤ aNode 就可以代替 struct node

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191206222222584.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[20191207103226856.png]: https://img-blog.csdnimg.cn/20191207103226856.png
[20191207134745690.png]: https://img-blog.csdnimg.cn/20191207134745690.png
[20191207135610924.png]: https://img-blog.csdnimg.cn/20191207135610924.png
[20191207135948934.png]: https://img-blog.csdnimg.cn/20191207135948934.png
[20191207163352315.png]: https://img-blog.csdnimg.cn/20191207163352315.png
[20191207165748803.png]: https://img-blog.csdnimg.cn/20191207165748803.png
[Link 1]: https://blog.csdn.net/wydyd110/article/details/83106138
[20191207185420632.png]: https://img-blog.csdnimg.cn/20191207185420632.png