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

news2025/10/30 22:48:00

一、数组

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

特点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;
}

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/98807.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

高通平台开发系列讲解（充电篇）充电底层驱动 power_supply 子系统

高通平台开发系列讲解（充电篇）充电底层驱动 power_supply 子系统

文章目录 一、Power Supply组成二、power_supply结构体说明三、驱动接口沉淀、分享、成长，让自己和他人都能有所收获！😄 📢 电池驱动采取的是 linux 内核驱动中的power_supply子系统框架进行上报电池状态。 一、Power Supply组成 power supply framework在kernel/driver…
阅读更多...
微服务真的是万能解药吗？

微服务真的是万能解药吗？

程序员宝藏库&#xff1a;https://gitee.com/sharetech_lee/CS-Books-Store DevWeekly收集整理每周优质开发者内容&#xff0c;包括开源项目、资源工具、技术文章等方面。 每周五定期发布&#xff0c;同步更新到 知乎&#xff1a;Jackpop。 欢迎大家投稿&#xff0c;提交issu…
阅读更多...
Spring MVC学习 | 拦截器异常处理器

Spring MVC学习 | 拦截器异常处理器

文章目录一、拦截器1.1 简介1.2 拦截器的使用1.2.1 创建1.2.2 配置1.2.3 测试1.3 多个拦截器的执行顺序1.3.1 preHandle()方法返回true1.3.2 preHandle()方法返回false二、异常处理器2.1 简介2.2 配置2.2.1 springmvc.xml中配置2.2.2 注解配置学习视频&#x1f3a5;&#xff1a…
阅读更多...
编码与解码总结

编码与解码总结

标准ASC||字符集&#xff1a; ASC||&#xff1a;美国信息交换标准代码&#xff0c;包括了英文、数字等标准ASC||使用一个字节存储一个字符&#xff0c;首位是0&#xff0c;总供可以表示128个字符 GBK&#xff08;汉字内码扩展规范&#xff0c;国标&#xff09; 汉字编码字符集…
阅读更多...
Apache Shiro，这一篇就够了

Apache Shiro，这一篇就够了

Apache Shiro&#xff0c;这一篇就够了1.Shiro实现登录拦截2.登录认证操作3.Shiro整合Mybatis4.用户授权操作5.Shiro授权6.Shiro整合Thymeleaf1.Shiro实现登录拦截 前期环境准备 准备添加Shiro的内置过滤器&#xff1a; Bean public ShiroFilterFactoryBean shiroFilterFact…
阅读更多...
《美国职业橄榄球大联盟》:NFL·橄榄1号位

《美国职业橄榄球大联盟》:NFL·橄榄1号位

基本装备 NFL橄榄球是一项过程极为激烈的比赛&#xff0c;阻挡、拦截与冲撞都是比赛不可或缺的一部分&#xff0c;这也可以说是橄榄球的一大特色。为了保护球员的安全&#xff0c;避免因为球员受伤而耽误球赛&#xff0c; NFL与NCAA都要求所有球员必须“穿戴合适且合法的护具”…
阅读更多...
IfcOpenShell正确设置几何体的坐标

IfcOpenShell正确设置几何体的坐标

在之前的文章中&#xff0c;我们使用 IfcOpenShell (IOS) 读取 ifc 几何并将其转换为 brep。 当我们读取 wikilab.ifc文件时&#xff0c;一切似乎都是正确的&#xff0c;但真的如此吗&#xff1f; 当你在项目中使用 BIM 时&#xff0c;坐标始终是正确讨论的主题。 就此而言&am…
阅读更多...
Android开发如何使用Docker为Jenkins持续集成助力

Android开发如何使用Docker为Jenkins持续集成助力

Android开发如何使用Docker为持续集成助力 为什么使用Docker 我为啥要使用到Docker呢&#xff1f;其实也是被动的&#xff0c;因为公司的项目托管在Coding上面&#xff0c;然后Jenkins集成也用的是Coding的&#xff0c;Coding默认提供了Android-29&#xff0c;JDK-8的构建环境…
阅读更多...
【JAVA进阶】多态，内部类

【JAVA进阶】多态，内部类

&#x1f4c3;个人主页&#xff1a;个人主页 &#x1f525;系列专栏&#xff1a;JAVASE基础 目录 一、多态 1.多态的概述 2.多态的优势 3.类型转换问题 二、内部类 1.内部类概述[了解] 2.静态内部类[了解] 3.成员内部类[了解] 4.匿名内部类概述[重点] 一、多态 1.多态…
阅读更多...
树状数组经典例题

树状数组经典例题

目录 1.数星星 2.小朋友排队 3.求逆序对 1.数星星 题目描述 天空中有一些星星，这些星星都是在不同的位置，每个星星都有一个坐标。 如果一个星星的左下方(包含正左和正下）有k颗星星，就说这颗星星是k级的。 例如，上图中星星5是3级的(1,2,4在它的左下），星星2,4是1级的。…
阅读更多...
idea中推送本地仓库和远程仓库后代码回退

idea中推送本地仓库和远程仓库后代码回退

本地仓库代码提交后回退 提交到本地仓库后 点击提交后会保存在本地仓库 本地仓库的回撤 找到git的提交记录 右键选择撤销还原 撤销还原后会出现提交文件&#xff0c;成功将本地仓库的文件移除&#xff0c;但是本地的错误代码仍然存在 如果想撤销提交到本地仓库的错误文…
阅读更多...
SOLID 设计原则 - 这篇最容易消化

SOLID 设计原则 - 这篇最容易消化

面向对象设计原则 SOLID 应该是职业程序员必须掌握的基本原则&#xff0c;每个程序员都应该了然于胸&#xff0c;遵守这 5 个原则可以帮助我们写出易维护、易拓展的高内聚低耦合的代码。 它是由罗伯特C马丁(知名的 Rob 大叔)21世纪初期 (准确来说&#xff0c;2000年在他的论文…
阅读更多...
DevOps实战系列【第十章】：详解Jenkins Pipeline基本概念和语法

DevOps实战系列【第十章】：详解Jenkins Pipeline基本概念和语法

个人亲自录制全套DevOps系列实战教程 &#xff1a;手把手教你玩转DevOps全栈技术 流水线基本概念 官方中文手册&#xff1a; https://www.jenkins.io/zh/doc/book/pipeline 我们最好在结合英文文档去看&#xff0c;因为翻译过来的中文比较乱。 Jenkins pipeline是一套插件&…
阅读更多...
MySQL 日志，难怪被模仿

MySQL 日志，难怪被模仿

一.前言 日志是mysql数据库的重要组成部分&#xff0c;记录着数据库运行期间各种状态信息。mysql日志主要包括错误日志、查询日志、慢查询日志、事务日志、二进制日志几大类。 通过分析日志&#xff0c;我们可以优化数据库性能&#xff0c;排除故障&#xff0c;甚至能够还原数…
阅读更多...
中文文献检索网站

中文文献检索网站

1. 中国知网 网址&#xff1a; https://www.cnki.net/ 中国知网被称众多科研人称国内文献论文最全最权威的中文文献库&#xff0c;知网提供中国学术文献、外文文献、学位论文、报纸、会议、年鉴、工具书等各类资源统一检索、统一导航、在线阅读和下载服务。 2. 掌桥科研 网址…
阅读更多...
25.Django大型电商项目之地址管理——如何使用三级联动菜单数据加载地址、保存数据、动态获取数据、设置默认值

25.Django大型电商项目之地址管理——如何使用三级联动菜单数据加载地址、保存数据、动态获取数据、设置默认值

1. 地址管理基本页面 1.1 概述 1.2 流程 修改templates的跳转链接center.html <ul><li><a href"/userapp/address/">地址管理</a></li> </ul>templates {% extends base.html %} {% block title %}用户中心{% endblock %} {…
阅读更多...
东北大学数据结构第八周（排序）

东北大学数据结构第八周（排序）

7-1 快速排序 作者 朱允刚 单位 吉林大学 给定包含n个元素的整型数组a[1],a[2],…,a[n]&#xff0c;利用快速排序算法对其进行递增排序&#xff0c;请输出排序过程&#xff0c;即每次Partition之后的数组。每次选择所处理的子数组的第一个元素作为基准元素。 输入格式: 输入为…
阅读更多...
MapReduce 序列化案例

MapReduce 序列化案例

文章目录MapReduce 序列化案例一、案例需求二、案例分析map 阶段Reduce 阶段三、代码实现1、编写流量统计的Bean对象2、Mapper阶段代码MapReduce 序列化案例 一、案例需求 1、需求&#xff1a; 统计每一个手机号耗费的总上行流量&#xff0c;下行流量&#xff0c;总流量 2、输…
阅读更多...
二、ZFNet可视化卷积神经网络——可解释性机器学习（DataWhale组队学习）

二、ZFNet可视化卷积神经网络——可解释性机器学习（DataWhale组队学习）

目录引言ZFNet的网络结构可视化反卷积反池化反激活反卷积训练细节特征可视化特征演化特征不变性局部遮挡测试敏感性分析相关性分析消融实验宽度影响深度影响迁移学习能力有效性分析总结引言 纽约大学ZFNet&#xff0c;2013年ImageNet图像分类竞赛冠军模型。对AlexNet进行改进的…
阅读更多...
AOP 操作

AOP 操作

AOP 操作AOP 操作&#xff08;准备&#xff09;1. Spring 框架一般是基于 AspectJ 实现 AOP 操作&#xff08;1&#xff09;什么是 AspectJ2. 基于 AspectJ 实现 AOP 操作3. 在项目工程里面引入 AOP 先关的依赖4. 切入点表达式举例1&#xff1a;对 com.fairykunkun.dao.UserDao…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023