九、C++结构体（1）

一、结构体概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

二、结构体定义和使用

语法：

struct 结构体名 {结构体成员列表};

通过结构体创建变量的方式有三种：

1、struct 结构体名?变量名
2、struct 结构体名?变量名 = {成员1值,成员2值};
3、定义结构体时顺便创建变量

#include<iostream>
#include<string.h>
using namespace std;

//结构体定义
//1、创建学生数据类型：学生包括（姓名，年龄，分数）
//本质是一些类型的集合
struct Student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;

}stu3;	//末尾的s3是第三种创建结构体变量的方法

//2、通过学生类型创建具体的学生

int main()
{
	//2.1 struct Student s1
	struct Student stu1;
	//给s1属性赋值，通过.访问结构体变量中的属性
	stu1.name = "张三";
	stu1.age = 18;
	stu1.score = 100;

	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age << " 分数：" << stu1.score << endl;

	//2.2 struct Student s2={...}
	struct Student stu2 = { "李四",19,80 };
	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age << " 分数：" << stu2.score << endl;

	//2.3 在定义结构体时顺便创建结构体变量
	stu3.name = "王五";
	stu3.age = 20;
	stu3.score = 99;
	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age << " 分数：" << stu3.score << endl;

	system("pause");
	return 0;
}

运行结果：

姓名：张三 年龄：18 分数：100
姓名：李四 年龄：19 分数：80
姓名：王五 年龄：20 分数：99

注：第一种和第二种定义方式使用较多

三、结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法：

struct 结构体名 数组名[元素个数]={ {},{},...,{}}

#include<iostream>
#include<string.h>
using namespace std;
//结构体数组
//1、创建结构体
struct Student {
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

int main()
{
	//2、创建结构体数组
	struct Student stuArry[3] = {
		{"张三",18,90},
		{"李四",20,100},
		{"王五",23,99}
	};

	//3、给结构体数组中的元素赋值
	//可以用来修改数组元素内容
	stuArry[2].name = "赵六";
	stuArry[2].age = 33;
	stuArry[2].score = 90;

	//4、遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArry[i].name << "年龄：" << stuArry[i].age << "分数：" << stuArry[i].score << endl;
	}

	system("pause");
	return 0;
}

运行结果：

姓名：张三年龄：18分数：90
姓名：李四年龄：20分数：100
姓名：赵六年龄：33分数：90

四、结构体指针

作用：通过指针访问结构体中的成员

利用操作符->可以通过结构体指针访问结构体属性

#include<iostream>
#include<string.h>
using namespace std;
//结构体指针
struct Student {

	string name;	//姓名
	int age;	//年龄
	int score;	//分数
};

int main()
{
	//1、创建学生结构体变量
	struct Student stu = { "张三",18,100 };

	//2、通过指针指向结构体变量
	struct Student * p = &stu;

	//3、通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要利用'->'
	cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;

	system("pause");
	return 0;
}

运行结果：

姓名：张三年龄：18分数：100

五、结构体嵌套结构体

作用：结构体中的成员可以使另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

#include<iostream>
#include<string.h>
using namespace std;

//定义学生结构体
struct student
{
	string name;
	int age;
	int score;
 };

//定义老师结构体
struct teacher {
	int id;
	string name;
	int age;
	struct student stu;		//嵌套学生结构体，辅导的学生
};

int main()
{
	//结构体嵌套结构体
	//创建老师
	teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 50;

	t.stu.name = "小弟";
	t.stu.age = 20;
	t.stu.score = 60;
	cout << "老师的姓名：" << t.name << " 老师的编号：" << t.id << " 老师的年龄：" << t.age
		<< " 老师辅导的学生姓名：" << t.stu.name << " 老师辅导的学生年龄：" << t.stu.age
		<< " 老师辅导的学生分数：" << t.stu.score << endl;
system("pause");
return 0;
}

运行结果：

老师的姓名：老王 老师的编号：10000 老师的年龄：50 老师辅导的学生姓名：小弟 老师辅导的学生年龄：20 老师辅导的学生分数：60

六、结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式有两种：

• 值传递
• 地址传递

#include<iostream>
#include<string.h>
using namespace std;

struct student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
	cout << "子函数中 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}

//2、地址传递
void printStudent2(struct student* p)
{
	cout << "子函数2中 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}

int main()
{
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生身上的所有信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	//cout << "main函数中打印 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;

	printStudent1(s);	//值传递，调用函数，结构体s传递到printStudent1()函数中
	printStudent2(&s);		//地址传递，用指针接收地址

	system("pause");
	return 0;
}

1、值传递：函数中修改形参age的值，main函数中的age实参不会发生改变

#include<iostream>
#include<string.h>
using namespace std;

struct student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "子函数中 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}

//2、地址传递
void printStudent2(struct student* p)
{
	cout << "子函数2中 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}

int main()
{
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生身上的所有信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	printStudent1(s);	//值传递，调用函数，结构体s传递到printStudent1()函数中

    cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << "分数：" << s.score << endl;

	//printStudent2(&s);		//地址传递，用指针接收地址

	system("pause");
	return 0;
}

运行结果：

main函数中打印 姓名：张三 年龄：20分数：85
子函数中 姓名：张三 年龄：100 分数：85

2、地址传递：

#include<iostream>
#include<string.h>
using namespace std;

struct student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
	cout << "子函数中 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}

//2、地址传递
void printStudent2(struct student* p)
{
	p->age = 100;
	cout << "子函数2中 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}

int main()
{
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生身上的所有信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	//printStudent1(s);	//值传递，调用函数，结构体s传递到printStudent1()函数中
	printStudent2(&s);		//地址传递，用指针接收地址

	cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << "分数：" << s.score << endl;

	system("pause");
	return 0;
}

运行结果：

子函数2中 姓名：张三 年龄：100 分数：85
main函数中打印 姓名：张三 年龄：100分数：85

七、结构体中const使用场景

作用：用const来防止误操作

#include<iostream>
#include<string.h>
using namespace std;

//const的使用场景
struct student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//*s，将函数中的形参改为指针，可以减少内存空间，而且不会复制出新的副本出来
void printStudent(const struct student *s)	
{
	//s->age = 150;		//加上const之后，一旦有修改操作就会报错，可以防止误操作
	cout << "姓名：" << s->name << " 年龄：" << s->age << "分数：" << s->score << endl;
}

int main()
{	
	//创建结构体变量
	struct student s = { "张三",15,70 };

	//通过函数来打印结构体变量信息
	printStudent(&s);

	cout << "在main函数中张三的年龄为：" << s.age << endl;

	system("pause");
	return 0;
}

运行结果：

姓名：张三 年龄：15分数：70
在main函数中张三的年龄为：15