• C++笔记1（数组，冒泡排序，二维数组，函数，指针，结构体）

    C++

    一、数组

    1、数组特点

    • 数组每一个数据元素都是相同的数据类型
    • 数组是由连续的内存位置组成的

    2、一维数组定义的三种方式

    在这里插入图片描述

    #include<iostream>
using namespace std;
int main() {
	//1.第一种定义方式
	/*
	int arr[3];
	arr[0] = 1;
	arr[1] = 2;
	arr[2] = 3;
	for (int i = 0; i < 3; i++) {
		cout << arr[i] << endl;
	}
	*/

	//2.第二种定义方式
	/*int arr[3] = {1,2,3};
	for (int i = 0; i < 3; i++) {
		cout << arr[i] << endl;
	}*/

	int arr2[] = { 5,6,7,8,9 };
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
		cout << arr2[i] << endl;
	}
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    3、一维数组数组名用途

    • 可以统计整个数组在内存中的长度
    • 可以获取数组在内存中的首地址
    #include<iostream>
using namespace std;
int main() {
	//数组名用途
	//1.可以获取整个数组占用的内存空间大小
	int arr[5] = { 5,6,7,8,9 };
	cout << "整个数组所占空间的大小为：" << sizeof(arr) << endl;
	cout << "每个元素所占空间的大小为：" << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为：" << sizeof(arr) / sizeof(arr[0]) << endl;

	//2.可以通过数组名获取到数组首地址
	cout << "数组首地址" << (int)arr << endl;
	//&为取址符号，（int）是强转为十进制
	cout << "数组中第一个元素地址" << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址" << (int)&arr[1] << endl;

	//注意：arr = 100;错误，数组名是常量，因此不可以赋值

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    4、案例：五只小猪称体重

    在这里插入图片描述

    #include<iostream>
using namespace std;
//思路：访问每一个元素，如果这个元素比我自己创建的最大值要大，更新最大值
int main() {
	//创建每个小猪体重的数组
	int arr[5] = { 300,350,200,400,250 };
	//从数组中找到最大值
	int max = 0;
	for (int i = 0; i < 5; i++) {
	//如果访问的数组中的元素比我认定的最大值还要大，更新最大值
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	cout << "最重的小猪体重为：" << max;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    5、 案例：数组元素逆置

    在这里插入图片描述

    #include<iostream>
using namespace std;
int main() {
	//实现元素逆置

	int arr[5] = { 1,3,2,4,5 };
	int start = 0;//起始下标的位置
	int end = sizeof(arr) / sizeof(arr[0]) - 1;

	while (start < end)
	{
		//实现元素互换
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		//下标更新
		start++;
		end--;
	}
	cout << "数组逆置后的元素" << endl;
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << endl;
	}

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    二、冒泡排序

    一、

    1. 最常用的排序方法，对数组内元素进行排序
    2. 规则：比较相邻的元素，如果第一个比第二个大，就交换他们两个
    3. 对每一组相邻元素做同样的工作，执行完毕后，找到第一个最大值
    4. 重复以上的步骤，每次比较次数减1，直到不能再比较

    二、规律

    • 排序总轮数 = 元素个数 - 1
    • 每轮对比次数 = 元素个数 - 排序轮数 - 1

    在这里插入图片描述

    #include<iostream>
using namespace std;
int main() {
	int arr[] = { 4,2,8,0,5,7,1,3,9 };
	//开始冒泡排序
	//排序总轮数  = 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++) {
          //内层循环对比
		//每轮对比次数 =  元素个数 - 排序轮数 - 1
		for (int j = 0; j < 9 - i - 1; j++) {
			//如果第一个数字比第二个数字大，交换两个数字
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	cout << "排序后：" << endl;
	for (int i = 0; i < 9; i++) {
		cout << arr[i] << " ";
	}
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    三、二维数组

    1、二维数组的定义方式

    在这里插入图片描述

    2、二维数组的数组名

    • 查看二维数组所占内存空间
    • 获取二维数组首地址
    #include<iostream>
using namespace std;
int main() {
	int arr[2][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			cout << arr[i][j]<<" ";
		}
		cout << endl;
	}
	cout << "整个数组的大小：" << sizeof(arr)<<endl;
	cout << "第一行数组的大小：" << sizeof(arr[0]) << endl;
	cout << "第一个数组的大小：" << sizeof(arr[0][0]) << endl;
	cout << "行数：" << sizeof(arr)/sizeof(arr[0]) << endl;
	cout << "列数：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
	cout << "二维数组的首地址：" << (int)arr<<endl;
	cout << "二维数组的第一行首地址：" << (int)arr[0] << endl;
	cout << "二维数组的第二行首地址：" << (int)arr[1] << endl;
	cout << "二维数组的第一个元素首地址：" << (int)&arr[0][0] << endl;//利用取地址符号

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    3、案例

    在这里插入图片描述

    //循环思想和利用循环做计算很重要
#include<iostream>
#include<string>
using namespace std;
int main() {
	//张三：100 100 100，李四：90 50 100，王五：60，70，80
	//计算每个人的总分

	int scores[3][3] = { {100,100,100},{90,50,40},{60,70,80} };
	string names[3] = { "张三","李四","王五" };
	for (int i = 0; i < 3; i++) {
		int sum = 0;
		for (int j = 0; j < 3; j++) {
			sum += scores[i][j];
		}
		cout << names[i]<<"的分数是："<<sum << endl;
	}

	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    四、函数

    1、作用

    • 将一段经常使用的代码封装在一起，减少重复代码，一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

    2、定义

    在这里插入图片描述
    在这里插入图片描述

    //定义一个加法函数
int add(int a,int b){
int sum = a+b;
return sum;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    3、值传递

    • 函数调用时实参将数值传入给形参
    • 值传递时，如果形参发生改变，并不会影响实参
    #include<iostream>
using namespace std;
void swap(int num1,int num2){
int temp = num1;
num1 = num2;
num2 = temp;
}
int main(){
int a = 10;
int b = 20;
//当我们做值传递的时候，函数的形参发生变化，并不会影响实参
swap(a,b);
//a,b还是10，20
return 0;}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    4、常见样式

    • 无参无返
    • 有参无返
    • 无参有返
    • 有参有返

    5、函数声明

    • 声明可以多次，定义只能一次
    int max(int a,int b);//函数声明

int main(){
int a = 100;int b  = 200;
cout << max(a,b);
return 0;}
//利用函数声明可以将函数定义写在main方法的后面
int max(int a,int b){
return a > b ? a : b;}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    6、函数的分文件编写

    1. 作用：让代码结构更加的清晰
    2. 编写的步骤：在这里插入图片描述
      在这里插入图片描述
    //swap.h
#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);


//swap.cpp
#include"swap.h"
//函数的定义
void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	cout << "a=" << a<<endl;
	cout << "b=" << b << endl;
}


//函数的分文件编写.cpp
#include<iostream>
using namespace std;
#include"swap.h"
int main() {
	int a = 20;
	int b = 30;
	swap(a, b);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    五、指针

    1、基本概念及作用

    • 作用：可以通过指针间接访问内存
    • 内存编号是从0开始记录的，一般用十六进制的数组表示
    • 可以利用指针变量保存地址

    2、定义和使用

    • 数据类型 * 变量名
    #include<iostream>
using namespace std;
int main() {
	//1.定义指针
	int a = 10;
	int* p;
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	*p = 1000;//解引用
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    3、指针所占内存空间

    • 在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
    • 在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型
    int a = 10;
int *p = &a;
cout<<sizeof(int *)<<endl;
cout<<sizeof(fioat *)<<endl;
cout<<sizeof(double *)<<endl;
cout<<sizeof(char *)<<endl;


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4、空指针

    1.空指针：指针变量向内存中编号为0的空间
    2.用途：初始化指针变量
    3.注意：空指针指向的内存是不可以访问的

    
#include<iostream>
using namespace std;
int main() {
	//指针变量p指向的内存地址编号为0的空间
	int* p = NULL;
	//访问空指针报错
	//内存编号为0~255为系统占用内存，不允许用户访问
	cout << *p << endl;
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5、野指针

    • 指针变量指向非法的内存空间
    • 总结：空指针和野指针都不是我们申请的空间，因此不要访问
    #include<iostream>
using namespace std;
int main() {
	//指针变量p指向内存地址编号为0x1100的空间
	int* p = (int*)0x1100;
	//访问野指针报错
	cout << *p << endl;
	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    6、const修饰指针

    1. const修饰指针——常量指针
    2. const修饰常量——指针常量
    3. const既修饰指针，又修饰常量
    #include<iostream>
using namespace std;
int main() {
	//指针的指向指的是改变地址值

	//1.const修饰指针（常量指针）
	int a = 10;
	int b = 10;
	const int* p = &a;
	//指针指向的值不能通过指针改变，但可以通过变量自身改变，指针的指向可以改变
	//*p = 20;//错误
	p = &b;//正确


	//2.const修饰常量(指针常量)
	//指针指向不可以改，指针指向的值可以通过指针更改_
	int* const p2 = &a;
	*p2 = 100;//正确
	//p2 = &b;错误


	//3.const既修饰指针又修饰常量
	const int* const p3 = &a;
	//指针的指向和指针指向的值都不可以改
	//*p3 = 100;//错误
	//p3 = &b;//错误
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    7、指针和数组

    • 作用：利用指针访问数组中的元素
    #include<iostream>
using namespace std;
int main() {
	//利用指针访问数组中的元素
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int* p = arr;//*p是数组第一个元素
	for (int i = 0; i < 10; i++) {
		cout << *(p + i)<<" ";
	}
	cout << endl << "或者" << endl;
	//或者
	for (int i = 0; i < 10; i++) {
		cout << *p << " ";
		p++;
	}

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    8、指针和函数

    • 作用：利用指针作函数参数，可以修改实参的值
    • 总结：如果想改变实参就用地址传递，不想就用值传递
    #include<iostream>
using namespace std;
//交换两个数（值传递）
void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
//交换两个数（地址传递）
void swap2(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	int num1 = 20;
	int num2 = 30;
	swap(num1, num2);

	swap2(&num1, &num2);
	cout << num1 << " " << num2;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    9、指针配合数组和函数案例

    • 案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
    #include<iostream>
using namespace std;
//案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
//冒泡排序的函数
//参数一：数组首地址，参数二：数组长度
void bubbleSort(int* arr, int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int* arr, int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i]<<" ";
	}
}

int main() {
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	bubbleSort(arr, 10);
	printArray(arr, 10);
		return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    六、结构体

    1、基本概念

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

    2、定义和使用

    • 语法：struct 结构体名{ 结构体成员列表 }；
    • 创建变量的三种方式：在这里插入图片描述方式一和方式二用的比较多
    • 总结：在这里插入图片描述
    #include<iostream>
using namespace std;
#include<string>//新版2022可以不用

struct Student {
	string name;
	int age;
	int score;
}s3;

int main() {
	//通过学生类型创建具体学生

	//方法一：struct Student s1
	//struct Student s1;
	//省略形式
	Student s1;

	//给s1属性赋值，通过.访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score;
	
	cout << endl;
	//方法二：struct Student s2 = {……}
	struct Student s2 = { "李四", 19, 80 };
	cout << "姓名：" << s2.name << "年龄：" << s2.age << "分数：" << s2.score;

	cout << endl;
	//方式三：在定义结构体的时候顺便创建结构体变量
	s3.name = "王五";
	s3.age = 16;
	s3.score = 80;
	cout << "姓名：" << s3.name << "年龄：" << s3.age << "分数：" << s3.score;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    3、结构体数组

    • 作用：将自定义的结构体放入到数组中方便维护
    • 语法： struct 结构体名 数组名[元素个数] = { { }，{ }，…{ } }
    #include<iostream>
using namespace std;
struct Student {
	string name;
	int age;
	int score;
};
int main() {
	struct Student stuArr[3] = {
		{"张三",18,100},
	     {"李四",28,99},
		{"王五",38,66}
	};

	stuArr[2].age = 22;
	stuArr[2].name = "赵六";
	stuArr[2].score = 55;


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


	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    4、结构体指针

    • 作用：通过指针访问结构体的成员
    • 利用操作符 -> 可以通过结构体指针访问结构体属性
    #include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};
int main() {
	//1.创建结构体变量
	struct student s = { "张三", 18 ,66 };

	//2.通过指针指向结构体变量
	
	student* p = &s;

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    5、结构体嵌套结构体

    • 作用：结构体中的成员可以是另一个结构体
    • 例如：每一个老师辅导一个学员，一个老师的结构体中，记录每一个学生的结构体
    #include<iostream>
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 = 18;
	t.stu.score = 88;
	cout << "老师姓名： " << t.name << " 老师编号： " << t.id << " 老师年龄： " << t.age
		<< " 老师辅导的学生姓名： " << t.stu.name << " 学生年龄： " << t.stu.age << " 学生分数: "
		<< t.stu.score;
	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    6、结构体做函数参数

    • 作用：将结构体作为参数向函数中传递
    • 传递方式：（1）值传递（2）地址传递
    • 总结： 如果你不想修改主函数的数据，用值传递，返之用地址传递
    #include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};

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


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

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

	student s;
	s.age = 18;
	s.name = "张胜男";
	s.score = 44;
	//printStudent(s);
	printStudent2(&s);
	cout << "main函数打印 姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score;

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    7、结构体中const的使用场景

    • 作用： 用const来防止误操作
    #include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
//void printStudent(student s) 
void printStudent( const student* s)
{//加入const之后，一旦有修改的操作就会报错，可以防止误操作
	//s->age = 100;报错
	cout << "姓名：" << s->name << "  年龄：" << s->age << " 分数：" << s->score<<endl;
}
int main() {
	struct student s = { "张三",15 ,70 };
	printStudent(&s);
	//通过函数来打印结构体的变量信息

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    8、结构体案例1

    在这里插入图片描述

    #include<iostream>
using namespace std;
struct student {
	string name;
	int score;
};
struct teacher {
	string tName;
	struct student sArr[5];
};

//给老师和学生赋值的函数
//参数也可以用指针
void allocateSpace(struct teacher tArr[], int len) {
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for (int i = 0;i<len;i++){
		tArr[i].tName = "Teacher_";
		tArr[i].tName += nameSeed[i];

		//通过循环给每名老师所带的学生赋值
		for (int j = 0; j < 5; j++) {
			tArr[i].sArr[j].name = "Student_";
			tArr[i].sArr[j].name += nameSeed[j];
			int ran = rand() % 61+40;//40~100分
			tArr[i].sArr[j].score = ran;

		}
	}
}

//打印所有的信息
void printInfo(struct teacher tArr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << "老师姓名：" << tArr[i].tName << endl;
		for (int j = 0; j < 5; j++) {
			cout << "\t学生姓名：" << tArr[i].sArr[j].name
				<< "考试分数：" << tArr[i].sArr[j].score<<endl;

		}
	}
}
int main() {
	//随机数种子
	srand((unsigned int)time(NULL));
	 teacher tArr[3];
	 allocateSpace(tArr, 3);
	 printInfo(tArr, 3);

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    9、结构体案例2

    在这里插入图片描述

    #include<iostream>
using namespace std;
struct hero {
	string name;
	int age;
	string sex;
};
//冒泡排序 实现年龄升序排序
void bubbleSort(struct hero heroArr[], int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {
			//如果j下标的年龄大于j+1的，就交换
			if (heroArr[j].age > heroArr[j + 1].age) {
				struct hero temp = heroArr[j];//用struct型的temp
				heroArr[j] = heroArr[j + 1];
				heroArr[j + 1] = temp;
			}
		}
	}
}
void print(struct hero heroArr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << "  姓名：" << heroArr[i].name << "  年龄：" << heroArr[i].age << "  性别：" << heroArr[i].sex << endl;
	}
}
	int main(){
		struct hero heroArr[5] = {
			{"刘备",23,"男"},
			{"关煜",22,"男"},
			{"张飞",20,"男"},
			{"赵云",21,"男"},
			{"貂蝉",19,"女"}
		};
		bubbleSort(heroArr, 5);
		print(heroArr, 5);
		return 0;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
  • 相关阅读:
    Java实现递归查询树结构
    element + vue3，级联选择器实现省市区
    Java转义工具类StringEscapeUtils的学习笔记
    LeetCode 1052. 爱生气的书店老板
    物联网智能互联创新开发平台
    跟艾文学编程《Python基础》PyCharm 安装
    shell 脚本数值运算
    南卡护眼灯和好视力护眼灯哪个好?深度测试对比两款护眼台灯
    Python基础知识入门（二）
    17 【2D转换 3D转换 浏览器私有前缀】
  • 原文地址：https://blog.csdn.net/weixin_60440795/article/details/125526030