C语言-结构体+联合体+枚举

最新推荐文章于 2022-07-26 18:37:50 发布
最新推荐文章于 2022-07-26 18:37:50 发布
阅读量881 收藏 2
点赞数
分类专栏： C 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//1、结构体:是一种构造数据类型
//结构体的用途：把不同的数据类型整合起来，成为一个自定义的数据类型

//1.1 定义一个结构体(定义结构体的关键字：struct)
//联想到Java中的类
// struct User{
//     //年龄
//     int age;
//     //用户名
//     char name[10];
// };

// int main(){
//     //使用
//     //第一种使用方式-构造初始化
//     // 正确写法-初始化
//     // struct User u = {18,"Dream"};
//     // printf("%d, %s\n",u.age,u.name);
//     //错误写法
//     // struct User u;
//     // u = {18,"Dream"};
//     // printf("%d, %s\n",u.age,u.name);

//     //第二种使用方式-成员赋值
//     struct User u;
//     u.age = 20;
//     //错误写法
//     //u.name = "Dream";
//     //正确的写法
//     strcpy(u.name,"Dream");
//     printf("%d, %s\n",u.age,u.name);

//     printf("Hello!");
//     getchar();
//     return 0;
// }


//1.2 第二种定义
// struct User{
//     int age;
//     char name[10];
// } u = {18,"Dream"},u1;

// int main(){
//     printf("%d, %s\n",u.age,u.name);
//     u.age = 100;
//     strcpy(u.name,"Dream");
//     printf("修改后：%d, %s\n",u.age,u.name);

//     u1.age = 100;
//     strcpy(u1.name,"Fantasy");
//     printf("修改后：%d, %s\n",u1.age,u1.name);

//     getchar();
//     return 0;
// }


//1.3 第三种定义
// struct User{
//     int age;
//     char name[10];
// } u1,u2,u3;

// int main(){
//     u1.age = 100;
//     strcpy(u1.name,"Deram");
//     printf("%d, %s\n",u1.age,u1.name);

//     u2.age = 150;
//     strcpy(u2.name,"微尘");
//     printf("%d, %s\n",u2.age,u2.name);

//     getchar();
//     return 0;
// }

//1.4 第四种定义-结构体嵌套
//第一种写法-定义在外部
// struct Order{
//     int count;
//     char name[10];
// };
// struct User{
//     int age;
//     char name[10];
//     Order order;
// };

//第二种写法-定义在内部
// struct User{
//     int age;
//     char name[10];
//     struct Order{
//         int count;
//         char name[10];
//     } order;
// };

// int main(){
//     //构造方式赋值
//     // struct User u = {18,"Dream",{999,"女装"}};
//     // printf("User:%d, User:%s\n",u.age,u.name);
//     // printf("Order:%d , Order:%s\n",u.order.count,u.order.name);

//     struct User u;
//     u.age = 100;
//     strcpy(u.name,"Dream");
//     u.order.count = 1000;
//     strcpy(u.order.name,"男装");
//     printf("User:%d, User:%s\n",u.age,u.name);
//     printf("Order:%d , Order:%s\n",u.order.count,u.order.name);

//     getchar();
//     return 0;
// }


//1.5 第五种定义-匿名结构体：一般情况下，定义的同时至少有一个申明变量,否则没有什么意义
//好处：你可以控制结构体变量数量(限量版)，一定程度上避免了出现结构体重名情况
//匿名结构体第一种写法
// struct{
//     int age;
//     double height;
//     char name[10];
// } u1，u2;

// int main(){
//     u1.age = 100;
//     u1.height = 165.00;
//     strcpy(u1.name,"Dream");
//     printf("%d, %lf, %s\n",u1.age,u1.height,u1.name);
//     return 0;
// }

//这种方式只有一个变量(单例)
//错误写法
// struct{
//         int age;
//         double height;
//         char name[10];
// };

// int main(){
    
//     age = 100;
//     height = 165;
//     strcpy(name,"Dream");
//     printf("%d, %lf, %s\n",age,height,name);
//     return 0;
// }

//1.6 第六种定义-结构体和数组
// struct User{
//     int age;
//     char name[10];
// } u1[2],u2[2] = {{18,"Dream"},{20,"迷离"}};

// int main(){
//     //不能这么干
//     //错误写法
//     // u1[0] = {18,"Dream"};
//     // u1[1] = {100,"Dream"};
//     //正确写法
//     // u1[0].age = 100;
//     // strcpy(u1[0].name,"Dream");

//     int i = 0;
//     for(;i<2;i++){
//         printf("%d, %s\n",u2[i].age,u2[i].name);
//     }
//     getchar();
//     return 0;
// }

//结构体和指针
// struct User{
//     int age;
//     int height;
//     char name[20];
// };

// int main(){
//     // struct User u = {18,180,"石桥中画妖"};
//     // //定义个结构体指针
//     // struct User *p = &u;
//     // //如何取值？
//     // //printf("%d, %d, %s",(*p).age,(*p).height,(*p).name);
//     // //(*p).age 等价于 p->age(简写)
//     // //JDK 1.8里面也支持了这种写法
//     // printf("%d, %d, %s",p->age,p->height,p->name);


//     //数组
//     struct User u1[] = {{18,175,"石桥中画妖"},{20,165,"Dream"}};
//     //采用指针遍历数组
//     struct User *p = u1;
//     for(;p < u1 + 2 ; p++){
//         printf("%d, %d, %s",p->age,p->height,p->name);
//     }

//     getchar();
//     return 0;
// }


//结构体和内存（字节对齐）
//结构体在内存中也是一块区域(有顺序,线性排列)
// struct User{
//     int age;
//     double height;
//     char name[20];
//     // 4 + 8 + 12*2 = 36  36 % 8 = 0
//     // 4 + 8 + 20 * 2 = 52%8?  53?  54? 55?  56%8=0
// };

// int main(){
//     struct User u = {18,165};
//     //打印结构体大小
//     //int->4字节  double->8字节  
//     //按常理来说：12字节，但是结果却是：16字节
//     //结构体字节对齐规则:
//     //1.结构体变量的大小需要满足被最宽基本数据类型的成员大小所整出(int double float)
//     //12%8?不成立    16%8=0成立
//     //2.结构体变量的成员的首地址偏移量必须是最宽的基本数据类型的整数倍
//     printf("大小: %lu\n",sizeof(u));

//     //为什么C语言要这么设计？
//     //初衷：就是为了提高读取效率（提高读取性能）
//     //刘翔跨栏(110)：每隔10米一个栏，如果每一个栏之间的距离不统一，那么跨栏难度系数会加大
//     //遵循规律（节奏）
//     getchar();
//     return 0;
// }

//结构体和动态内存分配
// struct User{
//     int age;
//     double height;
//     char name[10];
// };

// int main(){
//     //数组(动态内存分配)-数组大小是3
//     struct User *p = (struct User *)malloc(sizeof(struct User) * 3);
    
//     //默认首地址
//     // p->age = 100;
//     // p->height = 160;
//     // strcpy(p->name,"Dream");
//     // printf("%d, %f, %s\n",p->age,p->height,p->name);

//     // p++;
//     // p->age = 20;
//     // p->height = 165;
//     // strcpy(p->name,"Dream");
//     // printf("%d, %f, %s\n",p->age,p->height,p->name);

//     //循环通过指针赋值
//     int i = 0;
//     for(;i<3;i++){
//         p->age = 20+i;
//         p->height = 165+i;
//         strcpy(p->name,"Dream");
//         printf("%d, %f, %s\n",p->age,p->height,p->name);
//         p++;
//     }

//     getchar();
//     return 0;
// }

//typedef 给结构体取别名(增强了可读性,简化了使用)
//第一种写法
// struct User{
//     int age;
//     double height;
//     char name[10];
// };

// typedef struct User DreamUser;

//第二种写法
// typedef struct User{
//     int age;
//     double height;
//     char name[10];
// } DreamUser,AgeUser;

// int main(){
//     //使用方式(和Java基本上相同使用方式)
//     DreamUser dream;
//     dream.age = 18;
//     dream.height = 165.00;
//     strcpy(dream.name,"Dream");
//     printf("%d, %f, %s\n",dream.age,dream.height,dream.name);
    
//     getchar();
//     return 0;
// }


//联合体（共同体:union关键字)
//作用：使多个不同类型的变量共用一块内存区域,联合体变量任何时候只有一个成员变量在内存中存在
//好处：节约内存
//总结：联合体分配内存大小
//联合体大小(在C语言中系统分配内存的机制)
//条件一：最大的成员字节大小
//条件二：还的是最大的成员的基本数据类型的字节数的整数倍

// union Student{
//     int id;
//     float height;
//     char sex;

//     char name[10];
// };

// int main(){
//     //错误写法（不能直接初始化）
//     //union Student stu = {10,"Dream"};
//     //正确写法
//     union Student stu;
//     // strcpy(stu.name,"Dream");
//     stu.id = 100;
//     stu.sex = 'D';
//     printf("%d\n , %c\n",stu.id,stu.sex);
//     printf("%lu\n",sizeof(stu));
//     //发现有什么问题？结果替换了

//     getchar(); 

//     return 0;
// }


//联合体-匿名联合体
//好处：你可以控制结构体变量数量(限量版)，一定程度上避免了出现结构体重名情况
//第一种定义方式-匿名结构体
// union{
//     int age;
//     char name[10];
// } u;

// int main(){
//     u.age = 100;
//     getchar();
//     return 0;
// }
//第二种方式
// static union{
//     int age;
//     char name[10];
// };

// int main(){

//     age = 100;
//     strcpy(name,"Dream");
//     printf("%d\n",age);
//     printf("%s\n",name);
//     getchar();
//     return 0;
// }

//方式三


// int main(){
//     //其他方式调用：课后作业?
//     union{
//         int age;
//         char name[10];
//     };
//     age = 100;
//     strcpy(name,"Dream");
//     printf("%d\n",age);
//     printf("%s\n",name);
//     getchar();
//     return 0;
// }

//联合体取别名
// typedef union User{
//     int age;
//     char name[10];
// } DreamUser;

// union User{
//     int age;
//     char name[10];
// };
// typedef union User DreamUser;

// int main(){
//     DreamUser dream;
//     dream.age = 100;
//     getchar();
//     return 0;
// }

//枚举(定义：enum)---int类型
//总结：基本上和Java差不多
//好处：限定了值，保证取值的安全性
// enum MessageType{
//     //文本类型
//     Text = 10,
//     //图片类型
//     Image = 20,
//     //文件类
//     File = 30,
//     //视频类型
//     Video = 40,
//     //语言
//     Voice = 50
// };


// int main(){
//     enum MessageType d = Text;
//     printf("Text: %d\n",d);
//     d = Image;
//     printf("Image: %d\n",d);
//     getchar();
//     return 0;
// }

//枚举取别名
// typedef enum MessageType{
//     //文本类型
//     Text = 10,
//     //图片类型
//     Image = 20,
//     //文件类
//     File = 30,
//     //视频类型
//     Video = 40,
//     //语言
//     Voice = 50
// } Message;

// int main(){
//     Message d = Text;
//     printf("Text: %d\n",d);
//     d = Image;
//     printf("Image: %d\n",d);
//     getchar();
//     return 0;
// }



//匿名枚举
enum{
    //文本类型
    Text = 10,
    //图片类型
    Image = 20,
    //文件类
    File = 30,
    //视频类型
    Video = 40,
    //语言
    Voice = 50
} Message;

int main(){
    Message = Text;
    printf("Text: %d\n",Message);
    Message = Image;
    printf("Image: %d\n",Message);
    getchar();
    return 0;
}


整理自代码


锐湃
关注
专栏目录
C语言_结构体、枚举、联合体
weixin_43853178的博客
07-21 1034
结构体、枚举、联合体这三者都具有类似的结构，都是将一些变量或者值整合放在一起，这样做可以增加代码的可读性，也能方便编程。这篇博客中将会整理结构体、枚举、联合体的相关概念，举例介绍他们的适用场景。...
C语言的结构体、联合和枚举
奔梦记
08-20 5039
结构体是C语言中一种非常重要的数据结构，与数组不同，它的成员（结构体称元素）可以具有不同的类型，并通过成员的名称获取指定元素。联合和结构体相似，但联合的所有成员都共享同一存储空间，每次只能存储一个成员。枚举是命名的一组整数值。
C语言 自定义类型知识点总结(结构体,联合体,枚举)
qq_44770449的博客
04-22 311
1.结构体 结构体是一些值的集合,这些值称为成员变量.每个成员变量的类型可以相同,可以不同. 1.1结构体类型的声明 struct 结构体名称 { 成员类型 成员变量1; 成员类型 成员变量2; … }(定义当前结构体变量); 例: struct student { char name[1024];//名字 int age;//年龄 char sex[1024];//性别 char id[...
C语言—结构体/联合体/枚举
qq_40738945的博客
12-22 726
结构体 我们不能定义结构体，我们所做的是设计结构体。 接下来的代码时结构体的基本操作 struct student { char id[10]; char name[10]; char sex[6]; int age; }; student fun() { student s = { &quot;20180101&quot;, &quot;yhping&quot;, &quot;man&quot;, 28 }; retur
C语言结构体，联合体，枚举
qq_41681424的博客
04-30 225
结构体，联合体，枚举 文章目录结构体，联合体，枚举相应的关键字结构体typedef关键字结构体的声明定义的使用方法：结构体的初始化方法:结构体变量成员(字段)的访问函数和结构体，函数的形参联合体枚举C语言函数指针及多级指针 相应的关键字 关键字 说明 struct 结构体 union 联合体 enum 枚举 结构体 A.能够包含大量的变量并且对变量的数据类型无要求 B.结构体也是一种数据类型，它是自行定义的一种数据类型类比成一个int类型结构体分配空间是连续的,一个成员挨
【C语言-进阶】自定义类型详解(结构体+枚举+联合)
TPON的博客
03-28 479
自定义类型详解(结构体+枚举+联合)
【C语言】自定义类型详解（结构体+枚举+联合）
East-sunrise的博客
07-26 808
自定义类型详解（结构体+枚举+联合）
C语言结构体、枚举、联合体
qq_64105689的博客
03-26 757
#1.结构体 在现实世界里，常常有一些复杂对象不好用简单的变量或数组去表示，这时候C语言的自定义类型：结构体，就可以帮我们很好的定义这些复杂对象。 1.1 结构体是什么： 结构体是一些值的集合，这些值被称为成员变量，成员变量可以是不同的类型。 1.2结构体的声明： 这个时候我们就声明了一个有两个char类型和一个int类型的结构体类型struct str 1.3结构体的不完全声明： 与上面的声明不同的是少了结构体标签，所以这个结构体类型只有一个变量s3，不可在函...
c语言结构体加联合,C语言：结构体和联合体(共用体)
weixin_42396918的博客
05-19 819
结构体：struct1、结构体变量的首地址能够被其最宽基本类型成员的大小所整除。2、结构体每个成员相对于结构体首地址的偏移量(offset)都是成员的整数倍。3、结构体的总大小为结构体最宽基本类型成员大小的整数倍。cpu的字长：32位的cpu或64位的cpu32位或64位指的是cpu的字长字长实际上指得是cpu在访问内存时，一次可以读取的长度。内存对齐(可以设置,一般是2的倍数,虽然浪费了空间,但...
"C语言13-结构体、联合体、链表详解.ppt
本章主要内容的ppt文档主要介绍了C语言中的结构体、联合体、链表和枚举等内容。结构体用于保存复杂数据内容，联合体共享相同的内存空间，链表是一种数据结构，枚举是C语言的一种基本数据类型。其中，结构体的定义...
结构struct 联合Union和枚举Enum的细节讨论
weixin_30295091的博客
09-29 176
联合（Union）是一种构造数据类型，它提供了一种使不同类型数据类型成员之间共享存储空间的方法，同时可以实现不同类型数据成员之间的自动类型转换。联合体对象在同一时间只能存储一个成员的值。联合的内存大小取决于其中字节数最多的成员，而不是累加，联合也会进行字长对齐。在定义联合变量的时候可以指定初始值，但是只能制定一个初始值（测试过似乎无法设置初值），而且该初始值的类型必须与联合的第一个成员的类型匹配。...
结构体、联合体、枚举
HGJYTJ的博客
02-05 439
结构体1.声明一个结构体类型的一般形式为：struct    结构体名   ｛成员表列｝；如：struct [student]     （[ ]表示可选项）        {              int num;              char name[20];              char sex;              int age;              floa...
结构体 枚举 联合体
Eriksen的博客
10-28 196
一.结构体 1.概念 与数组不同 它的成员类型 可以是不同类型 2.声明一个结构体类型 struct是结构体关键字 Stu是结构体标签 3.创建变量 只有s1 s2 是局部的结构体变量 其余的都是全局变量 4.错误示范 编译器会把这两种匿名结构体 当作单独的两种结构体 因此不可以用psa去存放sa的地址 5. 结构体的自引用是不可以直接进行引用的 会类似为一种死递归下去 一个n又调用一个n 无限循环下去 无法计算 ...
详解C语言结构体、枚举、联合体
Ja_king_的博客
09-27 3080
结构体、枚举、联合体1.什么是结构体、枚举、联合体2.定义结构体2.1 包含结构体成员变量、variable2.2 tag、结构体成员变量2.3 用结构体声名变量2.4 用typedef 创建新类型2.5 两个结构体相互包含2.6 结构体变量初始化2.7 结构体指针3.枚举3.1 定义方式3.2 为什么用枚举3.3 枚举变量的定义3.4 实例3.5 枚举实际用途4.联合体4.1 与结构体区别4.2 定义 1.什么是结构体、枚举、联合体 结构体(struct)是由一系列具有相同类型或不同类型的数据项构成的
c语言结构体联合体与枚举考点,C语言入门第十七篇，结构体、联合体和枚举
weixin_35599815的博客
05-24 169
结构体是C语言很重要的概念，他是数据结构的关键。基本性质个人理解结构体是一种变量的集合体，他把变量放入了一个结构里面，形成了一个结构体。我们先看看他的基本语法。struct 结构体名{结构体}我们看上面的基本语法可以看出，我们需要给出结构体名和内部的结构体就能声明一个结构体变量。上面的语法还不能表现真正结构体的属性，我们来看看一个例子，我们需要定义一个学生的结构体，里面存放学号，姓名，性别。str...
结构体，联合体，枚举详解
lyzzs222的博客
10-05 1907
结构体，联合体，枚举详解 目录 结构体 联合体 枚举常量 1.结构体 在C语言中，系统已经提供了一些数据类型，比如float，int，double，char等，但是我们有时会需要更复杂的类型来描述一个数据。假如我想描述一个学生，我需要知道他的学号，姓名，性别，那么我就需要三个类型来分别保存他的信息，到时候需要信息时还得分别查找，显然这是不方便的。因此有了结构体，我们可以根据自己所需来定义数据类型。 简言之，结构体是由不同的类型数据组成的组合型数据结构。 结构体类型的声明以及定义 struct 结构
结构体，枚举，联合
番茄炒蛋不吃西红柿的博客
10-08 889
文章目录结构体结构体内存对齐结构体传参联合体 结构体 先介绍C语言内置类型 复杂对象怎么描述？ 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。 struct tag { member-list; }variable-list； struct - 结构体关键字 tag - 结构体标签 member-list - 结构体成员 variable-list - 结构体变量 结构体的类型是 struct tag 特殊的声明 在声明结构的时候，可以不完全的声明 //匿
C语言：结构体、联合体与枚举详解
第九章和第十章涵盖了C语言中的结构体、联合体、枚举和位运算等概念。结构体是一种复合数据类型，它允许将多个不同类型的数据成员组织在一起，形成一个自定义的对象。结构体的定义包括结构体名、成员及其类型，成员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值