C语言结构体训练

结构体大小和内存结构

 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 }

原文地址：https://www.cnblogs.com/WangGuiHandsome/p/9899005.html

时间： 2024-10-29 21:46:18

C语言结构体训练的相关文章

C语言 结构体指针赋值 incompatible types when assigning to type &#39;char[20]&#39; from type &#39;char *&#39;

strcpy(pstudent->name, "guo zhao wei "); 为什么错误,该怎么写,(红色行) 追问 为什么不能直接赋值啊, 追答 用char nnnn[20]定义的,用strcpy 用char *ppp定义的,用=来赋值 C语言 结构体指针赋值 incompatible types when assigning to type 'char[20]' from type 'char *'

漫谈C语言结构体struct、公用体union空间占用

先用代码说话: #include<stdio.h> union union_data0{ int a ;//本身占用4个字节 char b ;//本身占用1个字节 int c ; }; union union_data1{ short a;//本身占用2个字节 char b[13];//本身占用13个字节 int c ;//本身占用4个字节 }; struct struct_data{ int a ;//int本身占用4个字节,偏移量为0 char b ;//char本身占用1个字节,偏移量为

C语言结构体，C语言结构体指针，java对象引用，传值，传地址，传引用

C语言结构体,C语言结构体指针,java对象引用,传值,传地址,传引用 传值 把实参的值赋值给行参 那么对行参的修改,不会影响实参的值 传地址 传值的一种特殊方式,只是他传递的是地址,不是普通的如int 那么传地址以后,实参和行参都指向同一个对象 传引用 真正的以地址的方式传递参数 传递以后,行参和实参都是同一个对象,只是他们名字不同而已 对行参的修改将影响实参的值 所谓变量是内存地址的一个抽象名字,在静态编译的程序中,所有变量名都会在编译时转换成内存地址,机器不知道变量名,只知道地址. C 语

C语言结构体（struct）常见使用方法（转）

本文转自 CSDN huqinweI987 基本定义:结构体,通俗讲就像是打包封装,把一些有共同特征(比如同属于某一类事物的属性,往往是某种业务相关属性的聚合)的变量封装在内部,通过一定方法访问修改内部变量. 结构体定义: 第一种:只有结构体定义 [cpp] view plaincopy struct stuff{ char job[20]; int age; float height; }; 第二种:附加该结构体类型的“结构体变量”的初始化的结构体定义 [cpp] view plaincopy

C语言结构体赋初值

C语言结构体赋初值,特别是结构体中含有数组成员是,最后一个逗号最好是不要多写.因为有些时候可能会出错.图中,红色的框框处.

读陈浩的《C语言结构体里的成员数组和指针》总结，零长度数组

原文链接:C语言结构体里的成员数组和指针 复制如下: 单看这文章的标题,你可能会觉得好像没什么意思.你先别下这个结论,相信这篇文章会对你理解C语言有帮助.这篇文章产生的背景是在微博上,看到@Laruence同学出了一个关于C语言的题,微博链接.微博截图如下.我觉得好多人对这段代码的理解还不够深入,所以写下了这篇文章. 为了方便你把代码copy过去编译和调试,我把代码列在下面: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h>

c 语言 结构体

结构体初学者都有点小怕其实思维清晰之后你会发现结构体是个非常好的东西,嘿嘿. 第一,结构体的定义和初始化.别被书上大量的描述吓到 1.怎么定义结构体了例子如下,我们以构建一个包含学生姓名,年龄,Email为例子 1 struct 2 { 3 char name; 4 int age; 5 char Email; 6 }person; 现在我们定义就已经完成了,当然这是我最喜欢的范式,你们也可以在书上找到自己喜欢的. 2.怎么初始化了?结构体一般初始化都是以结构体数组的形式来的所以我们只说这个 t

C语言结构体的初始化

今天在工作时,看到了奇葩的结构体初始化方式,于是我查了一下C99标准文档和gcc的说明文档,终于搞清楚是怎么回事了. 假设有如下结构体定义: typedef struct { int a, b, c; } MyStruct; 那么结构体的初始化方式如下有三种: (1) C89的初始化方式 MyStruct test = {1, 2, 3}; 这种初始化的优点是语法简单,无需输入变量名:缺点是成员变量的初始化顺序必须与声明的一致,无法乱序初始化. (2) C99新增的初始化方式 MyStruct

不可或缺 Windows Native (8) - C 语言: 结构体，共用体，枚举，类型定义符

[源码下载] 作者:webabcd 介绍不可或缺 Windows Native 之 C 语言 结构体 共用体 枚举 类型定义符 示例cStruct.h #ifndef _MYHEAD_STRUCT_ #define _MYHEAD_STRUCT_ #ifdef __cplusplus extern "C" #endif char *demo_cStruct(); #endif cStruct.c /* * 结构体,共用体,枚举,类型定义符 * * 注:结构体变量在做参数传递时,其内每个