C++ _03＜数组&函数&指针&结构体＞

Gnar_w

已于 2023-10-03 18:21:18 修改

阅读量95

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-09-07 10:10:59 首次发布

本文链接：https://blog.csdn.net/Gnar_w/article/details/132488516

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

——本文均为自学笔记，如有错误请指正

一、数组

1. 概述

说明：所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点：

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

2. 一维数组

① 一维数组定义方式

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

示例：

//数组
/*
//第一种定义方式
int arr[5];
//数组中的元素进行赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
//访问数组元素
cout << arr[0] << endl;
*/

/*
//第二种定义方式
int arr2[] = { 10,20,30,40,50 };
//如果初始化数据时候，没有全部填写完，会用0来填补剩余数据
cout << arr2[0] << endl;
//利用循环 输出数组中的元素
for (int i = 0; i < 5; i++)
{
	cout << arr2[i] << endl;
}
*/

/*
//第三种定义方式
//定义数组的时候，必须有初始长度
int arr3[] = { 1,2,3,4,5,6,7,8,9 };
for (int i = 0; i < 9; i++)
{
	cout << arr3[i] << endl;
}
*/

② 一维数组数组名

一维数组名称的用途：

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

示例：

//一维数组名
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;

cout << "数组首地址为：" << (int)arr << endl;
cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;
//数组名是常量，不可以进行更改

案例：

//五只小猪称体重
//访问数组中每个元素，如果这个元素比我认定的最大值要大，更新最大值
//创建5只小猪体重
//从数组中找最大值
//打印最大值

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 << endl;

// 数组元素逆置

/*
步骤：
1. 创建数组
2. 实现逆置：
	记录起始、结束下标位置；起始结束下标位置元素互换；起始位置++，结束位置--
	循环执行互换操作，直到起始位置>=结束位置
3. 打印结果

*/
//末尾元素下标  int end = sizeof(arr)/sizeof(arr[0])-1  

/*逆置思路：
1 2 3 4 5
设 temp 空瓶  arr[0] 牛奶  arr[4]豆浆

int temp = arr[0]; //将牛奶倒入空瓶，现在牛奶杯没了牛奶
arr[0] = arr[4];   //将豆浆倒入牛奶瓶
arr[4] = temp;     //将空瓶中的牛奶倒入豆浆杯

实现： 空瓶→牛奶→空瓶，牛奶杯→豆浆，豆浆杯→牛奶

再转换 arr[0]→arr[start];arr[4]→arr[end]
int temp = arr[start];   //将首个元素放入临时变量
arr[start] = arr[end];   //将末尾元素放入首个元素地址
arr[end] = temp;         //将临时变量中的元素放入末尾元素地址

实现：临时变量空→首个元素→空；首个元素→末尾元素；末尾元素→首个元素

互换之后，元素要进行交替变更：
首个元素++变为下一个元素即start++，即首个元素从arr[0]<1>变为arr[1]<2>
末尾元素--变为上一个元素即end--,即末尾元素从arr[4]<5>变为arr[3]<4>
元素不止变更一次，因此需要添加循环进行持续变更;
当首个：arr[1]<2>→arr[2]<3>   末尾：arr[3]<4>→arr[2]<3> ,此时3=3，互换没意义,
因此当start ≥ end时,互换就应该停止,所以 持续变更需要条件即start<end
while(start<end)
{
	start++;
	end--;
}

*/

//1. 创建数组
int arr[5] = { 1,2,3,4,5 }; 
cout << "//逆置前//" << endl;
for (int i = 0; i < 5; i++)
{
	cout << arr[i] << endl;
}
//2. 实现逆置
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--;  
	 
}
//3. 打印逆置结果
cout << "//逆置后//"<< endl;
for (int i = 0; i < 5; i++)
{
	cout << arr[i] << endl;
}

③ 冒泡排序

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

比较相邻的元素。如果第一个比第二个大，就交换二者；
对每一对相邻的元素做同样的操作，执行完毕后，找到第一个最大值；
重复以上步骤，每次比较次数-1，直到不需要比较

注：

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

案例：将数组{4，2，8，0，5，7，1，3，9}进行升序排序

//冒泡排序
//示例：将数组{4，2，8，0，5，7，1，3，9}进行升序排序
/*逻辑思路：
比较相邻的元素。如果第一个比第二个大，就交换二者；
对每一对相邻的元素做同样的操作，执行完毕后，找到第一个最大值；
重复以上步骤，每次比较次数-1，直到不需要比较

排序轮数          数组             对比相邻次数                       结论
   0       4 2 8 0 5 7 1 3 9           8次        2 4 0 5 7 1 3 8 9  对比结束后，找到一个第一个最大值 9
   1       2 4 0 5 7 1 3 8             7次        2 0 4 5 1 3 7 8    找到第二个最大值 8
   2       2 0 4 5 1 3 7               6次        0 2 4 1 3 5 7      找到第三个最大值 7
   3       0 2 4 1 3 5                 5次        0 2 1 3 4 5        找到第四个最大值 5
   4       0 2 1 3 4                   4次        0 1 2 3 4          找到第五个最大值 4
   5       0 1 2 3                     3次        0 1 2 3            找到             3
   6       0 1 2                       2次        0 1 2                               2
   7       0 1                         1次        0 1                                 1
结果：0 1 2 3 4 5 7 8 9
*/
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
cout << "排序前" << endl;
for (int i = 0; i < 9; i++)
{
	cout << arr[i] << " ";
}
cout << endl;
//开始冒泡排序
/*
代码思路：
排序总轮数 = 元素个数-1；
每轮对比次数 = 元素个数 - 排序轮数 -1；
*/
//外层为排序轮数
for (int i = 0; i < 9-1; i++)
{
	//内层循环为 每轮对比次数
	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] << " ";
}

3. 二维数组

二维数组就是在一维数组上，多加了一个维度。通常以矩阵形式呈现。

① 二维数组定义方式

数据类型数组名 [ 行数 ] [ 列数 ]；

数据类型数组名 [ 行数 ] [ 列数 ] = {{数据1，数据2} ,{数据3，数据4}}; 推荐使用此方法

数据类型数组名 [ 行数 ] [ 列数 ] = {数据1，数据2，数据3，数据4};

数据类型数组名 [ ] [ 列数 ] = {数据1，数据2，数据3，数据4};

//二维数组定义

//第一种定义方式
int arr[2][3];  //两行三列
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
//外层循环打印行数，内层循环打印列数
for(int i = 0 ; i < 2 ; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr[i][j] << endl; 
	}
}

//第二种定义方式
int arr2[2][3] = 
{
	{1,2,3},
	{4,5,6}
};
for (int i = 0; i < 2; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr2[i][j] << " ";
	}
	cout << endl;
}

//第三种定义方式
	int arr3[2][3] = {1,2,3,4,5,6};   //2行3列，因此每3个数为一行

//第四种定义方式
	int arr4[][3] = { 1,2,3,4,5,6 }; //3列，因此，三个数为一行

//因此定义二维数组，可以省略行，不可以省略列

② 二维数组数组名

查看二维数组所占内存空间
获取二维数组首地址

//二维数组名称用途
//可以查看占用内存空间大小
int arr[2][3] = 
{
	{1,2,3},
	{4,5,6}
};
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[0][0] << endl; //获取元素地址需要取址符 &

③ 应用案例

//二维数组应用案例
//1、创建二维数组
int scores[3][3] = 
{
	{100,100,100},
	{90,50,100},
	{60,70,80}
};
//保存姓名的数组
string names[3] = {"张三","李四","王五"};  //需要加string头文件
//统计每个人的分数总和
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;
}

二、函数

1. 概述

作用：将一段经常使用的代码封装起来，减少重复代码；一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能；这些独立的模块通常可以写成一个函数。

2. 函数的定义

① 函数的定义五步骤：

返回值类型：一个函数可以返回一个值
函数名：自定义的函数名称
参数表列：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

② 语法：

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

③ 示例

//实现一个加法函数。功能:传入两个整形数据，计算数据相加的结果，并返回。
//返回值类型：int | 函数名:add | 参数列表:(int x ,int y) | 函数体语句:int sum = x + y | return表达式:return sum;
int add(int x, int y)
{
	int sum = x + y;
	return sum;
}

3. 函数的调用

① 功能：使用定义好的函数

② 语法：函数名(参数)

③ 示例：

//实现一个加法函数。功能:传入两个整形数据，计算数据相加的结果，并返回。
//返回值类型：int | 函数名:add | 参数列表:(int x ,int y) | 函数体语句:int sum = x + y | return表达式:return sum;
int add(int x, int y)
{
	int sum = x + y;
	return sum;
}

//定义的时候x,y并没有真实的数据，因此此时的x,y只是一个形式上的参数，简称形参
// a,b两个参数有实际的值，一般称为实际参数，简称实参
//当调用函数时，实参的值会传递给形参

int main()
{
	//函数的调用
	int a = 10;
	int b = 20;
	int c = add(10, 20);

	cout << "C = " << c << endl;



	system("pause");
	return 0;

}

4. 值传递

值传递，就是在函数调用时实参将数值传入给形参
值传递时，如果形参发生，并不会影响实参。
形参更改不了实参

示例：掉用两个数字进行交换的函数

//实现两个数字进行交换的函数
//如果函数不需要返回值，声明的时候可以写void
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;

	//return;  //返回值不需要的时候，可以不写return
}

int main()
{
	//函数的调用 swap()
	swap(a, b);

	system("pause");
	return 0;
}

5. 函数的常见样式

常见的函数样式有4种：

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

//函数的常见样式
//无参无返
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 10;
}
//有参有返
int test04(int a)
{
	cout << "this is test04 a =" << a << endl;
	return a;
}

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

    system("pause");
	return 0;
}

6. 函数的声明

作用：告诉编译器函数名称以及如何调用函数，函数的实际主体可以单独定义。

注：函数的声明可以多次，但是函数的定义只能有一次。

示例：

#include<iostream>
using namespace std;

//函数的声明
//比较函数，实现两个整型数字进行比较，返回较大的值
//提前告诉编译器函数的存在，可以利用函数的声明
//添加声明后，定义可以写在main函数的后面


//声明
int max(int a, int b);


int main()
{

	int a = 10;
	int b = 20;
	cout << max(a, b) << endl;



	system("pause");
	return 0;
}

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

7. 函数的份文件编写

作用：让代码结构更加清晰

步骤：

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

三、指针

1. 指针的基本概念

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

内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

<指针就是一个内存地址>

2. 指针变量的定义和使用

指针变量定义语法：数据类型 * 变量名
示例：


	//1、定义指针
	int a = 10;
	//指针定义的语法: 数据类型 * 指针变量
	int * p;
	//让指针记录变量a的地址
	p = &a;   //需要取址符 & 
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

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

3.指针所占空间内存

指针也是一种数据类型。
示例

	//指针所占空间
	int a = 10;
	int *p = &a;

	cout << *p << endl;  //解引用
	cout << "sizeof (int *) =  " << sizeof (int *) <<endl;
	cout << "sizeof (float *) =  " << sizeof(float *) << endl;
	cout << "sizeof (double *) =  " << sizeof(double *) << endl;
	cout << "sizeof (char *)= " << sizeof(char *) << endl;

	//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型；
	//在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型

4. 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注：空指针指向的内存是不可以访问的
示例-空指针

	//空指针
	//1、空指针用于给指针变量进行初始化
	int *p = NULL;
	//2、空指针是不可以进行访问的
	*p = 100;  //是错误的！！！！！

野指针：指针变量指向非法的内存空间
示例-野指针

//野指针
	int *p = (int *)0x1100;
	cout << *p << endl;  //错误

5. const 修饰指针

const 修饰指针有三种情况：

const修饰指针 ——常量指针
const修饰常量 ——指针常量
const 既修饰指针又修饰常量

示例：

6. 指针和数组

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

示例：

	//指针和数组
	
	//普通访问数组中的元素
	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++;
	}

7. 指针和函数<地址传递>

作用：利用指针作函数参数，可以修改实参的值

注：如果不想修改实参，用值传递；如果想修改实参，用地址传递

//实现两个数字进行交换
void swap(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;

}

int main()
{
	//指针和函数

	//地址传递
	//如果是地址传递，可以修饰实参
	int a = 10;
	int b = 20;
	swap(&a,&b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;


	system("pause");
	return 0;

}

8. 指针、数组、函数

案例：封装一个函数，利用冒泡排序，实现对整形数组的升序排序

例如数组：int arr[10] = {4,3,6,9,1,2,10,8,7,5}

//冒泡升序排序
//排序总轮数 = 元素个数-1；
//每轮对比次数 = 元素个数 - 排序轮数 - 1；
//参数1：数组的首地址，参数2：数组长度
void bubbleSort(int * arr ,int len)
{
	//外侧循环
	for (int i = 0; i < len - 1; i++)
	{
		//内侧循环
		for (int j = 0; j < len - i - 1; 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 }

    //定义数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);

    //冒牌排序
	bubbleSort(arr, len);

	//打印排序后的数组
	printArray(arr, len);

    system("pause");
	return 0;

}

四、结构体

1. 结构体基本概念

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

2. 结构体定义和使用

① 语法：

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

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

struct 结构体名变量名
struct 结构体名变量名 = {成员1值，成员2值...}
定义结构体时顺便创建变量 <不推荐使用>

③ 示例：

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

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

//顺便创建结构体变量

struct Student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
}s3; //顺便创建一个结构体变量;



int main()
{

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

    //struct 结构体名 变量名
	//结构体创建时struct关键字可以省略

	struct Student s1;
	//给s1赋值
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << "  年龄：" << s1.age << "  分数：" << s1.score << endl;

	//struct 结构体名 变量名 = { 成员1值，成员2值... }
	struct Student s2 = {"李四",18,80};
	cout << "姓名：" << s2.name << "  年龄：" << s2.age << "  分数：" << s2.score << endl;

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

    system("pause");
    return 0;
}

3. 结构体数组

① 作用：

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

② 语法：

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

③ 示例：

//结构体数组
//1、定义一个结构体
struct Student
{
	string name;
	int age;
	int score;
};



int main()
{
//结构体数组
//2、创建结构体数组
	struct Student stuArray[3] = 
	{
		{"张三",18,100},
		{"李四",18,60},
		{"王五",19,99,}
	};
//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;
	}
	system("pause");
	return 0;
}

4. 结构体指针

① 作用：

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

② 示例：

//结构体数组
//1、定义一个结构体
struct Student
{
	string name;
	int age;
	int score;
};
int main()
{
//创建学生结构体变量
	Student s = {"张三",18,100};

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

//通过指针访问结构体变量中的数据
	//通过结构体指针 访问结构体中的属性，需要利用 -> 符号
	cout << "姓名：" << p->name 
         << "  年龄：" << p->age 
         << "  分数：" << p->score<<endl;
    system("pause");
	return 0;
}

5. 结构体嵌套结构体

① 作用：

结构体中的成员可以是另一个结构体

② 示例：

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

//结构体嵌套结构体
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 = 1000;
	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;

}

6. 结构体做函数参数

① 作用：

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

② 两种传递方式：

值传递
地址传递

③ 示例：

//结构体做函数参数
//将学生传入到一个参数中，打印学生信息
struct student
{
	string name;
	int age;
	int score;
};
//打印学生信息的函数
//1、值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "子函数1中：姓名：" << s.name << "  年龄：" << s.age << "  分数：" << s.score << endl;
}
//2、地址传递
void printStudent2(struct student * p)
{
	p->age = 200;
	cout << "子函数2中：姓名：" << p->name << "  年龄：" << p->age << "  分数：" << p->score << endl;

}

int main()
{
	//结构体做函数参数
	//创建结构体变量
	student s;
	s.name = "张三";
	s.age = 18;
	s.score = 85;
	printStudent1(s);
	printStudent2(&s);
	cout << "main函数中：姓名：" << s.name << "  年龄：" << s.age << "  分数：" << s.score << endl;
    system("pause");
	return 0;
}

7. 结构体中const使用场景

① 作用：

用const来防止误操作

② 示例：

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

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

//通过函数打印结构体变量信息
	printStudents(&s);
	cout << "main函数中：姓名：" << s.name << "  年龄：" << s.age << "  分数：" << s.score << endl;
    system("pause");
	return 0;
}

8. 结构体案例

① 案例1：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：

设计学生和老师的结构体，在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的结构体中，有姓名、考试分数，

创建数组存放3名老师，通过给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带的学生数据。

//案例1

//学生结构体
struct student
{
	string sName;
	int score;
};
//老师结构体
struct teacher
{
	string tName;
	student sArray[5];
};
//给老师和学生赋值的函数
void allocateSpeace(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~100分
			tArray[i].sArray[j].score = random;
		}
	}
}
//打印所有信息的函数
void printInfo(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));

	//1、创建3名老师的数组
	teacher tArray[3];
	int len = sizeof(tArray) / sizeof(tArray[0]);
	//2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
	allocateSpeace(tArray, len);

	//3、打印所有老师及所带学生的信息
	printInfo(tArray, len);

    system("pause");
	return 0;
}

② 案例2：

设计一个英雄的结构体，包括成员姓名、年龄、性别；创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

无名英雄信息如下：

{”刘备“，23，”男“}，

{”关羽“，22，”男“}，

{”张飞“，20，”男“}，

{”赵云“，21，”男“}，

{”貂蝉“，19，”女“}

//案例2
//1、设计英雄结构体
struct hero
{
	string name;
	int age;
	string sex;
};
//冒泡排序
void bubbleSort(hero arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j].age > arr[j + 1].age)
			{
				hero temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				//切记此处交换的是结构体的成员，而非仅交换age
			}

		}
	}
}
//打印数组信息
void printHero(hero arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名：" << arr[i].name << "  年龄" << arr[i].age << "  性别：" << arr[i].sex << endl;
	}
}

int main()
{

//案例2

//2、创建数组存放5名英雄
	hero arr[5] = 
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(arr) / sizeof(arr[0]);
//3、对数组进行排序，按照年龄进行升序排序
	bubbleSort(arr, len);

//4、将排序后的结果打印输出
	printHero(arr, len);

    system("pause");
	return 0;
}

Gnar_w

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ _03＜数组&函数&指针&结构体＞

说明：所谓数组，就是一个集合，里面存放了相同类型的数据元素数组中的每个数据元素都是相同的数据类型；数组是由连续的内存位置组成的；数据类型数据名 [ 数组长度 ];数据类型数据名 [ 数组长度 ] = { 值1，值2...};数据类型数据名 [ ] = { 值1，值2...};//数组/*//第一种定义方式int arr[5];//数组中的元素进行赋值//访问数组元素*//*//第二种定义方式。
复制链接

扫一扫

专栏目录