C++入门基础（二）

松小淞

已于 2023-05-24 19:24:45 修改

阅读量436

点赞数 2

文章标签：学习 c++

于 2022-11-21 20:47:56 首次发布

本文链接：https://blog.csdn.net/qq_56896418/article/details/127675418

版权

5、数组

5.1 概述

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

特点1：数组中的每个数据元素都是相同的数据类型；

特点2：数组是由连续的内存位置组成的

5.2 一维数组

5.2.1 一维数组定义方式

1.数据类型数组名[数组长度];

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

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

示例代码如下：

定义方式1

#include<iostream>
using namespace std;

int main()
{
	//一维数组定义
	//方法1  数据类型 数组名[数组长度];
	int arr[5];
	arr[0] = 50;
	arr[1] = 10;
	arr[2] = 20;
	arr[3] = 30;
	arr[4] = 40;
	//访问数组最后一个位置的内容
	cout << arr[4] << endl;
	system("pause");
	return 0;
}

定义方式2

#include<iostream>
using namespace std;

int main()
{
	//一维数组定义
	//方法2  数据类型 数组名[数组长度]={数组内容};
	int arr[10] = { 0, 1, 2, 3};
	//访问数组中的所有元素
	int i;
	for (i = 0; i < 9; i++)
	{
		cout << arr[i] << endl;
	}
	system("pause");
	return 0;
}

注意:在此例中，数组初始定义为10个位置，但是赋值并没有完全赋值，此时没有赋值的位置将自动补0.

运行结果如下：

定义方式3

#include<iostream>
using namespace std;

int main()
{
	//方法3  数据类型 数组名[ ]={数组内容};
	int i;
	int arr[ ] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 ,9 };
	//打印数组中的所有元素
	for(i=0;i<9;i++)
	{
		cout << arr[i] << endl;
	}
	system("pause");
	return 0;
}

注意：不论哪种方式定义数组，初始定义时必须定义数组长度。

5.2.2 一维数组数组名的作用

1、通过元素名统计数组元素的大小；

2、可以查看数组首地址；

注意一维数组数组名为常量不可直接赋值。

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	//数组名的用途
	//1、通过元素名统计数组元素的大小
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	cout << "整个数组所占空间大小" << sizeof(arr) << endl;
	cout << "数组中的单个元素所占空间大小" << sizeof(arr[1]) << endl;
	cout << "数组长度为" << sizeof(arr) / sizeof(arr[1]) << endl;
	//2、可以查看数组首地址
	cout << "数组的首地址为" << arr << endl;
	//将数组首地址16进制的数转化为10进制
	cout << "数组的首地址为" << (int)arr << endl;
	//查看数组中第一个元素的地址
	cout << "数组的第一个元素地址为" << (int)&arr[0] << endl;
	cout << "数组的第二个元素地址为" << (int)&arr[1] << endl;
	system("pause");
	return 0;
}

此时运行结果如下：

第二个元素地址刚好比第一个元素地址多四个。正好一个元素所占空间的大小。并且数组地址每次运行都会发生变化。

5.2.3 案例-五只小猪称体重

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	//定义五只猪的体重
	int arr[] = { 150,200,350,100,250 };
	//找出体重最重的那只猪
	int max = 0;
	for (int i = 0; i < 5; i++)
	{
		if (max < arr[i])
			max = arr[i];
		else
			max = max;
	}
	cout << "最重的猪为" << max << "斤"<<endl;
	system("pause");
	return 0;
}

5.2.4 一维数组案例-数组元素逆置

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	//实现数组元素的逆置
	//1、创建数组
	int arr[] = { 3,5,1,2,4 };
	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--;
	}
	//打印逆置后的数组
	cout << "逆置后的数组为" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}
	system("pause");
	return 0;
}

注意：末尾下标为数组长度-1

5.2.5 冒泡排序

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	//利用冒泡排序实现数组的升序排列
	//创建数组
	int arr[] = {7,2,1,6,8,9,3,5};
	//开始冒泡排序
	//总共排序论述为 元素个数-1
	for (int i = 0; i < 8 - 1; i++)
	{
		//内层循环对比 次数=元素个数-当前轮数-1
		for (int j = 0; j < 8 - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}

	}
	//打印排序后的序列
	for (int k = 0; k < 8 ; k++)
	{
		cout << arr[k] << endl;
	}
	system("pause");
	return 0;
}

5.3 二维数组

5.3.1 二维数组定义方式

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

1.数据类型数据名[行数][列数];

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

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

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

建议：第二种定义方式更加直观，提高了代码的可读性。

示例代码如下（以第二种定义方法为例，其他同理）：

include<iostream>
using namespace std;

int main()
{
	//二维数组定义
	//2、数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}};
	int arr1[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr1[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

5.3.2 二维数组数组名

作用：查看二维数组所占的内存空间；

获取二维数组首地址；

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	//二维数组名的用途
	int arr1[2][3] = { {1,2,3} ,{4,5,6} };
	//作用1：查看二维数组所占的内存空间；
	cout << "二维数组所占内存空间的大小:" << sizeof(arr1) << endl;
	cout << "二维数组第0行所占内存空间大小:" << sizeof(arr1[0]) << endl;
	cout << "二维数组第0行第0列所占内存空间大小:" << sizeof(arr1[0][0]) << endl;
	cout << "求二维数组的行数:" << sizeof(arr1)/ sizeof(arr1[0])<< endl;  //利用整个二维数组的内存空间/二维数组一行的内存空间
	cout << "求二维数组的列数:" << sizeof(arr1[0]) / sizeof(arr1[0][0]) << endl;  //利用二维数组一行的内存空间/整个二维数组的一个元素的内存空间
	//作用2：获取二维数组首地址；
	cout << "二维数组所在地址的16进制:" << arr1 << endl;
	cout << "二维数组所在地址的16进制强制转化为10进制:" << (int)arr1 << endl;
	system("pause");
	return 0;
}

5.3.3 二维数组案例-考试成绩统计

要求：利用二维数组统计下列成绩

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	int arr1[3][4] =     //二维数组也可以采取这种方式定义更直观
	{
		{100, 100, 100},
		{100, 50, 100},
		{60, 70, 80}
	};
	for (int i = 0; i < 3; i++)
	{
		int sum = 0;  //注意定义变量时的位置，输出在第一层循环，那么定义不能在内部循环中循环
		for (int j = 0; j < 3; j++)
		{
			sum += arr1[i][j];
			cout << arr1[i][j] << " ";
		}
		cout << "第一个人的成绩为：" << sum;
		cout << endl;
	}
	system("pause");
	return 0;
}

6、函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2 函数的定义

函数的定义一般有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

示例：

代码如下：

#include<iostream>
using namespace std;

//函数体的定义
int add(int num1, int num2)
	{
		int sum = num1 + num2;
		return sum;
	}
int main()
{
	system("pause");
	return 0;
}

6.3 函数的调用

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

语法：函数名（参数）

示例代码如下：

#include<iostream>
using namespace std;

//函数体的定义
int add(int num1, int num2)
	{
		int sum = num1 + num2;
		return sum;
	}
int main()
{
	int a = 10, b = 2;
	int c = add(a, b);
	cout << "c=" << c << endl;

	int chinese = 90, math = 100;
	int score = add(chinese, math);
	cout << "总成绩为:" << score << endl;
	system("pause");
	return 0;
}

注:num1和num2在定义时，并没有实际的值。因此，它们通常称为形式参数，简称形参。实际参数是下面的a,b以及chinese,math。

6.4 值传递

功能：在函数调用时实参将数值传入形参。

值传递时，如果形参发生改变，并不会影响实参。

示例：利用函数实现两个数的互换。

示例代码如下：

#include<iostream>
using namespace std;
//函数的值传递

//定义函数时，如果函数没有返回值，可以使用void定义。
void swap(int num1, int num2)
	{
	cout << "交换前的数据" << endl;  //定义函数实现两个数的互换；
	cout << "num=" << num1 << endl;
	cout << "num=" << num2 << endl;
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换后的数据" << endl;
	cout << "num=" << num1 << endl;
	cout << "num=" << num2 << endl;
	}

int main()
{
	int a = 10, b = 2;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	 swap(a, b);
	 cout << "a=" << a << endl;
	 cout << "b=" << b << endl;
	
	system("pause");
	return 0;
}

运行结果如下：

解释如下：

程序从main函数开始首先打印main函数中定义的a,b的值，然后进入到swap函数里面，首先实参ab将自己的值传递给形参num1,num2,中间两个即是函数运行的结果，但是等到swap函数结束，a依然没有交换。这是因此在函数进行值传递的过程中，形参不论如何变化都不会影响实参的值。

6.5 函数的常见样式

常见的函数样式有四种

1、无参无返

2、有参无返

3、无参有返

4、有参有返

示例代码如下：

#include<iostream>
using namespace std;

//函数常见的四种样式
//无参无返
void demo1()
{
	cout << "this is a demo1" << endl;
}
//无参有返
int demo2()
{
	cout << "this is a demo2" << endl;
	return 100;
}
//有参无返
void demo3(int a)
{
	cout << "this is a demo3a="<<a << endl;
}
//有参有返
int demo4(int a)
{
	cout << "this is a demo4a=" << a << endl;
	return a;
}
int main()
{
	//无参无返的调用
	demo1();
	//无参有返的调用
	int num1=demo2();
	cout << num1 << endl;
	//有参无返的调用
	demo3(100);
	//有参有返的调用
	int num2 = demo4(20);
	cout << "a=" << num2 << endl;
	system("pause");
	return 0;
}

输出结果如下：

6.6 函数的声明

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

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

应用过程中，函数体如何在函数调用之后，会报错，因此可以在调用函数前加上函数声明。

示例代码如下：

#include<iostream>
using namespace std;

//函数的声明
//比较两个数字，并返回较大的一个

int max(int a, int b);
int main()
{
	int num1 = 20, num2 = 10;
	int c = max(num1, num2);
	cout << "a与b中大的一位数是" << c << endl;
	system("pause");
	return 0;
}
int max(int a, int b)
{
	return a > b ? a : b;  //三目运算符，如果a>b则返回a,否则返回b
}

6.7 函数的分文件编写

作用：让代码更加清晰

函数的分文件编写一般有四个步骤

1、创建后缀名为.h的头文件；

2、创建后缀名为.cpp的源文件；

3、在头文件中写函数的声明；

4、在源文件中写函数的定义；

示例代码如下：

头文件swap.h

#include<iostream>
using namespace std;


//14、函数分文件编写的头文件
//函数声明
void swap(int a, int b);

函数定义文件swap.cpp

#include"swap.h"

//14、函数分文件编写的函数定义文件
void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << a << endl;
	cout << b << endl;
}

主函数文件

#include<iostream>
using namespace std;
#include"swap.h"

int main()
{
	int a = 20, b = 10;
	swap(a, b);
	system("pause");
	return 0;
}

运行结果如下：

7、指针

7.1 指针的基本概念

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

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

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

7.2 指针变量的定义和使用

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

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	//定义指针 数据类型 *变量名；
	int *p;
	p = &a;  //建立变量a与指针p的联系。
	
	cout << "a的地址为：" << &a << endl;
	cout << "指针p的值为：" << p << endl;

	//使用指针
	//使用解引用的方法使用指针，即*。
	*p = 1000;
	cout << "*p的值为" <<*p<< endl;
	cout << "a的值为" << a << endl;
	system("pause");
	return 0;
}

7.3 指针的内存空间

在32位操作系统下：指针占用4个字节空间；64位操作系统下，占用8个字节内存空间；

示例代码如下：

#include<iostream>
using namespace std;


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

	cout << sizeof(int *) << endl;
	cout << sizeof(float*) << endl;
	cout << sizeof(double*) << endl;
	cout << sizeof(char*) << endl;
	system("pause");
	return 0;
}

运行结果如下：

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间；

用途：初始化指针变量；

注意：空指针指向的内存是不可以访问的；

#include<iostream>
using namespace std;

int main()
{
	//定义空指针
	int* p = NULL;

	//空指针不可以访问
	//因为0-255的内存空间是系统占用的，不能访问
	*p = 100;
	cout << *p << endl;

	system("pause");
	return 0;
}

运行结果如下：

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

#include<iostream>
using namespace std;

int main()
{
	//野指针
	int* p = (int*)0x1100;
	cout << *p << endl;
	system("pause");
	return 0;
}

运行结果如下：

7.5 const修饰指针

1、常量指针

特点：指针的指向可以修改，但是指针指向的值不可以修改。

eg:

const int *p=&a;

*p=20; //错误，指针指向的值不可以修改；

p=&b; //正确，指针指向可以修改；

2、指针常量

特点：指针的指向不可以改，指针指向的值可以改。

eg:

int * const p=&a;

*p=20; //正确，指针指向的值可以修改；

p=&b; //错误，指针指向不可以修改；

3、const 既修饰指针又修饰常量

特点：指针的指向和指针指向的值都不可以改。

记忆方式：我们将*称为指针，const称为常量。常量指针先出现const再出现*，所以称为常量指针。

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	int a =10,b;
	const int *p1 = &a;  //常量指针定义
	//*p1 = 20;  //错误，常量指针指针指向的值不可以修改
	p1 = &b;  //正确，常量指针指针指向可以修改
	
	int* const p2 = &a;  //指针常量定义
	*p2 = 20;  //正确，指针常量指针指向的值可以修改
	//p2 = &b;  //错误，指针常量指针指向不可以修改

	const int* const p3 = &a;  //const即修饰指针又修饰常量
	//*p3 = 20;  //错误，指针指向的值不可以修改
	//p3 = &b;  //错误，指针指向不可以修改
	system("pause");
	return 0;
}

7.6 指针和数组

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

示例代码如下：

#include<iostream>
using namespace std;

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int *p = arr;  //数组名代表数组的内存地址
	for (int i = 0; i < 10; i++)
	{
		cout << *p << endl;
		p++;
	}
	system("pause");
	return 0;
}

7.7 指针和函数

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

示例代码如下：

#include<iostream>
using namespace std;

void swap1(int a, int b)  //值传递
{
	int temp1 = a;
	a = b;
	b = temp1;
	cout << a << endl;
	cout << b << endl;
}
void swap2(int *p1, int *p2)  //地址传递
{
	int temp2 = *p1;
	*p1 = *p2;
	*p2 = temp2;
	cout << *p1 << endl;
	cout << *p2 << endl;
}
int main()
{
	int num1 = 10, num2 = 20;
	swap1(num1, num2);
	cout << num1 << endl;  //值传递并不会改变实参的值
	cout << num2 << endl;
	int num3 = 100, num4 = 10;
	swap2(&num3, &num4);
	cout << num3 << endl;  //地址传递可以改变实参的值
	cout << num4 << endl;
	system("pause");
	return 0;
}

运行结果如下：

解释：运行结果中，前两组数据显示的是值传递后的数据，第一个输出的是，函数定义中的输出实现了交换（形式参数），第二个输出的是main函数中的实际参数，并没有发生交换。后两组数据显示的地址传递后的数据，第三个输出的是函数定义中的输出实现了交换（形式参数），第四个输出的是main函数中的实际参数，发生了交换。

7.8 指针、数组、函数案例

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排列。

#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 - 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 < 10; i++)
	{
		cout << arr[i] << endl;
	}
}
int main()
{
	//利用数组进行冒泡排序
	int arr[] = { 3,1,4,6,8,9,5,2,7,0 };  //创建数组
	int len = sizeof(arr) / sizeof(arr[0]);
	bubblesort(arr, len);  //冒泡函数声明
	printArray(arr, len);  //打印函数声明
	system("pause");
	return 0;
}

8、结构体

8.1 结构体基本概念

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

8.2 结构体定义和使用

语法：struct 结构体名 {结构体成员列表}；

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

1、struct 结构体名变量名

2、struct 结构体名变量名={成员1值，成员2值...}

3、定义结构体时顺便创建变量

示例代码如下：

#include<iostream>
#include<string>
using namespace std;

//定义student数据类型，包含学生的（姓名、年龄、分数）
//struct 结构体名 {结构体成员列表}；
struct student
{
	string name;  //学生姓名
	int age;  //学生年龄
	double score;  //学生考试成绩
}s3;  //第三种创建方法
int main()
{
	//第一种方式：struct 结构体名 变量名
	struct student s1;  //通过结构体创建变量
	s1.name = "张三";  //通过.访问结构体变量中的属性
	s1.age =18;
	s1.score = 97.5;
	cout << "姓名:" << s1.name << " 年龄:" << s1.age << " 考试成绩:" << s1.score<<endl;

	//第二种方式：struct 结构体名 变量名={成员1值，成员2值...}
	struct student s2 = { "李四",19,92.5 };
	cout << "姓名:" << s2.name << " 年龄:" << s2.age << " 考试成绩:" << s2.score << endl;

	//第三种方式：创建结构体时，顺便创建结构体变量s3
	s3.name = "小明";  //通过.访问结构体变量中的属性
	s3.age = 18;
	s3.score = 65;
	cout << "姓名:" << s3.name << " 年龄:" << s3.age << " 考试成绩:" << s3.score << endl;
	system("pause");
	return 0;
}

8.3 结构体数组

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

语法：struct 结构体名数组名[元素个数]={{}，{}，{}，...{}}

示例代码如下：

#include<iostream>
using namespace std;
#include<string>

//结构体数组
	//1、定义结构体数组
struct student
{
	string name;
	int age;
	double score;
};
int main()
{
	//2、创建结构体数组
	struct student stuArray[3] =
	{
		{"张三",18,90},  //创建结构体数组时顺便赋值
		{"李四",28,80},
		{"小明",68,60}
	};
	//3、为结构体数组元素赋值
	stuArray[1].name = "小红";  //使用结构体数组元素进行赋值
	stuArray[2].age = 20;
	//4、遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "第" << i << "个人的姓名为：" << stuArray[i].name << "第" << i << "个人的年龄为：" << stuArray[i].age << "第" << i << "个人的成绩为：" << stuArray[i].score << endl;
	}

	system("pause");
	return 0;
}

8.4 结构体指针

作用：利用指针访问结构体中的元素；

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

#include<iostream>
using namespace std;
#include<string>
//结构体指针
//1、创建结构体
struct student
{
	string name;
	int age;
	double score;
};
int main()
{

//2、创建结构体变量
	struct student s = { "张三",18,99 };   //struct可以省略
//3、定义指针并指向结构体
	struct student* p = &s;  //struct可以省略
//4、通过指针访问结构体中的元素
	cout << p->name << p->age << p->score;
	system("pause");
	return 0;
}

8.5 结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体；

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

示例代码如下：

#include<iostream>
using namespace std;

//结构体嵌套结构体
//每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体；
//定义学生结构体
struct student
{
	string name;
	int age;
	double score;
};
//定义老师结构体
struct teacher
{
	string name;
	int id;
	int age;
	struct student stu;
};
int main()
{
	struct teacher t;
	t.id = 10000;
	t.name = "张三";
	t.age = 57;
	t.stu.name = "李四";
	t.stu.age = 22;
	t.stu.score = 90;
	cout << "老师信息:" << t.id << t.name << t.age << "学生信息" << t.stu.name << t.stu.age << t.stu.score;
	system("pause");
	return 0;
}

8.6 结构体做函数参数

作用：将结构体作为参数向函数传递；

传递方式有两种：

值传递

地址传递

示例代码如下：

#include<iostream>
using namespace std;

//结构体做函数参数
//定义结构体
struct student
{
	string name;
	int age;
	double score;
};

struct student stu;
struct student *p;
//值传递
void printfstudent1(struct student stu)
{
	cout << "子函数输出" << stu.name << stu.age << stu.score<<endl;
}
//地址传递
void printfstudent2(student *p)
{
	cout << "子函数输出2" << p->name << p->age << p->score;

}
int main()
{
	struct student stu;
	stu.name = "张三";
	stu.age = 22;
	stu.score = 86;
	cout << "主函数输出" << stu.name << stu.age << stu.score<<endl;
	printfstudent1(stu);
	printfstudent2(&stu);
	system("pause");
	return 0;
}

8.7 结构体中const的使用场景

作用：用const来防止误操作；

示例代码如下：

#include<iostream>
using namespace std;
//const修饰结构体
struct student
{
	string name;
	int age;
	int score;
};
void printfstudent(  const struct student s)
{
	//s.age = 18; 程序报错，结构体加了const,里面的值不能改变
	cout << s.name << s.age << s.score << endl;
}
int main()
{
	student s;
	s.age = 20;
	s.name = "李华";
	s.score = 90;
	printfstudent(s);
	system("pause");
	return 0;
}

8.8 结构体案例1-学生毕业论文

案例描述：

实现示例代码如下：

#include<iostream>
using namespace std;
#include<string>


//定义英雄结构体
struct hero
{
	string name;
	int age;
	string sex; //性别

};

void bulllesort(struct hero heroarray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果j下标的元素的年龄大于j+1元素，则交换
			if (  heroarray[j].age > heroarray[j + 1].age)
			{
				struct hero temp = heroarray[j];
				heroarray[j] = heroarray[j + 1];
				heroarray[j + 1] = temp;
			}
		}
	}
}
//定义打印函数
void printfhero(struct hero heroarray[], int len)
{

	for (int i = 0; i < 5; i++)
		{
			cout << "姓名" << heroarray[i].name << "年龄为" << heroarray[i].age << "性别为" << heroarray[i].sex << endl;
		}
}
int main(){
	//1、创建英雄结构体
	//2、创建数组，存放英雄信息
	struct hero heroarray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"貂蝉",17,"女"},
		{"张飞",20,"男"},
		{"赵云",18,"男"},
	};
	//int len = sizeof(heroarray) / sizeof(heroarray[0]);  //阶段测试
	//for (int i = 0; i < 5; i++)
	//{
	//	cout << "姓名" << heroarray[i].name << "年龄为" << heroarray[i].age << "性别为" << heroarray[i].sex << endl;
	//}
	//3、对数组进行排序，按照年龄进行升序排序
	int len = sizeof(heroarray) / sizeof(heroarray[0]);
	bulllesort(heroarray, len);
	//4、输出，将排序后结果打印
	printfhero(heroarray, len);

	system("pause");
	return 0;
}

运行结果如下：