重温C语言 | 结构体

结构体：

由一系列具有相同或者不同的数据类型的数据组成的集合，数据彼此之间有联系

数组：

由一系列具有相同数据类型的数据组成的集合，数据之间彼此独立，
数据意义相同---->数据类型相同
数组的特点：

数据多
数据的意义一样，---->数据类型一样
数据彼此独立，互不影响
可以拆分为基本数据类型
结构体的特点：
数据多
数据意义不一样—>数据类型不一样，也有可能一样
数据彼此有联系
可以拆分为基本数据类型

结构体类型定义的格式：
struct 结构体名
{
//成员列表
};
struct ：关键字，表示一种结构体数据类型 *----->指针类型 —> int *
结构体类型：struct 结构体名
成员列表：数据类型成员名; -------->结构体中的成员不能赋值
成员用分号隔开
结构体支持嵌套，但是要在嵌套之前，完成定义
结构体类型只需要定义一次，后面直接使用，不需要再重新定义该类型
结构体类型定义完成之后，不占用内存空间，只有在使用该类型的变量的时候，系统才会分配内存空间

注意：结构体大括号外面的分号不能省略

struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成绩
int num; //学号
struct BIR t;
};

结构体类型变量的定义

结构体类型变量的定义有三种方式
1）在定义结构体类型的同时，定义结构体类型的变量
struct NOM
{
char name[15]; //姓名
int score[2]; //成绩
int num; //学号
struct BIR t;
}a;
2）先定义结构体类型，然后在定义结构体类型的变量
struct NOM
{
char name[15]; //姓名
int score[2]; //成绩
int num; //学号
struct BIR t;
};
struct NOM 变量名;
3）在定义结构体类型的同时，不加结构体名，定义结构体类型的变量
struct
{
char name[15]; //姓名
int score[2]; //成绩
int num; //学号
struct BIR t;
}b,q; //定义结构体类型变量b
第三种形式不常用，这种方法只适合一次性的变量的定义，如果程序运行到后面的时候，还需要该类型的变量，则此时无法定义。
结构体类型的定义一般在头文件与主函数之间，在函数声明之前

构体类型变量的赋值引用初始化

结构体类型变量的初始化

结构体类型变量的初始化，采用大括号的形式对其进行整体赋值，系统默认从第一个成员开始赋值
结构体类型变量只有在初始化的时候，才能使用大括号对其整体赋值，除此以外不能对结构体变量进行整体赋值
结构体类型变量的再初始化的时候，不能跳跃式初始化，但是支持部分初始化，未被初始化的成员的值默认为0
结构体类型变量进行初始化的时候，成员的值，需要使用逗号隔开
结构体变量与变量之间可以进行整体赋值，数组与数组之间不能整体赋值

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[15];   //姓名 
   int score[2];    //成绩
   int num;       //学号
   struct BIR t;
};

   struct NOM a = {“张三”,89,90,1103,{1990,12}};  
   //结构体出现嵌套的时候，进行初始化可以加大括号分开，也可以不用加大括号分开
  // struct NOM a = {“张三”,89,90,1103,1990,12}; //第二种初始化方式 
 //struct NOM a = {“张三”,89,90,1103};  //部分初始化 
struct NOM b = a;

printf("%s %d %d %d %d %d\n",b.name,b.score[0],b.score[1],b.num,							   b.t.year,b.t.month);

结构体类型变量的赋值

给结构体变量赋值的时候，需要通过结构体变量名引用成员的方式对成员进行一一赋值，在赋值时候需要注意成员本身的特性，有的成员不支持整体赋值，此时就需要换一种方式
struct NOM a;
a.acore[2] = {11,34}; //不符合数组的定义
a.score[0] = 11 , a.score[1] = 32;
结构体变量先定义，后赋值，不能整体赋值

#include <stdio.h>

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[15];   //姓名
   int score[2];    //成绩
   int num;       //学号
   struct BIR t;
};


int main()
{
	// struct NOM a = {"张三",89,90,1103,1990,12}; //第二种初始化方式
    struct NOM a = {"张三",89,90,1103};  //部分初始化
	struct NOM b = a;   //结构体变量之间的赋值

	printf("%s %d %d %d %d %d\n",b.name,b.score[0],b.score[1],b.num,
							   b.t.year,b.t.month);
	struct NOM c;

	c.score[0] = 86;
	c.score[1] = 78;
	c.num = 1107;
	//c.t = {1789,10};  //结构体类型的成员不能整体赋值
	c.t.year = 1789;
    c.t.month = 10;
    //c.name = "李思";  //数组不能整体赋值
    //终端输入
    //gets(c.name);
    //字符串拷贝函数
	strcpy(c.name,"zhang san");

	printf("%s %d %d %d %d %d\n",c.name,c.score[0],c.score[1],c.num,
							   c.t.year,c.t.month);

    //结构体变量的值，终端输入，数据输入到结构体变量的成员
    struct NOM d;

	scanf("%s %d %d %d %d %d",d.name,&d.score[0],&d.score[1],&d.num,
							   &d.t.year,&d.t.month);

    printf("----------------------------------------------\n");
	printf("%s %d %d %d %d %d\n",d.name,d.score[0],d.score[1],d.num,
							   d.t.year,d.t.month);

}

结构体变量引用成员的方式

给结构体变量的赋值，实际上是给结构体变量的成员进行赋值，如果要使用结构体变量的值，需要通过结构体变量名引用成员们的方式，得到成员值
 	
结构体变量引用成员的方式：
结构体变量名.成员名
  如果结构体中出现嵌套的结构体，需要一层一层的进入，一层一个.
   
a.name
b.num
a.score[0]
a.score[1]
a.t.year  a.t.month

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[15];   //姓名
   int score[2];    //成绩
   int num;       //学号
   struct BIR t;
};

举个栗子
定义三个结构体变量，一个变量初始化，一个变量先定义后赋值。一个变量终端输入，打印学号最大的这个人的所有信息

扫描二维码关注公众号，回复： 9548893 查看本文章

#include <stdio.h>

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[15];   //姓名
   int score[2];    //成绩
   int num;         //学号
   struct BIR t;
};
int main()
{
	struct NOM a = {"张三",88,90,1102,2016,2};
	struct NOM b;
	struct NOM c;
	struct NOM max;

	//赋值：结构体变量名.成员 赋值
	strcpy(b.name, "李思");
	b.score[0] = 77;
	b.score[1] = 89;
	b.num = 1107;
	b.t.year = 2017;
	b.t.month = 10;

	//终端输入
	printf("请输入姓名\t 语文\t 数学\t 学号\t 年月：\n");
	scanf("%s %d %d %d %d %d",c.name,&c.score[0],&c.score[1],&c.num,
							  &c.t.year,&c.t.month);

	max = (a.num > b.num)?a:b;
	max = (max.num > c.num)?max:c;

	printf("学号最大的人的对应的信息为：\n");
	printf("姓名\t 语文\t 数学\t 学号\t 年\t 月\n");
	printf("%s\t %d\t %d\t %d\t %d\t %d\n",max.name,max.score[0],max.score[1],max.num,
							  max.t.year,max.t.month);
}

结构体数组的定义初始化赋值引用

结构体数组的定义跟结构体变量的定义方式一样
结构体数组的初始化，本质—>数组，只有在初始化的时候，才能使用大括号对结构体进行初始化，支持部分初始化，如果初始化，长度可以省略不写

//表示该数组有三个元素，每个元素的类型为结构体类型，包括成员
struct NOM a[3] = {
{“张三”},
{},
{},
}; //初始化数组中里面的括号可以省略不写，其目的只是为了区分元素

//结构体数组引用成员的方式：
数组名[下标].成员名

在进行赋值的时候，要注意成员本身的特性，有的成员不支持整体赋值

#include <stdio.h>

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[10];   //姓名    //15--->+1
   int score[2];    //成绩    //8--? 4+4
   int num;         //学号    //4
   struct BIR t;              //8
};
int main()
{
	struct NOM a[3] = {
						   {"zhangsan",88,90,1101,2017,8},
						   {"zhoasi",89,90,1102,2018,7},
						   {"zhaosan",66,56,1103,2015,8}
						};
	 int i;

     //结构体数组的赋值,实际上给数组的元素的成员进行赋值
     //a[0]  a[1]  a[2]
     strcpy(a[0].name,"张三");
     a[0].t.year = 2018;   //*a
     a[1].score[0] = 100;  //*(a+1)
     a[2].num = 1106;
     a[2].score[1] = 100;  //*(a+2)

      //终端输入
	 for(i = 0; i < 3; i++)
	 {
	 	scanf("%s %d %d %d %d %d",a[i].name,&a[i].score[0],&a[i].score[1],&a[i].num,
							  &a[i].t.year,&a[i].t.month);
	 }

     //打印
     for(i = 0; i < 3; i++)
	 {
	 	printf("%s %d %d %d %d %d\n",a[i].name,a[i].score[0],a[i].score[1],a[i].num,
							  a[i].t.year,a[i].t.month);
	 }
}

结构体指针的定义初始化赋值引用

结构体指针的定义跟结构体变量的定义方式一样
结构体指针的初始化，------>指针
指针指向结构体变量，指针指向结构体数组
结构体指针的引用成员，得到成员的值
指针名->成员
(指针名).成员名
结构体指针指向数组
(指针名+下标)->成员
((指针名+下标)).成员名

初始化
结构体类型指针 = &结构体变量名
结构体类型指针 = 结构体数组名

#include <stdio.h>

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[10];   //姓名    //15--->+1
   int score[2];    //成绩    //8--? 4+4
   int num;         //学号    //4
   struct BIR t;              //8
};
int main()
{

	struct NOM a = {"张三",88,90,1102,2016,2};
	struct NOM b;
	struct NOM c;
	struct NOM max;
	struct NOM *pb = &b;   //结构体指针指向结构体变量b


	//赋值：结构体变量名.成员 赋值
	//strcpy(b.name, "李思");
	strcpy(pb->name,"lisi");  //strcpy((*pb).name,"lisi");
	//b.score[0] = 77;
	(*pb).score[0] = 77;
	//b.score[1] = 89;
	 pb->score[1] = 89;
	//b.num = 1107;
	pb->num = 1107;
	//b.t.year = 2017;
	  (*pb).t.year = 2017;
	//b.t.month = 10;
	  pb->t.month = 10;

	//终端输入

	pb = &c;   //结构体指针指向结构体变量C
	printf("请输入姓名\t 语文\t 数学\t 学号\t 年月：\n");
	scanf("%s %d %d %d %d %d",pb->name,&pb->score[0],&pb->score[1],&pb->num,
							  &pb->t.year,&pb->t.month);



	max = (a.num > b.num)?a:b;
	max = (max.num > c.num)?max:c;


    pb = &max;  //结构体指针指向结构体变量max

	printf("学号最大的人的对应的信息为：\n");
	printf("姓名\t 语文\t 数学\t 学号\t 年\t 月\n");
	printf("%s\t %d\t %d\t %d\t %d\t %d\n",(*pb).name,(*pb).score[0],(*pb).score[1],(*pb).num,
							  (*pb).t.year,(*pb).t.month);
}

结构体指针指向结构体数组

#include <stdio.h>

struct BIR
{
   int year;
   int month;
};

struct NOM
{
   char name[10];   //姓名    //15--->+1
   int score[2];    //成绩    //8--? 4+4
   int num;         //学号    //4
   struct BIR t;              //8
};
int main()
{
	struct NOM a[3] = {
						   {"zhangsan",88,90,1101,2017,8},
						   {"zhoasi",89,90,1102,2018,7},
						   {"zhaosan",66,56,1103,2015,8}
						};
	 int i;
    struct NOM *p = a;    //数组名是数组首元素地址，
						  //结构体指针指向结构体数组首元素的地址，其指针可以当成数组名
                          //p+i 表示元素 a+i == &a[i]

     //结构体数组的赋值,实际上给数组的元素的成员进行赋值
     //a[0]  a[1]  a[2]
      //strcpy(a[0].name,"张三");
	 strcpy(p[0].name,"张三");

	  //a[0].t.year = 2018;   //*a
	  (p+0)->t.year = 2018;

    // a[1].score[0] = 100;  //*(a+1)
      (*(p+1)).score[0] = 100;

    // a[2].num = 1106;
	  (p+2)->num = 1106;
      (*(p+2)).score[1] = 100;  //*(a+2)



      //终端输入
	 for(i = 0; i < 3; i++)
	 {
	 	scanf("%s %d %d %d %d %d",(p+i)->name,&(p+i)->score[0],&(p+i)->score[1],&(p+i)->num,
							  &(p+i)->t.year,&(p+i)->t.month);
	 }

     //打印
     for(i = 0; i < 3; i++)
	 {
	 	printf("%s %d %d %d %d %d\n",(*(p+i)).name,(*(p+i)).score[0],(*(p+i)).score[1],(*(p+i)).num,
							 (*(p+i)).t.year,(*(p+i)).t.month);
	 }
}

CsData

发布了65 篇原创文章 · 获赞 36 · 访问量 5万+

私信关注