C++基础学习笔记(二)——基础入门PART2

参考链接:https://www.bilibili.com/video/BV1et411b73Z?p=42&vd_source=b4d9cee68649c8adcb1e266f7147cd5c

一、数组

一个集合中,里面存放了相同类型的数据元素

特点1:数组中的每个数据元素都是相同的数据类型
特点2:数组是由连续的内存位置组成的

1.1 一维数组

一维数组定义的三种方式:

  1. 数据类型 数组名[ 数组长度 ];
  2. 数据类型 数组名[ 数组长度 ] = { 值1,值2 …};
  3. 数据类型 数组名[ ] = { 值1,值2 …};

注:第二种定义方式,如果没有给值完全,剩余的用0填充

demo1:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int main()
{
	//数组:第一种
	int arr[5];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	cout << arr[0] << endl;

	//数组:第二种
	int arr2[5] = { 10,20,30,40,50 };

	cout << arr2[0] << endl;
	for(int i=0;i<5;i++)
	{
		cout << arr2[i] << endl;
	}
	
	//数组:第三种
	int arr3[] = { 90,80,70,60,50,40,30,20,10};



	return 0;
}
10
10
10
20
30
40
50

一维数组名称的用途:

  1. 可以统计整个数组在内存中的长度
  2. 可以获取数组在内存中的首地址

demo2

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int main()
{
	//数组名用途
//1、可以获取整个数组占用内存空间大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "整个数组所占内存空间为: " << sizeof(arr) << endl;
	cout << "每个元素所占内存空间为: " << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为: " << sizeof(arr) / sizeof(arr[0]) << endl;
	//2、可以通过数组名获取到数组首地址
	cout << "数组首地址为: " << (int)arr << endl;
	cout << "数组中第一个元素地址为: " << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为: " << (int)&arr[1] << endl;
	//arr = 100; 错误,数组名是常量,因此不可以赋值


	return 0;
}
整个数组所占内存空间为: 40
每个元素所占内存空间为: 4
数组的元素个数为: 10
数组首地址为: 7928228
数组中第一个元素地址为: 7928228
数组中第二个元素地址为: 7928232

注意:数组名是常量,不可以赋值
总结1:直接打印数组名,可以查看数组所占内存的首地址
总结2:对数组名进行sizeof,可以获取整个数组占内存空间的大小

demo3:

五只小猪称体重
案例描述:
在一个数组中记录了五只小猪的体重,如:int arr[5] = {300,350,200,400,250};
找出并打印最重的小猪体重。

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int main()
{
	int arr[5] = { 300,350,200,400,250};
	int max = 0;

	for (int i = 0; i < 5; i++)
	{
		/*
				if (max < arr[i])
		{
			max = arr[i];
		}
		else
		{
			max = max;
		}
		*/

		max = (arr[i] > max) ? arr[i] : max;

	}

	cout << "最肥的一只小猪体重为:" << max << endl;

	return 0;
}

输出:

最肥的一只小猪体重为:400

数组元素逆置

案例描述:请声明一个5个元素的数组,并且将元素逆置.
(如原数组元素为:1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

demo4:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int main()
{
	int arr[5] = {1,3,2,5,4};
	int start = 0;
	int end = sizeof(arr) / sizeof(arr[0]) - 1;
	int temp = 0;


	cout << "逆序前的数组为:" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;

	}

	while (start < end)
	{
		temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;

		start++;
		end--;
	}

	cout << "逆序后的数组为:" << endl;
	for (int j = 0; j < 5; j++)
	{
		cout << arr[j] << endl;

	}

	return 0;
}
逆序前的数组为:
1
3
2
5
4
逆序后的数组为:
4
5
2
3
1

冒泡排序

作用: 最常用的排序算法,对数组内元素进行排序

  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  2. 对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值。
  3. 重复以上的步骤,每次比较次数-1,直到不需要比较

(最大值像泡泡一样从最右边冒出来)

demo5:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


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

	int L = sizeof(arr) / sizeof(arr[0]);

	cout << "排序前的数组:" << endl;
	for (int i = 0; i < L; i++)
	{
		cout << arr[i] << endl;
	}

	for (int i = 0; i < L - 1; i++)
	{
		for (int j = 0; j < L - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
			else
			{
				arr[j] = arr[j];
				arr[j + 1] = arr[j + 1];
			}
		}
	}


	cout << "排序后的数组:" << endl;
	for (int i = 0; i < L; i++)
	{
		cout << arr[i] << endl;
	}

	return 0;
}

排序前的数组:
4
2
8
0
5
7
1
3
9
排序后的数组:
0
1
2
3
4
5
7
8
9

1.2 二维数组

二维数组定义的四种方式:

  1. 数据类型 数组名[ 行数 ][ 列数 ];
  2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1,数据2 } ,{数据3,数据4 } };
  3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1,数据2,数据3,数据4};
  4. 数据类型 数组名[ ][ 列数 ] = { 数据1,数据2,数据3,数据4};
    建议:以上4种定义方式,利用第二种更加直观,提高代码的可读性

统计每一位学生的总成绩
demo6:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int main()
{
	int arr[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};

	/*

	int row = sizeof(arr) / sizeof(arr[0]);
	int col = sizeof(arr[0]) / sizeof(arr[0][0]);


	int sum1 = 0;
	int sum2 = 0;
	int sum3 = 0;

	for (int i = 0; i < row; i++)
	{

		for (int j = 0; j < col; j++)
		{
			if (i == 0)
			{
				sum1 = sum1 + arr[i][j];
			}
			else if (i == 1)
			{
				sum2 = sum2 + arr[i][j];
			}
			else
			{
				sum3 = sum3 + arr[i][j];
			}
		}


	}


	cout<<"第一个学生的总成绩:" << sum1 << endl;
	cout << "第二个学生的总成绩:" << sum2 << endl;
	cout << "第三个学生的总成绩:" << sum3 << endl;
		*/


	int row = sizeof(arr) / sizeof(arr[0]);
	int col = sizeof(arr[0]) / sizeof(arr[0][0]);


	int sum[] = { 0,0,0 };

	for (int i = 0; i < row; i++)
	{

		for (int j = 0; j < col; j++)
		{
			sum[i] += arr[i][j];

		}
	}

	cout << "第一个学生的总成绩:" << sum[0] << endl;
	cout << "第二个学生的总成绩:" << sum[1] << endl;
	cout << "第三个学生的总成绩:" << sum[2] << endl;


	return 0;
}
第一个学生的总成绩:300
第二个学生的总成绩:240
第三个学生的总成绩:210

二、函数

2.1 函数定义

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

函数的定义一般主要有5个步骤:
1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、return 表达式

返回值类型 函数名 (参数列表)
{
函数体语句
return表达式
}

demo7:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


int add(int num1, int num2)//定义中的num1,num2称为形式参数,简称形参
{
	int sum = num1 + num2;

	return sum;
}


int main()
{
	int a = 10;
	int b = 20;
	int c = add(a, b);//调用时的a,b称为实际参数,简称实参

	cout << c << endl;


	return 0;
}
30

2.2 值传递

所谓值传递,就是函数调用时实参将数值传入给形参
值传递时,如果形参发生,并不会影响实参

demo8:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


void swap(int num1, int num2)
{
	cout << "交换前:" << endl;
	cout << "num1= " << num1 << endl;
	cout << "num2= " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后:" << endl;
	cout << "num1= " << num1 << endl;
	cout << "num2= " << num2 << endl;
}



int main()
{
	int a = 10;
	int b = 20;
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;


	swap(a, b);

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;


	return 0;
}
a= 10
b= 20
交换前:
num1= 10
num2= 20
交换后:
num1= 20
num2= 10
a= 10
b= 20

2.3 函数样式

常见的函数样式有4种

  1. 无参无返
  2. 有参无返
  3. 无参有返
  4. 有参有返

demo9:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


//无参无返
void test01()
{
	cout << "This is test01" << endl;
}

//有参无返
void test02(int a)
{
	cout << "This is test02 a = " << a << endl;
}

//无参有返
int test03()
{
	cout << "This is test03" << endl;
	return 1000;
}

//有参有返
int test04(int a)
{
	cout << "This is test04 a = " << a << endl;

	return a;
}

int main()
{
	//无参无返函数调用
	test01();
	//有参无返函数调用
	int aa = 2;
	test02(aa);
	//无参有返函数调用
	int num1 = test03();
	cout << "num1= " << num1 << endl;
	//有参有返函数调用
	int num2 = test04(10000);
	cout << "num2= " << num2 << endl;

	return 0;
}
This is test01
This is test02 a = 2
This is test03
num1= 1000
This is test04 a = 10000
num2= 10000

2.4 函数声明

作用: 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数的声明可以多次,但是函数的定义只能有一次

demo10:

//声明可以多次,定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
return a > b ? a : b;
}
int main() {
	int a = 100;
	int b = 200;
	cout << max(a, b) << endl;
	system("pause");
	return 0;
}

2.5 函数的分文件编写

作用:让代码结构更加清晰
函数分文件编写一般有4个步骤

  1. 创建后缀名为.h的头文件
  2. 创建后缀名为.cpp的源文件
  3. 在头文件中写函数的声明
  4. 在源文件中写函数的定义

demo11:

//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;
}
//main函数文件
#include "swap.h"
int main() {
int a = 100;
int b = 200;
swap(a, b);
system("pause");
return 0;
}

三、指针

3.1 定义及使用

指针的作用: 可以通过指针间接访问内存

内存编号是从0开始记录的,一般用十六进制数字表示

可以利用指针变量保存地址

指针变量定义语法: 数据类型 * 变量名;

demo12:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;




int main()
{
	//定义指针
	int a = 10;
	//指针语法
	int * p;
	//让指针记录变量a的地址
	p = &a;  //&为取址符

	cout << "a的地址为:" << &a << endl;
	cout << "指针p为:" << p << endl;

	//使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前面加*代表解引用,找到指针指向的内存中的数据
	*p = 1000;
	cout << "a= " << a << endl;
	cout << "*p = " << *p << endl;


	return 0;
}
a的地址为:0075FEC8
指针p为:0075FEC8
a= 1000
*p = 1000

3.2 指针所占的内存空间

所有指针类型在32位操作系统下是4个字节,64位下8个

注:即使是64位的操作系统,编译环境是32位的,输出仍是4

x86是32位,x64是64位
在这里插入图片描述

demo13:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;




int main()
{
	int a = 10;
	int* p = &a;

	cout << "sizeof (int *)= " << sizeof(int *) << endl;
	cout << "sizeof (float *)= " << sizeof(float *) << endl;
	cout << "sizeof (double *)= " << sizeof(double *) << endl;
	cout << "sizeof (char *)= " << sizeof(char *) << endl;

	return 0;
}

sizeof (int *)= 4
sizeof (float *)= 4
sizeof (double *)= 4
sizeof (char *)= 4

3.3 空指针和野指针

空指针 : 指针变量指向内存中编号为0的空间
用途:初始化指针变量(一开始不知道指到哪里好)
注意:空指针指向的内存是不可以访问的

demo14:

int main()
{

	//空指针
	int* p = NULL;
	//空指针不可以进行访问;0~255之间的内存编号是系统占用的,因此不可以访问
	// *p = 100;

	return 0;
}

野指针:指针变量指向非法的内存空间

在这里插入图片描述
demo15:

int main()
{

	//野指针
	//在程序中尽量避免野指针
	int* p = (int*)0x1100;

	cout << *p << endl;


	return 0;
}

3.4 const修饰指针

const修饰指针有三种情况

  1. const修饰指针 — 常量指针
  2. const修饰常量 — 指针常量
  3. const即修饰指针,又修饰常量

demo16:

int main() {
int a = 10;
int b = 10;
//const修饰的是指针,指针指向可以改,指针指向的值不可以更改
const int * p1 = &a;
p1 = &b; //正确
//*p1 = 100; 报错
//const修饰的是常量,指针指向不可以改,指针指向的值可以更改
int * const p2 = &a;
//p2 = &b; //错误
*p2 = 100; //正确
//const既修饰指针又修饰常量
const int * const p3 = &a;
//p3 = &b; //错误
//*p3 = 100; //错误
system("pause");
return 0;
}

技巧:看const右侧紧跟着的是指针还是常量, 是指针就是常量指针,是常量就是指针常量

3.5 指针和数组

作用:利用指针访问数组中元素

demo17:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;




int main()
{

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "第一个元素为:" << arr[0] << endl;

	int* p = arr;   //arr就是数组首地址

	cout << "利用指针访问第一个元素:" << *p << endl;

	p++;//让指针向后偏移4个字节

	cout << "利用指针访问第二个元素:" << *p << endl;

	cout << "利用指针遍历数组 " << endl;

	int* p2 = arr;

	for (int i = 0; i < 10; i++)
	{
		cout << *p2 << endl;
		p2++;
	}

	return 0;
}
第一个元素为:1
利用指针访问第一个元素:1
利用指针访问第二个元素:2
利用指针遍历数组
1
2
3
4
5
6
7
8
9
10

3.6 指针和函数

作用:利用指针作函数参数,可以修改实参的值

demo18:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "swap01 a= " << a << endl;
	cout << "swap01 b= " << b << endl;
}

void swap02(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}


int main()
{

	//值传递
	int a = 10;
	int b = 20;
	swap01(a, b);

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;

	//地址传递;可以修饰实参
	swap02(&a, &b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;

	return 0;
}
swap01 a= 20
swap01 b= 10
a= 10
b= 20
a= 20
b= 10

总结:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递

3.7 指针、数组、函数

案例描述:封装一个函数,利用冒泡排序,实现对整型数组的升序排序
例如数组:int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

demo19:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
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] << endl;
	}
		
}

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

	int len = sizeof(arr) / sizeof(arr[0]); //在BubbleSort函数内部无法算出数组长度

	BubbleSort(arr, len);

	printArray(arr, len);


	return 0;
}
1
2
3
4
5
6
7
8
9
10

总结:当数组名传入到函数作为参数时,被退化为指向首元素的指针

四、 结构体

4.1 结构体基本概念和定义使用

结构体属于用户自定义的数据类型,允许用户存储不同的数据类型(内置数据类型的集合)

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

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

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

demo20:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;




//创建学生类型:学生包括(姓名、年龄、分数)
//自定义数据类型,一些类型集合组成的一个类型
//语法 struct 类型名称 {成员列表}
struct Student
{

	//成员列表
	string name;
	int age;
	int score;
}s3;  //结构体变量创建方式1,顺便创建结构体变量

//通过学生类型创建具体学生
//1. struct student s1
//2. struct student s2={...}
//3.在定义结构体时顺便创建结构体变量

int main()
{
	//结构体变量创建方式1
	struct Student s1;
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;

	cout << "姓名: " << s1.name << " 年龄: " << s1.age << " 分数: " << s1.score << endl;

	//结构体变量创建方式2
	struct Student s2 = { "李四",19,80 };
	cout << "姓名: " << s2.name << " 年龄: " << s2.age << " 分数: " << s2.score << endl;

	//结构体变量创建方式3
	s3.name = "王五";
	s3.age = 20;
	s3.score = 60;
	cout << "姓名: " << s3.name << " 年龄: " << s3.age << " 分数: " << s3.score << endl;

	return 0;
}
姓名: 张三 年龄: 18 分数: 100
姓名: 李四 年龄: 19 分数: 80
姓名: 王五 年龄: 20 分数: 60

总结1:定义结构体时的关键字是struct,不可省略
总结2:创建结构体变量时,关键字struct可以省略
总结3:结构体变量利用操作符 ‘’.‘’ 访问成员

4.2 结构体数组

作用:将自定义的结构体放入到数组中方便维护
语法: struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }

demo21:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

//结构体数组

//1.定义结构体
struct Student
{
	string name;
	int age;
	int score;

};




int main()
{
	//2.创建结构体数组
	struct Student stuArray[3] =
	{
		{"张三", 18,100},
		{"李四", 28, 99},
		{"王五", 38, 66}
	};

	//3.给结构体数组中的元素赋值
	stuArray[2].name = "赵六";
	stuArray[2].age = 80;
	stuArray[2].score = 60;

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

	return 0;
}
 姓名: 张三 年龄: 18 分数: 100
 姓名: 李四 年龄: 28 分数: 99
 姓名: 赵六 年龄: 80 分数: 60

4.3 结构体指针

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

demo22:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

//结构体指针

//1.定义学生结构体
struct Student
{
	string name;
	int age;
	int score;

};




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

	//3.通过指针指向结构体变量
	struct Student* p = &s;

	//4.通过指针访问结构体变量中的数据

	cout << " 姓名: " << p->name 
		 << " 年龄: " << p->age 
		 << " 分数: " << p->score << endl;

	return 0;
}
 姓名: 张三 年龄: 18 分数: 100

总结:结构体指针可以通过 -> 操作符 来访问结构体中的成员

4.4 结构体嵌套结构体

作用: 结构体中的成员可以是另一个结构体
例如:每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体

demo23:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
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 << endl;

	return 0;
}
 老师姓名: 老王 老师编号: 10000 老师年龄: 50 老师辅导的学生姓名: 小王

4.5 结构体做函数参数

作用:将结构体作为参数向函数中传递
传递方式有两种:
值传递
地址传递

demo24:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



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

};

//值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "在子函数1中打印 姓名:" << s.name << " 年龄: " << s.age << " 分数: " << s.score << endl;
}
//地址传递
void printStudent2(struct student * p)
{
	p->age = 200;
	cout << "在子函数2中打印 姓名:" << p->name << " 年龄: " << p->age << " 分数: " << p->score << endl;
}



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

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

	//printStudent1(s);
	printStudent2(&s);
	cout << "在main函数中打印 姓名:" << s.name << " 年龄: " << s.age << " 分数: " <<s.score<< endl;


	return 0;
}

//值传递结果
在子函数1中打印 姓名:张三 年龄: 100 分数: 85
在main函数中打印 姓名:张三 年龄: 20 分数: 85
//地址传递结果
在子函数2中打印 姓名:张三 年龄: 200 分数: 85
在main函数中打印 姓名:张三 年龄: 200 分数: 85

4.6 结构体中 const使用场景

作用:用const来防止误操作

(虽然地址传递不用复制新的副本减少了内存,但也存在着可以修饰实参的问题)

在这里插入图片描述
demo25:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



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

};

//将函数中的形参改为指针,可以减少内存空间,而且不会复制新的出来
//但这种方式可以修饰实参
void printStudents(const struct student * p)
{
	//p->age = 150;  //加入const之后,一旦有修改的操作就会报错,可以防止我们的误操作
	cout << "姓名:" << p->name << " 年龄: " << p->age << " 分数: " << p->score << endl;
}


int main()
{


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


	printStudents(&s);
	cout << "在main函数中打印 姓名:" << s.name << " 年龄: " << s.age << " 分数: " <<s.score<< endl;


	return 0;
}
姓名:张三 年龄: 15 分数: 70
在main函数中打印 姓名:张三 年龄: 15 分数: 70

4.7 案例1

案例描述:
学校正在做毕设项目,每名老师带领5个学生,总共有3名老师,需求如下
设计学生和老师的结构体,其中在老师的结构体中,有老师姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数,创建数组存放3名老师,通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据。

demo26:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
#include<ctime>
using namespace std;




//定义学生结构体
struct Student
{
	string sName;
	int score;

};

//定义老师结构体
struct Teacher
{
	string tName;
	struct Student sArray[5]; //学生数组

};

void allocateSpace(struct Teacher tArray[], int len)
{
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for (int i = 0; i < len; i++)
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];

		//通过循环给每名老师所带的学生赋值
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[j];

			int random = rand() % 61 + 40; //(0~60)+40=40~100
			tArray[i].sArray[j].score = random;
		}
	}
}



void printInfo(struct Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << " 老师姓名:" << tArray[i].tName << endl;

		for (int j = 0; j < 5; j++)
		{
			cout << " \t学生姓名:" << tArray[i].sArray[j].sName << 
				" 考试分数: " << tArray[i].sArray[j].score <<endl;
		}
	}
	
}


int main()
{
	//随机数种子
	srand((unsigned int)time(NULL));
	//创建3名老师的数组
	struct Teacher tArray[3];
	//通过函数 给3名老师的信息赋值,并给老师的学生信息赋值
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len);
	//打印所有老师及所带学生的信息
	printInfo(tArray, len);


	return 0;
}

 老师姓名:Teacher_A
        学生姓名:Student_A 考试分数: 75
        学生姓名:Student_B 考试分数: 52
        学生姓名:Student_C 考试分数: 77
        学生姓名:Student_D 考试分数: 45
        学生姓名:Student_E 考试分数: 59
 老师姓名:Teacher_B
        学生姓名:Student_A 考试分数: 98
        学生姓名:Student_B 考试分数: 79
        学生姓名:Student_C 考试分数: 57
        学生姓名:Student_D 考试分数: 50
        学生姓名:Student_E 考试分数: 90
 老师姓名:Teacher_C
        学生姓名:Student_A 考试分数: 71
        学生姓名:Student_B 考试分数: 99
        学生姓名:Student_C 考试分数: 51
        学生姓名:Student_D 考试分数: 98
        学生姓名:Student_E 考试分数: 93

4.8 案例2

案例描述:
设计一个英雄的结构体,包括成员姓名,年龄,性别;创建结构体数组,数组中存放5名英雄。
通过冒泡排序的算法,将数组中的英雄按照年龄进行升序排序,最终打印排序后的结果。
五名英雄信息如下:

{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"},

demo27:

自己写的:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


//定义英雄结构体
struct Hero
{
	string hName;
	int age;
	string sex;

};



int main()
{
	struct Hero hArray[] = {
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"}
	};

	int len = sizeof(hArray) / sizeof(hArray[0]);
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (hArray[j].age > hArray[j + 1].age)
			{
				int temp_a = hArray[j].age;
				hArray[j].age = hArray[j + 1].age;
				hArray[j + 1].age = temp_a;

				string temp_n = hArray[j].hName;
				hArray[j].hName = hArray[j + 1].hName;
				hArray[j + 1].hName = temp_n;

				string temp_s = hArray[j].sex;
				hArray[j].sex = hArray[j + 1].sex;
				hArray[j + 1].sex = temp_s;
			}
		}
	}

	for (int i = 0; i < len; i++)
	{
		cout << " 英雄姓名:" << hArray[i].hName <<
			" 英雄年龄: " << hArray[i].age << 
			" 英雄性别: " << hArray[i].sex<<endl;
	}

	return 0;
}

 英雄姓名:貂蝉 英雄年龄: 19 英雄性别: 女
 英雄姓名:张飞 英雄年龄: 20 英雄性别: 男
 英雄姓名:赵云 英雄年龄: 21 英雄性别: 男
 英雄姓名:关羽 英雄年龄: 22 英雄性别: 男
 英雄姓名:刘备 英雄年龄: 23 英雄性别: 男

老师的:

#include<iostream>
//#include<string> //用C++风格字符串,要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


//定义英雄结构体
struct Hero
{
	string hName;
	int age;
	string sex;

};

//冒泡排序
void bubbleSort(struct Hero hArray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (hArray[j].age > hArray[j + 1].age)
			{
				struct Hero temp = hArray[j];
				hArray[j] = hArray[j + 1];
				hArray[j + 1] = temp;

			}
		}
	}
}

//打印排序后数组中的信息
void printHero(struct Hero hArray[], int len)
{

	for (int i = 0; i < len; i++)
	{
		cout << " 英雄姓名:" << hArray[i].hName <<
			" 英雄年龄: " << hArray[i].age <<
			" 英雄性别: " << hArray[i].sex << endl;
	}

}

int main()
{
	struct Hero hArray[] = {
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"}
	};

	int len = sizeof(hArray) / sizeof(hArray[0]);

	bubbleSort(hArray, len);
	printHero(hArray, len);


	return 0;
}

优势:直接交换结构体的顺序,而不用每个单独交换。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值