C++基础学习笔记（二）——基础入门PART2

已于 2022-12-19 16:43:00 修改
阅读量1k 收藏
点赞数
分类专栏： C++ 文章标签： c++ 学习 算法 基础入门
于 2022-12-18 18:49:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45719141/article/details/128266268
版权

参考链接：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;
}

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

子非鱼icon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值