精华内容
下载资源
问答
  • 结构体数组作为函数参数,编程实现如下菜单驱动的学生成绩管理系统。 (1) 录入每个学生的学号、姓名和各科考试成绩。 (2) 计算每门课程的总分和平均分。 (3) 计算每个学生的总分和平均分。 (4) 按每个...
  • 主要介绍了C++中的指针结构体数组以及指向结构体变量的指针的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
  • Java调用C语言动态库(JNA方式):回调函数、结构体数组传参、结构体数组返回-附件资源
  • 所谓结构体数组,是指数组中的每个元素都是一个结构体。在实际应用中,结构体数组常被用来表示一个拥有相同数据结构的群体,比如一个班的学生、一个车间的职工等。 定义结构体数组和定义结构体变量的方式类似,请看...
  • 主要介绍了C#调用C++DLL传递结构体数组的终极解决方案的相关资料,需要的朋友可以参考下
  • 下面小编就为大家分享一篇基于C#调用c++Dll结构体数组指针的问题详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 讲解区分结构体与结构体数组:结构体的引出、结构体变量的定义和引用、结构体数组
  • 搜索字段(AStruct) - 显示结构数组 AStruct 中的所有字段及其完整(“长”)名称。 搜索字段(AStruct,SearchString) - 显示结构数组 AStruct 中名称包含 SearchString 的所有字段(默认 = 不区分大小写)。 ...
  • 资源代码演示的是c#代码调用c++ DLL 的方式。该演示为原创,绝非搬砖。解决了c# 调用 C++ Dll获取相关信息之如何传递结构体数组引用以及如何处理获取到的结构体数组数据的问题。
  • 定义嵌套结构体数组

    2017-01-21 16:29:28
    定义复杂结构体—包括嵌套结构体数组,并显示结构体所占字节数。
  • Filterstruct 允许使用逻辑矩阵来相同地过滤结构的各个字段。 如果 filterlogic 有一列并且字段包含多于一列,则将过滤每个字段的行。 如果 filterlogic 有多个列,则过滤的字段的大小必须与 filterlogic 相同。...
  • MatLab 函数“orderfields”的递归版本。... 与仅对顶级字段排序的“orderfields”相反,函数“OrderAllFields”在其所有级别上对结构体数组的字段进行排序(从而也传递具有元胞数组结构而不是结构体数组结构的级别)。
  • C语言结构体数组+结构体类型指针+指向结构体数组的指针+typedef类型结构体数组两种结构体数组的定义形式用sizeof运算符求结构体数组所占字节数结构体类型指针指向结构体数组的指针typedef类型 结构体数组 如果要处理...

    上一篇文章:C语言结构体类型定义+结构体变量的定义与使用及其初始化+结构体变量作为函数参数

    结构体数组

    如果要处理多个类型相同的结构体数据,就需要定义结构体数组

    两种结构体数组的定义形式

    结构体数组定义的方法和结构体变量定义的方法一样,只不过加了一个数组的长度而已
    第一种:和结构体类型同时定义,例如:

    struct student
    {
    	int sno;
    	char sname[10];
    	int sage;
    	char depmt[20];
    	float cscore;
    }s1[10];//定义了一个结构体数组,数组名为s1,数组的长度为10
    

    第二种:和结构体类型分开定义,如:

    struct student
    {
    	int sno;
    	char sname[10];
    	int sage;
    	char depmt[20];
    	float cscore;
    };//不要忘记最后的分号
    main()
    {
    	struct student s1[10];//在主函数中定义结构体数组,数组名为s1,数组长度为10
    	...
    }
    

    用sizeof运算符求结构体数组所占字节数

    在这里插入图片描述
    char name 占用10个字节,int age 占用4个字节,int score占用3*4=12个字节,加起来总共是26个字节,可是上面输出的是28个字节,多出两个字节。这是因为在编译系统中,结构体类型存在字节边界的要求。而不同编译器字节边界的要求又是不一样的,上面这个案例我使用的是DevC++编译器,然而试验了一番之后,我并没能发现DevC++编译器字节边界要求的规律,反而把我给整懵圈了,如下:
    在这里插入图片描述
    虽然它的内存地址分配规律我没能搞懂,但是在使用的时候,依然可以正常用指针来操纵内存地址,进而操纵对应内存地址中的数据。 如下:
    在这里插入图片描述
    结构体中的内存地址分配规律,相对于普通的数据类型的内存地址分配规律,要更加复杂一些,而且不同的编译器也不一样。
    在VC编译器中,各成员变量在内存中的起始地址相对于结构体变量(或数组)的起始地址的偏移量,必须为该变量的类型所占字节数的倍数。如果某成员的偏移量不是该类型的整数倍,则VC编译系统会自动填充一定的字节数,以保证字节边界的要求。同时VC为了确保结构体的大小为结构体中所占内存空间最大的成员类型的字节数的倍数,在为最后一个成员变量申请空间后,还会根据需要自动填充空缺的字节。
    在这里插入图片描述
    内存地址相减得到各成员变量所占的字节数

    注意
    访问结构体中的数据时,格式为结构体变量.结构体成员,这个时候使用的是点. 如果是一个指针变量p,p指向一个结构体类型,用指针来访问的话那么格式为指针变量->结构体成员,这个时候使用的是减号和大于号->,表示一个箭头,注意区分一下,使用的时候不要出错

    结构体数组初始化

    格式为:结构数组[n] = {{初值表1},{初值表2}, ... ,{初值表n}};
    在这里插入图片描述
    用for循环输出结构体数组中的內容:
    在这里插入图片描述
    当一个代码语句太长时,用反斜杠来进行代码换行
    图中的代码有个字母打错了,导致最后的成绩输出全部是0,分数是float型的,而输出的时候却用了%d,应该用%f

    结构体数组作为函数的参数

    结构体数组作为函数的参数时,既可以作为形参,也可以作为实参,和普通数组一样。实参到形参的传递为地址传递。

    查找符合条件的人数(一)

    #include <stdio.h>
    #define N 10
    struct student
    {
    	int no;
    	char name[10];
    	int score;
    };
    int fun(struct student s[],struct student b[],int m,int n);
    void output(struct student x[],int n);
    int main()
    {
    	struct student s[N]=
    	{
    		{1001,"zhangsan",79},
    		{1002,"lisi",87},
    		{1003,"wanger",83},
    		{1004,"mazi",86},
    		{1005,"wangwu",89},
    		{1006,"wangliu",75},
    		{1007,"liwu",84},
    		{1008,"zhangwu",93},
    		{1009,"zhangqi",85},
    		{1010,"masan",97},
    	};
    	int m,n,k;
    	struct student a[N];
    	printf("please input range in m,n:\n");
    	scanf("%d%d",&m,&n);
    	printf("The original data:\n");
    	output(s,N);
    	k=fun(s,a,m,n);
    	printf("The student that score in %d & %d is:\n",m,n);
    	output(a,k);
    	return 0;
    }
    int fun(struct student s[],struct student b[],int m,int n)
    {
    	int i,k=0;
    	for(i=0;i<N;i++)
    	{
    		if(s[i].score>=m&&s[i].score<=n)
    			b[k++]=s[i];
    	}	
    	return k;
    }
    void output(struct student x[],int n)
    {
    	int i;
    	printf(" no          name       score\n");
    	for(i=0;i<n;i++)
    		printf("%d   %10s       %d\n",x[i].no,x[i].name,x[i].score);
    	putchar('\n');
    }
    

    在这里插入图片描述

    结构体类型指针 和 指向结构体数组的指针

    指向结构体变量的指针的定义

    struct 结构体类型名 *指针名;

    struct student stu;
    struct student *ps=&stu;
    

    利用结构体指针引用结构体变量成员

    指针变量->结构体成员名;
    取內容符**指针变量表示指针指向的变量,
    也可以(*指针变量).成员名
    所以有三种方法可以指向结构体成员变量
    结构体变量名 . 成员变量名
    指向结构体变量的指针变量的名字 -> 成员变量名
    (*指向结构体变量的指针变量的名字) . 成员变量名,括号不可省略

    "."是分量运算符
    

    指向结构体数组的指针

    struct student s[3];
    struct student *ps=s;//结构体变量名“s”为结构体数组的首地址
    

    也可以写成:

    struct student *ps=&s[0];
    

    查找符合条件的人数(二)

    结构体数组作为函数的实参时,可以用指针变量作为形参来接收结构体数组的内存地址,进而进行操作,把上面的代码改用指针来做,如下:(用指针做会更麻烦一些,但是为了加深对指针的印象和应用,我还是用指针做了一遍)

    #include <stdio.h>
    #define N 10
    struct student
    {
    	int no;
    	char name[10];
    	int score;
    };
    int fun(struct student *p,struct student *p2,int m,int n);//用指针来接收结构体数组的内存地址
    void output(struct student *p,int n);//用指针来接收结构体数组的内存地址
    int main()
    {
    	struct student s[N]=
    	{
    		{1001,"zhangsan",79},
    		{1002,"lisi",87},
    		{1003,"wanger",83},
    		{1004,"mazi",86},
    		{1005,"wangwu",89},
    		{1006,"wangliu",75},
    		{1007,"liwu",84},
    		{1008,"zhangwu",93},
    		{1009,"zhangqi",85},
    		{1010,"masan",97},
    	};
    	int m,n,k;
    	struct student a[N];
    	printf("please input range in m,n:\n");
    	scanf("%d%d",&m,&n);
    	printf("The original data:\n");
    	output(s,N);
    	k=fun(s,a,m,n);
    	printf("The student that score in %d & %d is:\n",m,n);
    	output(a,k);
    	return 0;
    }
    int fun(struct student *p1,struct student *p2,int m,int n)//用指针来接收结构体数组的内存地址
    {
    	int i,k=0;
    	for(i=0;i<N;i++)
    	{
    		if((p1+i)->score>=m&&(p1+i)->score<=n)//用指针指向结构体数组中的人成员变量
    			*(p2+k++)=*(p1+i);//结构体变量之间的赋值
    			//注意k++和++k之间的区别
    	}
    	return k;
    }
    void output(struct student *p,int n)//用指针来接收结构体数组的内存地址
    {
    	int i;
    	printf(" no          name       score\n");
    	for(i=0;i<n;i++)
    		printf("%d   %10s       %d\n",(p+i)->no,(p+i)->name,(p+i)->score);
    	putchar('\n');
    }
    

    在这里插入图片描述

    typedef类型

    typedef的使用形式:typedef 标准类型名 别名;
    如:

    typedef int INTEGER;
    

    为标准类型int定义一个别名,可以使用INTEGER来定义变量

    INTEGER a,b;
    

    结构体也可以使用typedef类型定义:

    typedef struct student
    {
    	int no;
    	char name[10];
    	int score;
    }STU;
    

    这样就可以使用STU来定义结构体变量:

    STU s1,s2;
    STU s[10];
    

    学生成绩排序

    输入n(n<=50)个学生的成绩信息,按照学生的个人平均成绩从高到低输出他们的信息。

    #include <stdio.h>
    struct student
    {
    	int num;
    	char name[10];
    	int computer,english,math;
    	double average;
    };
    int main()
    {
    	int i,index,j,n;
    	struct student stu[50],temp;
    	
    	printf("Input n:");
    	scanf("%d",&n);
    	for(i=0;i<n;i++)
    	{
    		printf("Input the info of No.%d:\n",i+1);
    		printf("number:");
    		scanf("%d",&stu[i].num);
    		printf("name:");
    		scanf("%s",stu[i].name);
    		printf("math score:");
    		scanf("%d",&stu[i].math);
    		printf("english score:");
    		scanf("%d",&stu[i].english);
    		printf("computer score:");
    		scanf("%d",&stu[i].computer);
    		stu[i].average=(stu[i].math+stu[i].english+stu[i].computer)/3.0;
    	}
    	for(i=0;i<n-1;i++)
    	{
    		index=i;
    		for(j=i+1;j<n;j++)
    			if(stu[j].average>stu[index].average)
    				index=j;
    		temp=stu[index];
    		stu[index]=stu[i];
    		stu[i]=temp;
    	}
    	printf("num\tname\taverage\n");
    	for(i=0;i<n;i++)
    		printf("%d\t%s\t%.2lf\n",stu[i].num,stu[i].name,stu[i].average);
    		
    	return 0;
    }
    

    在这里插入图片描述

    修改学生成绩

    输入n(n<=50)个学生的成绩信息,再输入一个学生的学号、课程以及成绩,在自定义函数中修改该学生指定课程的成绩

    #include <stdio.h>
    struct student 
    {
    	int num;
    	char name[10];
    	int computer,english,math;
    	double average;
    };
    int updata_score(struct student *p,int n,int num,int course,int score);
    int main()
    {
    	int course, i, n, num, pos, score;
    	struct student stu[50];
    	printf("Input n:");
    	scanf("%d",&n);
    	for(i=0;i<n;i++)
    	{
    		printf("Input the info of No.%d:\n",i+1);
    		printf("number:");
    		scanf("%d",&stu[i].num);
    		printf("name:");
    		scanf("%s",stu[i].name);
    		printf("math score:");
    		scanf("%d",&stu[i].math);
    		printf("english score:");
    		scanf("%d",&stu[i].english);
    		printf("computer score:");
    		scanf("%d",&stu[i].computer);
    	}
    	printf("Input the number of the students to be updata:");
    	scanf("%d",&num);
    	printf("Choise the course: 1.math  2.english  3.computer:");
    	scanf("%d",&course);
    	printf("Input the new score:");
    	scanf("%d",&score);
    	pos=updata_score(stu,n,num,course,score);
    	if(pos==-1)
    		printf("Not found!\n");
    	else
    	{
    		printf("After updata:\n");
    		printf("num\tmath\tenglish\tcomputer\n");
    		printf("%d\t%d\t%d\t%d\n",stu[pos].num, stu[pos].math, stu[pos].english, stu[pos].computer);
    	}
    	return 0;
    }
    int updata_score(struct student *p,int n,int num,int course,int score)
    {
    	int i,pos;
    	for(i=0;i<n;i++,p++)
    		if(p->num==num)
    			break;
    	if(i<n)
    	{
    		switch(course)
    		{
    			case 1:p->math=score;break;
    			case 2:p->english=score;break;
    			case 3:p->computer=score;break;
    		}
    		pos=i;
    	}
    	else
    		pos=-1;
    	return pos;
    }
    

    在这里插入图片描述

    下一篇文章

    动态数组的实现,结合指针与结构体实现链表,以及链表相关操作

    展开全文
  • 1.定义结构体数组 和定义结构体变量类似,定义结构体数组时只需声明其为数组即可。如: 代码如下:struct Student{ int num; char name[20]; char sex[5]; int age; float score; char addr[30];};Student stu...
  • 定义一个职工结构体数组,从键盘输入5位职工信息,打印输出最高的工资。是一个很好的关于学习C语言结构体的例子。
  • 对于结构体数组,前些天有个同事说链表真好用,他的关注点是插入排序(用于对蓝牙设备顺序存入,然后将新的蓝牙设备按照接收灵敏度插入到链表中,既完成了存入,又完成了排序)。因为他是第一次用链表,表述成了链表...

    目录

    为什么要写这篇

    为什么要用结构体数组

    什么时候用得到结构体数组

    C代码实现运用结构体数组

    程序运行结果

    达到预期目的

    程序优化

    程序优化后源代码


    为什么要写这篇

    近期一直在看C Primer Plus,对于C语言的掌握能力有了显著提升,运用也更灵活。因此对C语言刷新的认知是:C语言是把刻刀。同时在 “习以为常” 之前记录一下成长:成长中实践

    编译出错,语义错误什么的不再是简单的认为改改就好,问题解决能用就行,而成了如何用好C语言,少犯一些低级错误。为什么觉得错误低级,又为什么觉得是C语言是刻刀?因为工具参考书就在那里,写得明明白白。不去使用手册,遇到问题不从自身找原因,而是吃一堑长一智,这种做法,前期可行,但想一直用下去,永远无法对C语言掌握透彻,永远不会觉得这只是一个工具(刻刀)。而且不看C语言的书籍,不会清楚明白C语言和其它编程语言的界限在哪里。更别提以他山之石,攻己之玉。

    为什么要用结构体数组

    对于结构体数组,前些天有个同事说链表真好用,他的关注点是插入排序(用于对蓝牙设备顺序存入,然后将新的蓝牙设备按照接收灵敏度插入到链表中,既完成了存入,又完成了排序)。因为他是第一次用链表,表述成了链表排序真好用,当时我说的是用结构体数组应该更好一些吧,数组的排序要比链表快吧(回头查了一下链表的插入排序与数组的冒泡排序或快速排序 的对比)。我却劝别人用,但自己还没用过结构体数组,因此在心里留下了个结,一直想着解开这个结。

    什么时候用得到结构体数组

    后来一个灯板的电路进行了更改,选择的芯片引脚不够控制那么多RGB灯,就用上了74HC595芯片(串转并)。关于74HC595想了解的可以看一下这篇文章:74HC595引脚图详解

    一开始没有想到更改硬件之后会对原来的功能产生影响,认为只需要把RGB灯控制部分的程序更改为用74HC595控制就好了,但后来发现个问题。

    之前RGB灯的七种颜色控制是直接用红、绿、蓝颜色的灯亮灭来拼出来的,控制红、绿、蓝颜色灯的引脚高低就可以控制灯颜色,程序的实现并非用宏定义常量来标识要显示的颜色,而是通过枚举类型的常量来表示颜色。当常量要控制的颜色修改时,只需修改枚举类型的颜色标识符顺序(标识符还是那个标识符,但对应的常量值变了),而无需修改程序内部逻辑。

    但换成74HC595后,红绿蓝颜色灯的引脚不能单独控制了,而是通过按位输入到74HC595。一次性控制多个RGB灯,要还是用这种switch...case的方式,情况是多个灯的情况, 比如红红红 是一种case, 红红黄是一种case, 如果是3个灯的话7*7*7 = 343 个case分支,灯越多case分支越多。因此需要一种新的方式实现:设置颜色控制颜色 相分离,即标记颜色的常量(设置颜色的常量)控制颜色的常量无关。

    分离后,如果使用switch...case方式,仍然可以是七八个case分支(case 是设置颜色,具体执行的case分支是将控制颜色存入某个变量),最后将几个灯控制颜色的变量拼接起来按位送入74HC595。但这样无形中引入了新的问题,硬件更改,这个switch...case函数也得更改,从我的理解角度来说,硬件更改,只是数据发生了变动,又不是有了新的需求,程序实现逻辑不该发生改动

    设置颜色 控制颜色 相关的变量并不用函数来将其关联,而是通过某种数据结构,这种数据结构要能表示这种关联 的 集合。这时候就想到结构体数组了。

    C代码实现运用结构体数组

    程序运行结果

    达到预期目的

    之后要修改常量对应的颜色只需修改枚举类型 rgb_color(标记颜色的常量(设置颜色的常量))的标识符顺序就可以啦, 硬件电路有修改只需要更改total_color数组每一项的set_color值就可以啦。

    程序优化

    访问结构体数组的函数使用顺序查找是比较低效的,因为结构体数组在迁就(设置颜色的常量),数组最好的访问方式不是通过顺序查找,而是使用下标直接访问到数组元素,此时时间复杂度为O(1)。

    结构体数组的每一项下标是固定的(0,1,2  ...),只是每一项的结构体的成员变量可能发生改变,导致设置颜色的常量与结构体数组的下标值不相等。若按照标记颜色的常量(设置颜色的常量) 由小到大进行排序,只需初始化时进行一次,使其与结构体的下标相对应,之后就可以通过下标直接访问结构体另一项成员变量了。

    优化后访问结构体数组函数

    程序优化后源代码

    下面是改进后的测试程序,可以直接在菜鸟C在线工具运行。

    此处对排序的使用还是基于之前的架构,交换的函数有所不同,冒泡排序的实现和以前也有所不同,感兴趣的小伙伴可以拿这篇文章对照下:把数据滤波写成不明觉厉的样子

    #include <stdio.h>
    #include <stdint.h>
    #include <stdlib.h>
    #include <time.h>
    
    
    #define DEBUG_OUTPUT 		1
    
    typedef struct color_set
    {
    	uint8_t color;
    	uint8_t set_color;
    }COLOR_SET;
    
    enum rgb_color        ///< 为测试而修改
    {
    	NO_COLOR = 0,
    	PURPLE,
    	RED,	
    	GREEN,
    	BLUE,
    	WHITE,
    	YELLOW,
    	CHING,
    };
    
    COLOR_SET total_color[8] =
    {
    	{NO_COLOR, 0},
    	{RED, 1},
    	{YELLOW, 3},
    	{GREEN, 2},
    	{CHING, 6},
    	{BLUE, 4},
    	{PURPLE, 5},
    	{WHITE, 7}
    };
    
    
    
    typedef void (*Exchange_Func)(void *, void *);
    
     uint8_t _74HC595_set_color(uint8_t color);
     void struct_binary_exchange(void* num1, void* num2);
     void bubble_sort(void * buf, uint16_t num, uint8_t size, Exchange_Func operator_func);
     uint8_t _74HC595_set_color_Init(void);
    
    /**
     * _74HC595_set_color
     * @brief 	得到74HC595实际输出的值
     * @param	要设置的颜色对应的常量color_set.color
     * @return 	转换成要设置的颜色对应值 color_set.set_color
     */
     uint8_t 
     _74HC595_set_color(uint8_t color)
     {
    #if DEBUG_OUTPUT
    	printf("output color is: %d", total_color[color].set_color);
    #endif
    	return total_color[color].set_color;
     }
    
    /**
     * uint8_t_binary_exchange
     * @brief 设计判断条件交换两数在数组中的位置
     * @param	num1 按照uint8_t类型进行处理
     * @param 	num2 按照uint8_t类型进行处理
     * @retval	None
     * @note	将 > 改为 < 即由递增序列变为递减序列
     */
    void 
    struct_binary_exchange(void* num1, void* num2)
    {
    	if((*(COLOR_SET *)num1).color > (*(COLOR_SET *)num2).color)
    	{
    		COLOR_SET temp = *(COLOR_SET *)num1;
    		*(COLOR_SET *)num1 = *(COLOR_SET *)num2;
    		*(COLOR_SET *)num2 = temp;
    	}else
    	{
    		/* no code */
    	}
    }
    
    /**
     * bubble_sort
     * @brief 	冒泡排序法,为处理不同数据准备的框架
     * @details 使用回调函数来实现只改底层,不动上层的分层思想
     * @param	buf 数组首地址,void* 修饰,表示任意类型传入
     * @param	num 数组大小,通常用sizeof(buf)/sizeof(buf[0]) 来得到
     * @param	size 要处理的数据类型占用字节数,通常用sizeof(buf[0]) 来得到
     * @param	operator_fuc 函数指针,用于调用相应函数实现功能
     * @retval 	None
     * @note	为功能测试而通过宏切换验证
     */
    void 
    bubble_sort(void * buf, uint16_t num, uint8_t size, Exchange_Func operator_func)
    {
    	uint16_t ex_cycle_i, in_cycle_j;
     
    	if(size == 0 || size > 16)
    	{
    		printf("please check input data type size !\n");
    		return;
    	}else
    	{
    		for(ex_cycle_i = 0; ex_cycle_i < num - 1; ex_cycle_i++)
    		{
    			for(in_cycle_j = ex_cycle_i + 1; in_cycle_j < num; in_cycle_j++)
    			{
    				operator_func(buf + size*ex_cycle_i, buf + size*in_cycle_j);
    			}
    		}
    	}
    }
    
    /**
     * _74HC595_set_color_Init
     * @brief 	将用于74HC595的数组排序
     * @note 	对于频繁调用的函数_74HC595_set_color 减轻工作量
     */ 
    uint8_t 
    _74HC595_set_color_Init(void)
    {
    #if DEBUG_OUTPUT
    	printf("origin data is :\n");
    	for(uint8_t i=0; i<8; i++)
    	{
    		printf("total_color[%d].color = %d, total_color[%d].set_color = %d \n", i, total_color[i].color, i, total_color[i].set_color);
    	}
    #endif
    	bubble_sort((void *)total_color, sizeof(total_color)/sizeof(total_color[0]), sizeof(total_color[0]), struct_binary_exchange);
    #if DEBUG_OUTPUT
    	printf("sort data is :\n");
    	for(uint8_t i=0; i<8; i++)
    	{
    		printf("total_color[%d].color = %d, total_color[%d].set_color = %d \n", i, total_color[i].color, i, total_color[i].set_color);
    	}
    	printf("\n");
    #endif
    }
    
    int main(void)
    {
    	_74HC595_set_color_Init();
    
    #if DEBUG_OUTPUT
    	srand((unsigned)time(NULL));
    	uint8_t random_val = rand() % 7 + 1;
    	printf("random_val is %d \n", random_val);
    	_74HC595_set_color(random_val);
    #endif
    
    	return 0;
    }

    展开全文
  • 结构体是一种集合,它里面包含了多个变量或数组,它们的类型可以相同,也可以不同,每个这样的变量或数组都称为结构体的成员(Member)。请看下面的一个例子: struct stu{ char name[]; //姓...

    1.结构体的定义与使用

    • 结构体是一种构造数据类型
    • 把不同类型的数据组合成一个整体

    结构体的定义形式:

    struct 结构体名{
        结构体所包含的变量或数组
    };

    结构体是一种集合,它里面包含了多个变量或数组,它们的类型可以相同,也可以不同,每个这样的变量或数组都称为结构体的成员(Member)。请看下面的一个例子:

    struct stu{
        char name[];  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在学习小组
        float score;  //成绩
    };

    注意:大括号后面的分号;不能少,这是一条完整的语句。

    stu 为结构体名,它包含了 5 个成员,分别是 name、num、age、group、score。结构体成员的定义方式与变量和数组的定义方式相同,只是不能初始化

    结构体也是一种数据类型,它由程序员自己定义,可以包含多个其他类型的数据。
    像 int、float、char 等是由C语言本身提供的数据类型,不能再进行分拆,我们称之为基本数据类型;而结构体可以包含多个基本类型的数据,也可以包含其他的结构体,我们将它称为复杂数据类型或构造数据类型。

    • 先定义结构体类型,再定义结构体变量
     struct   student 
    {       
     int num;
     char  name[20];
     char sex;
     int age; 
     float score;
     char addr[30];
     };
     struct student stu1,stu2;         
    • 定义结构体类型的同时定义结构体变量
     struct   data
     {      
      int day int month;
      int year
     }time1,time2; 
    • 直接定义结构体变量
     struct 
    {
     char name[20];
     char sex; 
     int num; 
     float score[3]
     }person1,person2; 

    2.结构体变量的初始化

    和其它类型变量一样,对结构体变量可以在定义时指定初始值。

    #include <stdio.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book = {"C 语言", "RUNOOB", "编程语言", 123456};
     
    int main()
    {
        printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
    }

    输出结果:

    title : C 语言
    author: RUNOOB
    subject: 编程语言
    book_id: 123456

    3.访问结构成员

    为了访问结构的成员,我们使用成员访问运算符(.)

    引用形式:<结构体类型变量名>.<成员名>

    注意:结构体变量不能整体引用,只能引用变量成员

    成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法:

    #include <stdio.h>
    int main(){
        struct{
            char *name;  //姓名
            int num;  //学号
            int age;  //年龄
            char group;  //所在小组
            float score;  //成绩
        } stu1;
    
        //给结构体成员赋值
        stu1.name = "Tom";
        stu1.num = 12;
        stu1.age = 18;
        stu1.group = 'A';
        stu1.score = 136.5;
    
        //读取结构体成员的值
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", stu1.name, stu1.num, stu1.age, stu1.group, stu1.score);
    
        return 0;
    }

    运行结果:
    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    除了可以对成员进行逐一赋值,也可以在定义时整体赋值,例如: 

    struct{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1, stu2 = { "Tom", 12, 18, 'A', 136.5 };

    不过整体赋值仅限于定义结构体变量的时候,在使用过程中只能对成员逐一赋值,这和数组的赋值非常类似。

    需要注意的是,结构体是一种自定义的数据类型,是创建变量的模板,不占用内存空间;结构体变量才包含了实实在在的数据,需要内存空间来存储。

    4.结构作为函数参数

    可以把结构作为函数参数,传参方式与其他类型的变量或指针类似。例如:

    #include <stdio.h>
    #include<string.h>
    
    struct Books
    {
    	char title[50];
    	char author[50];
    	char subject[100];
    	int book_id;
    };
    
    void printBook(struct Books book);//函数声明
    
    int main()
    {
    	struct Books Book1;//声明Book1,类型为Books
    	struct Books Book2;
    
    	/* Book1 详述 */
    	strcpy(Book1.title, "C Programming");
    	strcpy(Book1.author, "Nuha Ali");
    	strcpy(Book1.subject, "C Programming Tutorial");
    	Book1.book_id = 6495407;
    	printBook(Book1);
    	return 0;
    }
    void printBook(struct Books book)
    {
    	printf("Book title:%s\n", book.title);
    	printf("Book author:%s\n", book.author);
    	printf("Book subject:%s\n", book.subject);
    	printf("Book book_id:%d\n", book.book_id);
    }

    运行结果:

    Book title:C Programming
    Book author:Nuha Ali
    Book subject:C Programming Tutorial
    Book book_id:6495407

    5.结构体数组

    所谓结构体数组,是指数组中的每个元素都是一个结构体。在实际应用中,结构体数组常被用来表示一个拥有相同数据结构的群体,比如一个班的学生、一个车间的职工等。

    定义结构体数组和定义结构体变量的方式类似,请看下面的例子:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5];
    //表示一个班有5个人

    结构体数组在定义的同时也可以初始化,例如:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };

    当对数组中全部元素赋值时,也可以不给出数组长度,如:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };

    结构体数组的使用也很简单。例如,计算全班学生的总成绩、平均成绩和140分一下的人数:

    #include <stdio.h>
    
    struct{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    }class[] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };
    
    int main(){
        int i, num_140 = 0;
        float sum = 0;
        for(i=0; i<5; i++){
            sum += class[i].score;
            if(class[i].score < 140) num_140++;
        }
        printf("sum=%.2f\naverage=%.2f\nnum_140=%d\n", sum, sum/5, num_140);
        return 0;
    }

    运行结果:

    sum=707.50
    average=141.50
    num_140=2

    6.指向结构的指针

    可以定义指向结构的指针,方式与定义指向奇特类型变量的指针类似,

    定义形式:struct 结构体名 *结构体指针名;

    struct Books *struct_pointer;

    定义之后可以在上述定义的指针变量中存储结构变量的地址。例:

    struct_pointer = &Book1;

    为了使用指向该结构的指针访问结构的成员,必须使用->运算符,如下所示:

    struct_pointer->title;

    定义结构体指针的实例:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1 = { "Tom", 12, 18, 'A', 136.5 };
    //结构体指针
    struct stu *pstu = &stu1;

    也可以在定义结构体的同时定义结构体指针:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

    注意:结构体变量名和数组名不同,数组名在表达式中会被转换为数组指针,而结构体变量名不会,无论在任何表达式中它表示的都是整个集合本身,要想取得结构体变量的地址,必须在前面加&符号,所以给p赋值只能写成

    struct stu *p=&stu1;

    而不能写成:

    struct stu *p=stu1;

    注意:结构体和结构体变量是两个不同的概念:结构体是一种数据类型,是一种创建变量的模板,编译器不会为它分配内存空间,就像 int、float、char 这些关键字本身不占用内存一样;结构体变量才包含实实在在的数据,才需要内存来存储。下面的写法是错误的,不可能去取一个结构体名的地址,也不能将它赋值给其他变量:

    struct stu *pstu = &stu;
    struct stu *p=stu;

    7.获取结构体成员

    通过结构体指针可以获取结构体成员,一般形式为:

    (*pointer).memberName

    或者:

    pointer->memberName

    第一种写法中,.的优先级高于*,(*pointer)两边的括号不能少,如果去掉括号写成*pointer.memberName,那么就等效于*(pointer.memberName),这样意义就不对了。

    第二种写法中,->是一个新的运算符,习惯称它为“箭头”,有了它,可以通过结构体指针直接取得结构体成员,这也是->在C语言中的唯一用途。

    上面两种写法是等效的,我们通常采用第二种写法,这样更加直观。

    实例:结构体指针的使用

    #include <stdio.h>
    int main(){
        struct{
            char *name;  //姓名
            int num;  //学号
            int age;  //年龄
            char group;  //所在小组
            float score;  //成绩
        } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;
    
        //读取结构体成员的值
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", (*pstu).name, (*pstu).num, (*pstu).age, (*pstu).group, (*pstu).score);
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", pstu->name, pstu->num, pstu->age, pstu->group, pstu->score);
    
        return 0;
    }

    运行结果:

    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!
    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    示例:结构体数组指针的使用

    #include <stdio.h>
    
    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    }stus[] = {
        {"Zhou ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"Liu fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    }, *ps;
    
    int main(){
        //求数组长度
        int len = sizeof(stus) / sizeof(struct stu);
        printf("Name\t\tNum\tAge\tGroup\tScore\t\n");
        for(ps=stus; ps<stus+len; ps++){
            printf("%s\t%d\t%d\t%c\t%.1f\n", ps->name, ps->num, ps->age, ps->group, ps->score);
        }
    
        return 0;
    }

    运行结果:

    Name            Num     Age     Group   Score
    Zhou ping       5       18      C       145.0
    Zhang ping      4       19      A       130.5
    Liu fang        1       18      A       148.5
    Cheng ling      2       17      F       139.0
    Wang ming       3       17      B       144.5

    参考资料:

    C语言结构体和指针

    C语言结构体数组

    C结构体

    展开全文
  • 本文实例为大家分享了C++结构体数组实现贪吃蛇的具体代码,供大家参考,具体内容如下 代码: #include #include #include using namespace std; const int h=50,w=50,MaxLen=400; void gotoxy(short y,short x)//...
  • C语言结构体数组

    千次阅读 多人点赞 2018-10-18 19:50:54
    C语言结构体数组 所谓结构体数组,是指数组中的每个元素都是一个结构体。在实际应用中,结构体数组常被用来表示一个拥有相同数据结构的群体,比如一个班的学生、一个车间的职工等。 定义结构体数组和定义结构体...

    C语言结构体数组

    所谓结构体数组,是指数组中的每个元素都是一个结构体。在实际应用中,结构体数组常被用来表示一个拥有相同数据结构的群体,比如一个班的学生、一个车间的职工等。

    定义结构体数组和定义结构体变量的方式类似,请看下面的例子:

    struct stu{

        char *name;  //姓名

        int num;  //学号

        int age;  //年龄

        char group;  //所在小组

        float score;  //成绩

    }class[5];

    表示一个班级有5个学生。

    结构体数组在定义的同时也可以初始化,例如:

    struct stu{

        char *name;  //姓名

        int num;  //学号

        int age;  //年龄

        char group;  //所在小组

        float score;  //成绩

    }class[5] = {

        {"Li ping", 5, 18, 'C', 145.0},

        {"Zhang ping", 4, 19, 'A', 130.5},

        {"He fang", 1, 18, 'A', 148.5},

        {"Cheng ling", 2, 17, 'F', 139.0},

        {"Wang ming", 3, 17, 'B', 144.5}

    };

    当对数组中全部元素赋值时,也可不给出数组长度,例如:

    struct stu{

        char *name;  //姓名

        int num;  //学号

        int age;  //年龄

        char group;  //所在小组

        float score;  //成绩

    }class[] = {

        {"Li ping", 5, 18, 'C', 145.0},

        {"Zhang ping", 4, 19, 'A', 130.5},

        {"He fang", 1, 18, 'A', 148.5},

        {"Cheng ling", 2, 17, 'F', 139.0},

        {"Wang ming", 3, 17, 'B', 144.5}

    };

    结构体数组的使用也很简单,例如,获取 Wang ming 的成绩:

    class[4].score;

    修改 Li ping 的学习小组:

    class[0].group = 'B';

    【示例】计算全班学生的总成绩、平均成绩和以及 140 分以下的人数。

    #include <stdio.h>

    struct{

        char *name;  //姓名

        int num;  //学号

        int age;  //年龄

        char group;  //所在小组

        float score;  //成绩

    }class[] = {

        {"Li ping", 5, 18, 'C', 145.0},

        {"Zhang ping", 4, 19, 'A', 130.5},

        {"He fang", 1, 18, 'A', 148.5},

        {"Cheng ling", 2, 17, 'F', 139.0},

        {"Wang ming", 3, 17, 'B', 144.5}

    };

    int main(){

        int i, num_140 = 0;

        float sum = 0;

        for(i=0; i<5; i++){

            sum += class[i].score;

            if(class[i].score < 140) num_140++;

        }

        printf("sum=%.2f\naverage=%.2f\nnum_140=%d\n", sum, sum/5, num_140);

        return 0;

    }

    运行结果:

    sum=707.50

    average=141.50

    num_140=2

    展开全文
  • 一、结构体指针 与一般指针类似结构体也可以使用结构体指针进行引用使用。结构体指针的定义方式如下: struct Student stu = { 1001,"Li Lei",'M',1.87 }; //定义一个Student 的结构体变量stu struct Student *p...
  • 结构体数组详解

    2021-10-08 13:35:36
    C语言结构体数组概述 C语言定义结构体数组 C语言使用结构体数组注意事项 实例应用 C语言结构体数组概述 一个结构体变量中可以存放一组有关联的数据,如一个学生的学号、姓名、成绩等数据,如果有10个学生的...
  • C++结构体数组 | 结构体数组的使用

    千次阅读 2020-12-30 21:23:16
    C++结构体数组 C++结构体数组与以前介绍过的数值型数组的不同之处在于:每个数组元素都是一个结构体类 型的数据,它们都分别包括各个成员项。 C++结构体数组定义 C++结构体数组的定义和定义结构体变量的方法相仿,只...
  • 结构体数组 结构体数组格式:声明变量类型 数组名称[数组长度] //定义一个结构体数组名为a,它里面包含有5个元素,每一个元素都是一个结构体变量 Wor a[5]={}; ...
  • mfc上使用gsoap,返回值为结构体/结构体数组。有一定的借鉴意义
  • 结构体数组

    千次阅读 多人点赞 2017-09-10 19:18:31
    结构体数组 结构体数组相对于顺序表的优势在于可以用每个结点存储每个个体的信息,相对于链表的优势在于操作简便;结构体数组的劣势在于插入、删除操作占用资源过多,并且有时候无法分配足够的连续空间。  结构体...
  • 结构体数组初始化

    千次阅读 2021-03-17 15:24:52
    《代码大全》建议在变量定义的时候进行初始化,但是很多人,特别是新人对结构体或者结构体数组定义是一般不会初始化,或者不知道怎么初始化。 1、初始化 typedef struct _TEST_T { int i; char c[10]; }TEST_T; TEST...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 236,359
精华内容 94,543
关键字:

结构体数组