C语言结构体+公用体+枚举训练

最新推荐文章于 2024-11-06 15:03:53 发布
最新推荐文章于 2024-11-06 15:03:53 发布
阅读量184 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/WangGuiHandsome/p/9899005.html
版权

结构体大小和内存结构

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 //结构体需要根据数据类型进行内存对齐
 7 //struct stus
 8 //{
 9 //    char name[20];//20
10 //    unsigned int age;//4
11 //    char tel[15];//15
12 //    char sex;//1  52
13 //    float scores[3];//12
14 //}stu;
15 
16 struct stus
17 {
18     //char * p;   //4
19     //char arr[2];//2  8
20     //short d; //2   16
21     //int c;  //4 
22     //long g;//4    
23     //double f;//8  24
24     //float h[2];//8   40
25 
26 
27     double f;//8  24
28     float h[2];//8   40
29     long g;//4    
30     int c;  //4 
31     char * p;   //4
32     short d; //2   16
33     char arr[2];//2  8
34 
35 
36     /*
37     姓名：  char name[200];
38     等级： int 
39     当前经验：int 
40     攻击： int 
41     防御：int 
42     技能冷却：foat 
43 
44     */
45 
46 
47 }stu;
48 
49 
50 int main()
51 {
52     
53     printf("结构体大小%d\n", sizeof(stu));
54 
55     system("pause");
56     return EXIT_SUCCESS;
57 }

结构体学生成绩排序

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct stu1
 7 {
 8     //成员列表
 9     char name[21];
10     float scores[3];
11 };
12 int main()
13 {
14     struct stu1 s[3];
15     for (int i = 0; i < 3; i++)
16     {
17         printf("请您输入学生 姓名   成绩 ：\n");
18         scanf("%s%f%f%f", s[i].name, &s[i].scores[0], &s[i].scores[1], &s[i].scores[2]);
19     }
20     //冒泡排序
21     for (int i = 0; i < 3 - 1; i++)
22     {
23         for (int j = 0; j < 3 - i - 1; j++)
24         {
25 
26             int sum1 = s[j].scores[0] + s[j].scores[1] + s[j].scores[2];
27             int sum2 = s[j + 1].scores[0] + s[j + 1].scores[1] + s[j + 1].scores[2];
28             if (sum1 > sum2)
29             {
30                 //结构体交换   交换所有成员列表中的数据
31                 //交换姓名
32                 char temp[21] = { 0 };
33                 strcpy(temp, s[j].name);
34                 strcpy(s[j].name, s[j + 1].name);
35                 strcpy(s[j + 1].name, temp);
36 
37                 //交换成绩
38 
39                 for (int k = 0; k < 3; k++)
40                 {
41                     float temp = s[j].scores[k];
42                     s[j].scores[k] = s[j + 1].scores[k];
43                     s[j + 1].scores[k] = temp;
44                 }
45 
46             }
47         }
48     }
49 
50 
51 
52 
53     for (int i = 0; i < 3; i++)
54     {
55         printf("姓名：%s\n", s[i].name);
56         printf("成绩: %.1f   %.1f   %.1f\n", s[i].scores[0], s[i].scores[1], s[i].scores[2]);
57     }
58 
59 
60     system("pause");
61     return EXIT_SUCCESS;
62 }

学生成绩优化

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct stu1
 7 {
 8     //成员列表
 9     char name[21];
10     float scores[3];
11 };
12 int main()
13 {
14     struct stu1 s[3];
15     for (int i = 0; i < 3; i++)
16     {
17         printf("请您输入学生 姓名   成绩 ：\n");
18         scanf("%s%f%f%f", s[i].name, &s[i].scores[0], &s[i].scores[1], &s[i].scores[2]);
19     }
20     //冒泡排序
21     for (int i = 0; i < 3 - 1; i++)
22     {
23         for (int j = 0; j < 3 - i - 1; j++)
24         {
25 
26             int sum1 = s[j].scores[0] + s[j].scores[1] + s[j].scores[2];
27             int sum2 = s[j + 1].scores[0] + s[j + 1].scores[1] + s[j + 1].scores[2];
28             if (sum1 > sum2)
29             {
30                 //结构体交换   交换所有成员列表中的数据
31                 ////交换姓名
32                 //char temp[21] = { 0 };
33                 //strcpy(temp, s[j].name);
34                 //strcpy(s[j].name, s[j + 1].name);
35                 //strcpy(s[j + 1].name, temp);
36 
37                 ////交换成绩
38 
39                 //for (int k = 0; k < 3; k++)
40                 //{
41                 //    float temp=s[j].scores[k];
42                 //    s[j].scores[k] = s[j + 1].scores[k];
43                 //    s[j + 1].scores[k] = temp;
44                 //}
45 
46                 //结构体变量交换
47                 struct stu1 temp = s[j];
48                 s[j] = s[j + 1];
49                 s[j + 1] = temp;
50 
51             }
52         }
53     }
54 
55 
56 
57 
58     for (int i = 0; i < 3; i++)
59     {
60         printf("姓名：%s\n", s[i].name);
61         printf("成绩: %.1f   %.1f   %.1f\n", s[i].scores[0], s[i].scores[1], s[i].scores[2]);
62     }
63 
64 
65     system("pause");
66     return EXIT_SUCCESS;
67 }

结构体成员为指针

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct stuinfo
 7 {
 8     char *name;
 9     int age;
10 };
11 
12 int main()
13 {
14     struct  stuinfo si;
15     si.name = (char *)malloc(sizeof(char) * 21);
16 
17     strcpy(si.name, "张三");
18     si.age = 18;
19 
20     printf("%s   %d\n", si.name, si.age);
21 
22     free(si.name);
23 
24 
25     system("pause");
26     return EXIT_SUCCESS;
27 }

结构体指针

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct sinfo
 7 {
 8     char *name;
 9     int age;
10 }stu;
11 int main()
12 {
13     struct sinfo * s = &stu;
14     s->name = (char *)malloc(sizeof(char) * 21);
15     strcpy(s->name, "李芮");
16     s->age = 50;
17     printf("%s   %d\n", s->name, s->age);
18 
19     free(s->name);
20 
21 
22 
23     system("pause");
24     return EXIT_SUCCESS;
25 }

 

 

 

堆空间开辟结构体

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct tec
 7 {
 8     char *name;//4
 9     int age;//4
10 }t;
11 
12 int main()
13 {
14     struct tec * p = (struct tec *)malloc(sizeof(t));
15     p->name = (char *)malloc(sizeof(char) * 21);
16 
17     strcpy(p->name, "牛玲");
18     p->age = 18;
19 
20     printf("%s   %d\n", p->name, p->age);
21 
22     if (p->name != NULL)
23     {
24         free(p->name);
25         p->name = NULL;
26     }
27 
28     if (p)
29     {
30         free(p);
31         p = NULL;
32     }
33 
34 
35     printf("%d\n", sizeof(struct tec *));//无论为什么类型的指针，都是4个
36 
37     system("pause");
38     return EXIT_SUCCESS;
39 }

 

 

 学生成绩

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 struct stu2
 6 {
 7     //成员列表
 8     //char name[21];
 9     char * name;
10     float * scores;
11 };
12 
13 int main()
14 {
15     struct stu2 *p = (struct stu2 *)malloc(sizeof(struct stu2) * 3);
16     for (int i = 0; i < 3; i++)
17     {
18         p[i].name = (char *)malloc(sizeof(char) * 21);
19         p[i].scores = (float *)malloc(sizeof(float) * 3);
20 
21         printf("请您输入学生 姓名   成绩 ：\n");
22         scanf("%s%f%f%f", p[i].name, &p[i].scores[0], &p[i].scores[1], &p[i].scores[2]);
23 
24     }
25 
26     //冒泡排序
27     for (int i = 0; i < 3 - 1; i++)
28     {
29         for (int j = 0; j < 3 - i - 1; j++)
30         {
31             float sum1 = p[j].scores[0] + p[j].scores[1] + p[j].scores[2];
32             float sum2 = p[j + 1].scores[0] + p[j + 1].scores[1] + p[j + 1].scores[2];
33             if (sum1 > sum2)
34             {
35                 struct stu2 temp = p[j];
36                 p[j] = p[j + 1];
37                 p[j + 1] = temp;
38             }
39         }
40     }
41 
42 
43     for (int i = 0; i < 3; i++)
44     {
45 
46         printf("姓名：%s\n", p[i].name);
47         printf("成绩: %.1f   %.1f   %.1f\n", p[i].scores[0], p[i].scores[1], p[i].scores[2]);
48     }
49 
50 
51     //释放
52     for (int i = 0; i < 3; i++)
53     {
54         free(p[i].name);
55         free(p[i].scores);
56     }
57 
58     free(p);
59 
60 
61 
62     system("pause");
63     return EXIT_SUCCESS;
64 }

结构体和函数

 

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct info
 7 {
 8     char name[21];
 9     int age;
10 };
11 
12 void fun01(struct info s)
13 {
14     strcpy(s.name, "李四");
15     s.age = 20;
16 
17     printf("%s   %d\n", s.name, s.age);
18 
19 }
20 void fun02(struct info *s)
21 {
22     strcpy(s->name, "李四");
23     s->age = 20;
24 
25 }
26 
27 
28 
29 int main1()
30 {
31     struct info s = { "张三",18 };
32 
33     //fun01(s);
34     fun02(&s);
35 
36     printf("%s   %d\n", s.name, s.age);
37 
38     system("pause");
39     return EXIT_SUCCESS;
40 }
41 struct info  fun03()
42 {
43     struct info s;
44     strcpy(s.name, "李四");
45     s.age = 20;
46 
47     return s;
48 
49 }
50 struct info * fun04()
51 {
52     struct info s;
53     strcpy(s.name, "李四");
54     s.age = 20;
55 
56     return &s;
57 }
58 
59 //int fun04()
60 //{
61 //    int a = 10;
62 //    return a;
63 //}
64 int main()
65 {
66     struct info s = fun03();
67     printf("%s   %d\n", s.name, s.age);
68 
69 
70     //int a = fun04();
71 
72 
73     //struct info * s = fun04();
74     //printf("%s   %d\n", s->name, s->age);
75     system("pause");
76     return 0;
77 
78 }

 结构体嵌套结构体

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct stra
 7 {
 8     int a;  //4   4
 9     float b;//4   8
10     char c;//1   12  9
11     char arr[7];   //16
12     double h;//24
13 }abc;
14 
15 struct  strb
16 {
17     struct stra abc;//12  16
18     short f;  //2
19     char * e;  //4
20     short g;
21     //double d; //8
22 };
23 
24 
25 /*
26     技能cd：
27     skill01 10
28     skill02 3
29     skill03 7
30 
31 */
32 /*
33 
34     名称
35     等级
36     攻击
37     技能：
38 
39 
40 */
41 int main()
42 {
43     struct strb  strbb;
44     //strbb.d = 10.0f;
45     //strbb.abc.a = 100;
46 
47 
48     //printf("%d\n", strbb.abc.a);
49 
50     printf("%d\n", sizeof(strbb));
51 
52 
53     system("pause");
54     return EXIT_SUCCESS;
55 }

共用体

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 //共用体   union 共用体名称  成员列表  共用体变量名
 7 union vars
 8 {
 9     double a;
10     float b;
11     int c;
12     short d;
13     char f;
14     char arr[17];//17
15 }var;
16 int main()
17 {
18     printf("%d\n", sizeof(var));
19     var.a = 100;
20     var.b = 3.14;
21     var.c = 66;
22     printf("%f\n", var.a);
23     printf("%f\n", var.b);
24     printf("%d\n", var.c);
25 
26     system("pause");
27     return EXIT_SUCCESS;
28 }

 

枚举

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 enum colors
 7 {
 8     red = 10, bule, yellow = 20, black, white, green
 9 }clo;
10 /*
11 插卡
12 输入密码
13 锁定
14 取款
15 查询
16 退卡
17 锁定解除
18 
19 */
20 /*
21 10
22 移动
23 攻击
24 技能
25 死亡
26 20
27 亮牌子
28 跳舞
29 
30 
31 */
32 int main()
33 {
34     clo = 0;
35 
36     int val;
37     scanf("%d", &val);
38     switch (val)
39     {
40     case red:
41         break;
42     case bule:
43         break;
44     case yellow:
45         break;
46     case black:
47         break;
48     case white:
49         break;
50     case green:
51         break;
52     default:
53         break;
54     }
55     //switch (val)
56     //{
57     //case red:
58     //    printf("请输入您的密码");
59     //    clo = 1;
60     //    printf("红色\n");
61     //    break;
62     //case bule:
63     //    printf("");
64     //    clo = 2;
65     //    clo = 3;
66     //    clo = 4;
67 
68     //    printf("蓝色\n");
69 
70     //    break;
71     //case yellow:
72     //    printf("黄色\n");
73 
74     //    break;
75     //case black:
76     //    break;
77     //case white:
78     //    break;
79     //case green:
80     //    break;
81     //default:
82     //    break;
83     //}
84 
85     system("pause");
86     return EXIT_SUCCESS;
87 }

 

 

转载于:https://www.cnblogs.com/WangGuiHandsome/p/9899005.html

dili5112
关注
【 C语言初级项目：通讯录（结构体+枚举+指针）】
m0_52882232的博客
03-31 1万+
函数指针、结构体、枚举的实际应用
【C语言基础一百题11】87-92题结构体公共体和枚举类型
ぁ風雲變色ぁ
02-06 1854
【程序87】 题目：编写input()和output()函数输入，输出5个学生的数据记录。 1.程序分析： 2.程序源代码： #include #define N 5 struct student { char num[6]; char name[8]; int score[4]; } stu[N]; input(stu) struct student stu[]; { int i,j; for(i=0;i/n"); for(i=
（C语言）自定义类型——结构体+枚举+联合
博主qq1077644249
07-17 830
1 结构体的声明 1.1 结构的基础知识 1.2 结构的声明 1.3 特殊的声明 1.4 结构的自引用 1.5 结构体变量的定义和初始化 1.6 结构体内存对齐 1.7 修改默认对齐数 百度笔试题： 1.8 结构体传参 2. 位段 2.1 什么是位段 2.2 位段的内存分配 2.3 位段的跨平台问题 3.枚举 3.1 枚举类型的定义 3.2 枚举的优点 3.3 枚举的使用 4.联合（共用体） 4.1 联合类型的定义 4.2 联合的特点 （面试题）判断当前计算机的大小端存储 4.3 联合大小的计算
C语言---自定义类型详解（结构体 + 枚举 + 共用体）
a-clear-meaning的博客
07-14 2502
C语言自定义类型（结构体+枚举+联合）的超详细分享，附+贴心图解，清晰明了，快来看看你都学会了吗！
C语言：枚举体、结构体、共用体
Cbye_的博客
02-03 930
C语言：枚举体、结构体以及共用体
C语言——结构体、共用体、枚举、位运算
attitude_lu的博客
08-09 1275
struct 结构体名成员列表其中struct关键字表示在构造一个结构体类型，结构体名用来该结构体这个类型的名称，成员列表表示要描述的复杂数据中用到的具体的成员变量，成员列表的定义方式和普通变量的定义方式相同。例如下面定义一个student结构体类型：int sno;int age;在studen这个结构体中包含了姓名name、学号sno、年龄age;、性别sex[10];分数score;这些数据类型该结构体可以用来描述一个学生的基本信息。
【C语言-进阶】自定义类型详解(结构体+枚举+联合)
TPON的博客
03-28 484
自定义类型详解(结构体+枚举+联合)
自定义类型【结构体+枚举+联合】详解【C语言的进阶结构体】
_featherbrain的博客
04-04 2282
进阶结构体目录☝️ 前言 ☝️ 前言 前面我们系统得学习了一下结构体，讲解了结构体的定义和使用，下面我们会着重下面的重点来讲解自定义类型： 结构体 结构体类型的声明 * ❗️结构体 ❓- 结构体类型的声明 ❓- 结构的自引用 List item ❓ - 结构体变量的定义和初始化 ❓ - 结构体内存对齐 ❓ - 结构体传参 ❓ - 结构体实现位段（位段的填充&可移植性） 枚举 枚举类型的定义 枚举的优点 枚举的使用 联合 联合类型的定义 联合的特点 联合大小的计算 ...
C语言深度解析之六：自定义类型详解(结构体+枚举+联合)
yzy521wjm的博客
03-25 595
今天更新的东西比较简单，最重要的东西就是结构体的内存对齐，还有位段，枚举和联合体的概念和一些计算。
【C语言】自定义类型详解（结构体+枚举+联合）
East-sunrise的博客
07-26 821
自定义类型详解（结构体+枚举+联合）
C语言初阶：结构体，联合体，枚举，类型重命名
凯凯在此
03-28 1925
1. 结构体 1.1 结构体的基本用法 结构体的各种运用： #include <stdio.h> struct Point{ int x; int y; int z; }; void PrintPoint(struct Point m){ printf("(%d,%d,%d)\n",m.x,m.y,m.z); } void PrintPointPtr(struct Point* p){ printf("(%d,
自定义类型(结构体+枚举+联合)详解
lovepotato_的博客
11-06 323
讲解了结构体，枚举，联合体的基本知识
C语言中对自定义类型（结构体、枚举、联合）的深度剖析
dddddrrrzz的博客
09-18 306
目录一、结构体1.1结构的概念1.2结构的声明1.3 特殊的声明1.4 结构的自引用1.5 结构体变量的定义和初始化1.6 结构体内存对齐例题一例题二例题三1.7 修改默认对齐数1.8 结构体传参二、位段2.1 什么是位段2.2 位段的内存分配2.3 位段的跨平台问题三、枚举3.1 枚举类型的定义3.2 枚举的优点四. 联合（共用体）4.1 联合类型的定义4.2 联合的特点4.3 联合大小的计算 常见的自定义类型（构造类型）都有：结构体、枚举、联合体，接下来我们一个一个来看，首先，我们先看结构体： 一、
flex与Bison 词法语法分析
最新发布
11-06 213
编译原理-词法分析实践(flex)_flex编译原理-CSDN博客
DFS求解迷宫最长移动路线
安祝老师的博客
11-05 1265
来源：十四届蓝桥杯STEMA考试Python真题试卷第二套第五题。本文给出了C++实现代码，介绍了 STL 中容器`vector`，`pair`，`unordered_set` 的应用，供信奥选手参考。**迷宫类问题**适合用**DFS算法**解决，本文最后总结了DFS算法的两种常见实现方式——**递归实现、栈实现**，应用场景——**迷宫类问题、图的连通性、树的遍历、拓朴排序、排列组合**，以及主要优缺点。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 311
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 99
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1037
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
C语言结构体与共用体详解
"C语言结构体与共用体的使用方法" 在C语言中，结构体（struct）和共用体（union）是两种重要的构造数据类型，它们允许我们将不同类型的数据组合到一起，形成一个复合的数据结构。下面将详细介绍这两种类型以及它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值