C语言-结构体和共用体

谁借莪１个温暖的怀抱￠ 2022-01-21 07:01 468阅读 0赞

## 概述： ##

> **数组**：描述一组具有相同类型数据的有序集合，用于处理大量相同类型的数据运算。
> 
> 有事我们需要将不同类型的数据组合成一个有机的整体，如：一个学生有学号、姓名、性别、年龄、地址等属性。显然单独定义以上变量比较繁琐，数据不便于管理，C语言中给出了另一种**构造**数据类型--**结构体**

**定义结构体格式**

struct Student
    {
        //成员列表
        char name[10];
        char id[11];
        int age;
        char tel[16];
        char sex;
    };//stu1,stu2,stu3;可定义多个结构体变量，若后面加{}则必须要赋值

**定义结构体变量**

>  *  **struct 结构体名称 结构体变量名**
>  *  **结构体变量名.结构体成员列表 = 值**
> 
> **注：如果是字符串类型，则需要strcpy来赋值**

#include <stdio.h>
    #include <string.h>
    struct Student
    {
        char name[10];
        char id[11];
        int age;
        char tel[16];
        char sex;
    } //4.stu={"张三","2016114444",20,"12345678910",'M'};
    int main()
    {
        //1.按照结构体顺序赋值
        //struct Student stu = {"张三","2016114444",20,"12345678910",'M'};
        //2.
        //struct Student stu ={.sex='M',.name="李四",.id="2016115433",.age=20,.tel="123542343242"};
        //3.
        //struct Student stu;
        //若直接用stu.name = "张三";则表示让name数组指向字符串，所以应使用字符串赋值，将字符串复制给数组
        //strcpy(stu.name,"张三");
        //strcpy(stu.id,"2016117834");
        //stu.age = 22;
        //stu.sex = 'F';
        //strcpy(stu.tel,"23134123213");
        printf("姓名:\t%s\n",stu.name);
        printf("学号:\t%s\n",stu.id);
        printf("年龄:\t%d\n",stu.age);
        printf("电话:\t%s\n",stu.tel);
        printf("性别:\t%s\n",stu.sex=='M'?"男":"女");
    }

![20190608213734327.png][]

**结构体内存存储**

**注：结构体需要根据数据类型进行内存对齐**

#include <stdio.h>
    struct student
    {
        char name[20];  //20*1
        unsigned int age;//4*1
        char tel[15]; //15*1
        float scores[3];//4*3=12
        char sex;   //1*1    sum = 52   
    
    }stu;
    int main()
    {
        printf("结构体内存大小:\t%d\n",sizeof(stu));
        return 0;
    }

![20190608215524328.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70][]

**若改变顺序为**

struct student
    {
        char name[20];  //20*1
        unsigned int age;//4*1
        char tel[15]; //15*1
        char sex;   //1*1    
        float scores[3];//4*3=12  sum = 52
    }stu;

![20190608221439748.png][]

#include <stdio.h>
    struct student
    {
        char *p;      //4
        char arr[2];  //1*2
        int c;        //4
        short d;      //2
        double e;     //8
        long g;       //4
        float h[2];   //4*2  sum = 32 实际为40
    }stu;
    int main()
    {
        printf("结构体内存大小:\t%d\n",sizeof(stu));
        return 0;
    }

![20190609123840421.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 1][]

**若调整变量声明的位置**

struct student
    {
        char *p;
        char arr[2];
        short d;
        int c;
        long g;
        double e;
        float h[2];
    }stu;

![20190609125255548.png][]

**结构体数组**

#include <stdio.h>
    struct Student
    {
        char name[10];
        char id[11];
        int age;
        char tel[16];
        char sex;
    };
    int main()
    {
        struct Student s[2];
        for(int i=0;i<2;i++){
            printf("请输入学生%d的信息:\n",i+1);
            scanf("%s %s %d %s %c",s[i].name,s[i].id,&s[i].age,s[i].tel,&s[i].sex);  
        }
        for(int i=0;i<2;i++){
        printf("姓名:\t%s\n",s[i].name);
        printf("学号:\t%s\n",s[i].id);
        printf("年龄:\t%d\n",s[i].age);
        printf("电话:\t%s\n",s[i].tel);
        printf("性别:\t%s\n\n",s[i].sex=='M'?"男":"女");
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 2][]

**结构体排序**

#include <stdio.h>
    struct stu
    {
        char name[10];
        float score[3];
    };
    int main()
    {
        int n;
        printf("请输入学生的人数:\n");
        scanf("%d",&n);
        struct stu s[n];
        for(int i=0;i<n;i++){
            printf("请输入学生%d的姓名和成绩:\n",i+1);
            scanf("%s %f %f %f",s[i].name,&s[i].score[0],&s[i].score[1],&s[i].score[2]);
    
        }
        for(int i=0;i<n-1;i++){
            for(int j=0;j<n-i-1;j++){
                int sum1 = s[j].score[0]+s[j].score[1]+s[j].score[2];
                int sum2 = s[j+1].score[0]+s[j+1].score[1]+s[j+1].score[2];
                if(sum1<sum2){
                    //结构体变量互换
                   struct stu s3;
                   s3 = s[j];
                   s[j] = s[j+1];
                   s[j+1] = s3;
                    }
                }
            }
        for(int i=0;i<n;i++){
            printf("姓名:\t%s\n",s[i].name);
            printf("成绩:\t%.2f\t%.2f\t%.2f\n",s[i].score[0],s[i].score[1],s[i].score[2]);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 3][]

**结构体和指针**

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    struct student
    {
        char* name;
        int age;
    }stu;
    int main()
    {
        //1.给成员指针分配内存空间
        //stu.name = (char*)malloc(sizeof(char)*10);
        //2.创建结构体指针指向结构体变量的地址
        struct student* s1 = &stu;
        s1->name = (char*)malloc(sizeof(char)*10);
        strcpy(s1->name,"张三");
        s1->age = 20;
        printf("%s\t%d\n",s1->name,s1->age);
    }

![20190609214736473.png][]

![20190609213731292.png][]

**堆空间开辟结构体**

#include <stdio.h>
    struct student
    {
        char* name;
        int age;
    };
    int main()
    {
        //开辟一个结构体类型的空间
        struct student* p = (struct student*)malloc(sizeof(struct student));
        //给name申请内存空间
        p->name = (char*)malloc(sizeof(char)*10);
        //结构体指针需要用->来进行操作，不能使用.
        scanf("%s %d",p->name,&p->age);
        printf("%s\t%d",p->name,p->age);
        free(p->name);
        free(p);
    }

![20190610195809887.png][]

**结构体和函数**

#include <stdio.h>
    #include <string.h>
    struct student
    {
        char name[10];
        int age;
    };
    void fun01(struct student s)//相当于把stu的副本传给s，s的改变不影响stu--值传递
    {
        //不能用s.name = "张三";因为张三是字符串常量，存储于数据区，这样做相当于把字符串的地址赋值给s.name
        strcpy(s.name,"张三");
        s.age = 20;
        printf("fun01执行:\t%s\t%d\n",s.name,s.age);
    }
    void fun02(struct student *p)
    {
        //结构体指针变量需要用->来对变量进行操作
        //*p = &stu,p指向stu所在的内存空间--地址传递
        strcpy(p->name,"王二");
        p->age = 18;
        printf("fun02执行:\t%s\t%d\n",p->name,p->age);
    }
    struct student fun03()   //在栈区创建，函数执行完成后销毁内存空间，但值依然传递
    {
        struct student s;
        strcpy(s.name,"麻子");
        s.age = 24;
        return s;  //返回一个结构体变量(struct studnet类型)
    }
    struct student* fun04()  //在栈区创建，函数执行完成后销毁内存空间
    {
        struct student s;
        strcpy(s.name,"赵六");
        s.age = 26;
        return &s;  //返回结构体变量s的地址
    }
    int main()
    {
        struct student stu;
        strcpy(stu.name,"里斯");
        stu.age = 22;
        fun01(stu);
        printf("主函数执行:\t%s\t%d\n",stu.name,stu.age);
        fun02(&stu);
        printf("主函数执行:\t%s\t%d\n",stu.name,stu.age);
        struct student s = fun03();
        printf("fun03-主函数执行:\t%s\t%d\n",s.name,s.age);
        struct student* s1 = fun04(); //s1指向一个不存在的空间
        printf("fun04-主函数执行:\t%s\t%d\n",s1->name,s1->age);
    }

![20190611091912712.png][]

**结构体嵌套**

#include <stdio.h>
    struct skill
    {
        char* skill01;
        char* skill02;
        char* skill03;
        char* skill04;
    }sk;
    struct hero
    {
        char* name;
        int level;
        float atk;
        float hp;
        struct skill sk;
    };
    int main()
    {
        struct hero* p = (struct hero*)malloc(sizeof(struct hero)*3);
        for(int i=0;i<3;i++){
            //给成员申请内存空间
            p[i].name = (char*)malloc(sizeof(char)*10);
            p[i].sk.skill01 = (char*)malloc(sizeof(char)*20);
            p[i].sk.skill02 = (char*)malloc(sizeof(char)*20);
            p[i].sk.skill03 = (char*)malloc(sizeof(char)*20);
            p[i].sk.skill04 = (char*)malloc(sizeof(char)*20);
            //
            printf("请输入Hero%d的信息:\n",i+1);
            scanf("%s %d %f %f %s %s %s %s",p[i].name,&p[i].level,&p[i].atk,&p[i].hp,p[i].sk.skill01,p[i].sk.skill02,p[i].sk.skill03,p[i].sk.skill04);
        }
        for(int i=0;i<3;i++){
            printf("姓名:\t%s\n等级:\t%d\n攻击力:\t%.2f\n生命值:\t%.2f\n技能一:\t%s\n技能二:\t%s\n技能三:\t%s\n技能四:\t%s\n\n",p[i].name,p[i].level,p[i].atk,p[i].hp,p[i].sk.skill01,p[i].sk.skill02,p[i].sk.skill03,p[i].sk.skill04);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 4][]

## 共用体 ##

*  联合union是一个能在同一个存储空间存储不同类型数据的类型
 *  联合体所占的内存长度等于其最长成员的长度，也有叫做共用体
 *  同一内存段可以用来存放几种不同类型的成员，但每一瞬时只有一种起作用
 *  共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有成员的值会被覆盖
 *  共用体变量的地址和它的各成员的地址都是同一地址

#include <stdio.h>
    union test
    {
       int a;
       float b;
       double c;   //该共用体占用的内存空间为成员中最长的长度，即double 8
    };
    int main()
    {
        union test p;
        p.a = 10;
        printf("%d\n\n",p.a);
        p.b = 5;
        printf("%d\n",p.a);
        printf("%.2f\n\n",p.b); //共用体共用一个存储空间，所以当给a赋值后再对b赋值，b会覆盖a
        p.c = 20;
        printf("%d\n",p.a);
        printf("%.2f\n",p.b);
        printf("%.2f\n",p.c);
    
    }

![20190611130305578.png][]

## 枚举 ##

> **枚举**：将变量的值一一列举出来，变量的值只限于列举出来的值得范围内
> 
> **枚举类型定义**:enum  枚举名
> 
>                          \{
> 
>                                     枚举值表
> 
>                           \};
> 
>  *  在枚举值表中应列出所有可用值，也称为枚举元素
>  *  枚举值是常量，不能在程序中用赋值语句再对它赋值
>  *  枚举元素本身有系统定义了一个表示序号的数值从0开始顺序定义为0,1

## **typedef** ##

> typedef为C语言的**关键字**，作用是为一种数据类型（基本类型或自定义数据类型）定义一个新名字，**不能创建新类型**
> 
>  *  与\#define不同，typedef仅限于数据类型，而不是能是表达式或具体的值
>  *  \#define发生在预处理，typedef发生在编译阶段

[20190608213734327.png]: /images/20220121/1034767cb8db4f43b94df2610f7a5079.png
[20190608215524328.png]: /images/20220121/ebe20eadcb8a4be1aebdf052e67b234c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70]: /images/20220121/3ce2afc2ed2f4349812fea5fae00fc15.png
[20190608221439748.png]: /images/20220121/3bca53e8da644072a5dd605741000a23.png
[20190609123840421.png]: /images/20220121/be172a0b1a794370b51ee45565c79451.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 1]: /images/20220121/948ac1864e3442e49f644de1246dad90.png
[20190609125255548.png]: /images/20220121/7c30d422af3c4a45ae5e9542966180c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 2]: /images/20220121/ae70ab0f55114cd6b2db442cc4594da4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 3]: /images/20220121/0ac8c151f7544ff6a0f7cb74fdb9fa0e.png
[20190609214736473.png]: /images/20220121/6b4cfae097cd453b9df91bc5603d73ee.png
[20190609213731292.png]: /images/20220121/e7168df0999f4a579087e22d55ac95ab.png
[20190610195809887.png]: /images/20220121/c8fc36c2674a457889ecf647ef31157f.png
[20190611091912712.png]: /images/20220121/4df09e7652fa4308b0a4636eb58a5ee8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 4]: /images/20220121/1fcf0ec9c4ed466abd5b953bb8062b36.png
[20190611130305578.png]: /images/20220121/8877feae1f7249e9810319571e5861db.png