C++基础
C++初识(2022.10.17)
1.4 常量定义方式
(1)#define 宏常量:一旦修改就会报错
(2)const修饰的变量:也称为常量,修改也会报错
#define Day 7
Day = 14;//报错,Day是常量,一旦修改就会报错
const int month = 12;
cout << "一周总共有" <<Day<<"天" << endl;
month = 24;//也会报错,常量是不可以修改的
1.5 关键字
**作用:**关键字是C++中预先保留的单词
- 在定义变量或常量时,不要用关键字
1.6标识符命名规则
作用:C++规定给标识符(变量、常量)命名时,有一套自己的规则
- 标识符不能是关键字
- 标识符只能是由字母、数字、下划线组成
- 第一个字符必须为字母或下划线
- 标识符字母区分大小写
建议:给标识符命名时,争取做到见名知意,方便代码阅读
2 数据类型
2.1 整型
//1.短整型(占2个字节)
short num1 = 10;
//2.整型(占4)
int num2 = 10;
//3.长整型(占4)
long num3 = 10;
//4.常常整型(占8)
long long num4 = 10;
2.2 sizeof关键字
作用:统计数据类型所占内存大小
语法:sizeof(数据类型/变量)
int main(){
cout<<"short 类型所占内存空间为:"<< sizeof(short)<<endl;
cout<<"int 类型所占内存空间为:"<< sizeof(int) << endl;
cout<<"long 类型所占内存空间为:"<< sizeof(long) << endl;
system("pause");
return 0;
}
2.3 实型(浮点型)
**作用:**用于表示小数
浮点型变量分两种:
1.单精度float(占4字节):7位有效数字
2.双精度double(占8字节):15-16位有效数字
两者的区别在于表示的有效数字范围不同。
float f1 = 3.14f;//f的作用是明显告诉它为单精度,否则默认为双精度
double d1 = 3.1415926;//默认情况下,输出一个小数,会显示6位有效数字,从左往右
2.4 字符型
**作用:**字符型变量用于显示单个字符
**语法:**char ch =‘a’;(单引号内只能有一个字符,不可以是字符串)
char ch = 'a';//字符型变量所占内存大小为1个字节
//常见错误char ch2 = "b";//创建字符型变量时候,要用单引号
cout<< (int)ch <<endl; //输出字符型变量对应的ASCII编码
2.5 转义字符
**作用:**用于表示一些不能显示出来的ASCII字符
现阶段常用转义字符有:\n(换行); \\(反斜杠); \t(水平制表符,整齐输出数据,一个\t占8个字符空间)
2.6 字符串型
**作用:**用于表示一串字符
两种风格:
1. C风格字符串:char 变量名[] = "字符串值"
|
示例:
char str1[] = "hello world";
cout << str1 <<endl;
注意:c风格的字符串要用双引号括起来
2. C++风格字符串: string 变量名 = "字符串值"
#include <string> //用c++风格字符串时候,要加上这个头文件
string str2 = "hello world";
cout << str2 << endl;
2.7 布尔类型bool
bool类型占1个字节大小
示例:
int main()
{
bool flag = true;
cout << flag << endl;//1
flag = false;//重新赋值为fallse
cout << flag << endl;//0
cout <<"size of bool="<<sizeof(bool)<<endl;//1
system("pause");
return 0;
}
2.8 数据的输入
**作用:**用于从键盘获取数据
关键字: cin
语法: cin >> 变量
|
示例:
int main(){
//整型输入
int a = 0; // 先给a赋一个初始值
cout << "请给整型变量a赋值:" << endl;
cin >> a;
cout << "整型变量a="<<a << endl;
//浮点型
float f = 3.14f
cout << "请给浮点型变量f赋值" <<endl;
cin >> f;
cout << "浮点型变量f="<< f <<endl;
}
3 运算符
3.1 算数运算符
- %:取模运算,求余数,只能两整数进行运算
- ++(前置递增):先让变量+1,然后进行表达式运算
- ++(后置递增):先进行表达式运算,后让变量+1
int a2 = 10;
int b2 = ++a2 * 10;
cout << a2 <<endl;//11
cout << b2 <<endl;//110
int a3 = 10;
int b3 = a3++ * 10
cout << a3 <<endl;//11
cout << b3 <<endl;//100
- –(前置递减):
- –(后置递减):
3.2 赋值运算符
3.3 比较运算符
3.4 逻辑运算符
4 程序流程结构
4.1 选择结构
4.1.1 if 语句
4.1.2 三目运算符
语法: 表达式1 ? 表达式2 : 表达式3
**解释:**如果表达式1的值为真,执行表达式2,并返回表达式2的结果。如果表达式1的值为假,执行表达式3,并返回表达式三的结果。
4.1.3 switch 语句
语法
switch(表达式)
{
case 结果1:执行语句;break;
case 结果2:执行语句;break;
···
default:执行语句;break;
}
//if 和 switch区别?
//switch缺点:判断时候只能是整型或字符型,不可以是一个区间
//switch优点:结构清晰,执行效率高
4.2 循环结构
4.2.1 while循环语句
语法: while(循环条件){循环语句}
|
案例:
#include <ctime>
int main{
//添加随机数种子,利用当前系统时间生成随机数,防止每次随机数都一样
srand((unsigned int)time(NULL));
int a=rand()%100 + 1;//rand()%100是指生成0-99的随机数
int b;
cout << "请输入你猜测的数字:" << endl;
cin >> b;
while (a != b)
{
if (a > b) {
cout << "你猜的太小了,继续" << endl;
cin >> b;
}
else {
cout << "你猜的太大了,继续" << endl;
cin >> b;
}
}
cout << "猜对了,过关!" << endl;
system("pause");
return 0;
}
4.2.2 do…while循环语句、
语法: do{循环语句} while(循环条件)
|
**案例:**在所有三位数中找到水仙花数(该数字所有位的三次方之和等于该数字)
例如水仙花数153,
技巧:获取个位 153%10 = 3 对数字取模于10可以获取个位
获取十位 153/10=15 15%10=5 先整除于10,再取模于10,获得十位
获取百位 153/100=1 直接整除于100获得
int main{
int num = 100; //案例三
do {
int a = 0;
int b = 0;
int c = 0;
a = num % 10;
b = (num / 10)%10;
c = num / 100;
if (a * a * a + b * b * b + c * c * c == num)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}
4.2.3 for循环语句
案例:0-100数字中,输出特殊数字,7的倍数,个位有7,十位有7
int main{
for (int i = 0; i <= 100; i++) {
if (i % 7 == 0 || i % 10 == 7 || i/10==7) {
cout << "敲桌子"<< i << endl;
}
else {
cout << i << endl;
}
}
system("pause");
return 0;
}
4.2.4 嵌套循环
案例5:输出10*10的星图
int mian{
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
cout << "* ";
}
cout << endl;
}
system("pause");
return 0;
}
案例6:输出9*9乘法表
int mian(){
for (int i = 1; i <10 ; i++) { //案例6
for (int j = 1; j < 10; j++) {
if (i >= j) {
cout << j << "*" << i << "=" << i * j <<" ";
}
}
cout << endl;
}
system("pause");
return 0;
}
5 数组
5.1 概述
5.2 一维数组
5.2.1 一维数组定义方式
三种定义方式:
1.数据类型 数组名[数组长度]
2.数据类型 数组名[数组长度] = {值1,值2,…}
3.数据类型 数组名[] = {值1,值2,…}
//不同定义类型示例:
//1.数据类型 数组名[数组长度]
int arr[5];
arr[0]=10; //给数组中的元素赋值
arr[1]=20;
arr[2]=30;
arr[3]=40;
arr[4]=50;
//2.数据类型 数组名[数组长度] = {值1,值2,...}
//如果在初始化数据时候,没有全部填写完,会用0来填补剩余数据
int arr2[5] = {10,20,30,40,50};
//3.数据类型 数组名[] = {值1,值2,...}
//定义数组的时候,必须有初始长度,不能像这样 int arr[];
int arr[] = {90,80,70,60}
//数组名用途
//1.可以通过数组名统计整个数组占内存大小
int arr[10] = {1,2,3,4,5,6}
cout <<"整个数组占用内存空间为:"<<sizeof(arr)<< endl;
cout <<"每个元素占用内存空间为:"<<sizeof(arr[0])<<endl;
//2.可以通过数组名查看数组首地址
cout<<"数组首地址为:"<<(int)arr <<endl;
cout<<"数组中第一个元素地址为:"<<(int)&arr[0]<<endl;//访问具体元素地址,需要加取址符&
//arr = 100;错误,数组名是常量,因此不可以赋值
案例2:数组元素逆置
案例描述:请声明一个5个元素的数组,并将元素逆置。例如数组{1,3,2,5,4}逆置为{4,5,2,3,1}
//法一:自己写的方法,申请了额外的空间存放新数组
int main(){
int arr1[5] = { 1,3,2,5,4 };
int arr2[5];
int j = 0; //末尾元素下标可这样求:end = sizeof(arr)/sizeof(arr[0]) - 1
for (int i = 4; i >= 0; i--) {
arr2[j] = arr1[i];
j++;
}
for (int n = 0; n < 5; n++) {
cout<<arr2[n] ;
}
system("pause");
return 0;
}
//法2:老师的方法,不需要申请额外空间,用交换排序
int main(){
int arr1[5] = { 1,3,2,5,4 };
int start = 0;
int end = sizeof(arr1)/sizeof(arr1[0]) - 1;//末尾元素下标=元素长度-1
while (start < end) {
int temp = arr1[start];
arr1[start] = arr1[end];
arr1[end] = temp;
start++;
end--;
}
for (int i = 0; i < 5; i++) {
cout << arr1[i];
}
system("pause");
return 0;
}
5.2.3 冒泡排序
**作用:**最常见的排序算法,对数组内元素进行排序
1.比较相邻的元素,如果第一个比第二个大,就交换他们两个
2.对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值
3.重复以上的步骤,每次比较次数减一,知道不需要比较
示例:将数组{4,2,8,0,5,7,1,3,9}进行升序排序
int main(){
//冒泡排序案例
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
for (int i = 0; i < 9-1; i++)
{ //排序总轮数=元素个数-1
for (int j = 0; j < 9 -i - 1; j++)
{ //每轮对比次数=元素个数-排序轮数-1
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int n = 0; n < 9; n++) {
cout << arr[n] ;
}
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};
建议利用第二种更加直观,提高代码的可读性
//1.` 数据类型 数组名[行数][列数];`
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 1;
arr[1][2] = 1;
//2.` 数据类型 数组名[行数][列数]={{数据1,数据2},{数据3,数据4}};`
int arr2[2][3]=
{
{1,2,3},
{4,5,6}
};
//案例,求三个人的分数和
//1.创建二维数组
int score[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80}
};
//2.统计每个人的总和分数
for (int i = 0; i < 3; i++) {
int sum = 0;
for (int j = 0; j < 3; j++) {
sum += score[i][j];
}
cout << "第"<<i+1 <<"个人的分数和为:" << sum << endl;
}
system("pause");
return 0;
6 函数
6.1 概述
6.2 函数的定义
语法:
返回值类型 函数名(参数列表)
{
函数体语句;
return 表达式 ;
}
6.3 函数的调用
int add(int num1, int num2) //num1,num2称为形式参数,形参
{
int sum = num1 + num2;
return sum;
}
int main(){
int a = 10; //a,b称为实参
int b = 20;
int c = add(a, b);
cout << c << endl;
system("pause");
return 0;
}
6.4 值传递
6.5 函数的常见样式
常见得函数样式有4种:
1.无参无返
2.有参无返
3.无参有返
4.有参有返
//函数常见样式
//1.无参无返
void test01()
{
cout << "this is test01" << endl;
}
//2.有参无返
void test02(int a)
{
cout << "this is test02 a =" << a << endl;
}
//3.无参有返
int test03() {
cout << "this is test03" << endl;
return 1000;
}
//4.有参有返
int test04(int a) {
cout<<"this is test04 a=" << endl;
return a;
}
int main() {
//无参无返函数调用
test01();
//有参无返函数调用
test02(1000);
//无参有返函数调用
int num = test03();
//有参有返函数调用
int num2 = test04(10000);
system("pause");
return 0;
}
6.6 函数的声明
//可以利用函数的声明,提前告诉编译器函数的存在
//声明可以写多次,但定义只能有一次
int max(int a, int b); //函数的声明
int main(){
int a=10;
int b=20;
cout<<max(a,b)<<endl;
}
//定义函数
int max(int a ,int b){
return a > b ? a:b ;
}
//如果函数声明有默认参数,函数实现就不能有默认参数
6.7 函数的分文件编写
作用:让结构更加清晰
函数分文件编写一般有4个步骤:
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明 //记得添加标准头文件 #include
4.在源文件中写函数的定义 // #include “自己写的头文件.h”
7 指针
7.1 指针的基本概念
**指针的作用:**可以通过指针间接访问内存
- 内存编号是从0开始记录的,一般用十六进制数字表示
- 可以利用指针变量保存地址
7.2 指针的定义和使用
指针变量定义语法:数据类型 * 变量名;
示例:
int main(){
//1.指针的定义
int a = 10;
//指针定义语法: 数据类型 * 变量名;
int * p;
//指针变量赋值
P = &a; //指针指向变量a的地址
cout<< &a <<endl; //打印数据a的地址
cout<< p <<endl; //打印指针变量p
//2.指针的使用
//通过*操作指针变量指向的内存
cout<<"*p="<<*p<<endl;
system("pause");
return 0;
}
7.3 指针所占内存空间
- 在32位操作系统下,指针是占4个字节空间大小,不管是什么数据类型的指针。
- 在64位操作系统下,指针是占8个字节空间大小,不管是什么数据类型的指针。
7.4 空指针和野指针
**空指针:**指针变量指向内存中编号为0的空间
用途:初始化指针变量
注意:空指针指向的内存是不可以访问的
示例1:空指针
int main(){
//空指针
//1、空指针用于给指针变量进行初始化
int * p = NULL;
//2、空指针是不可以进行访问的
//*p = 100; //cout<< *p <<endl; //都是错误操作,0-255之间的内存编号是系统占用的,因此不可以访问
system("pause");
return 0;
}
野指针:指针变量指向非法的内存空间
示例2:野指针
int main(){
//指针变量p指向内存地址编号为0x1100的空间
int * p = (int *)0x1100; //用(int *)把十六进制数强转为地址,因为是随便指向的一个地址,并没有申请,所有必会报错,出现野指针的情况。
//对*p解引用,访问野指针报错
cout<< *p <<endl;
system("pause");
return 0;
}
总结:空指针和野指针都不是我们申请的空间,因此不要访问,会报错。
7.5 const 修饰指针
const修饰指针有三种情况:
1.const修饰指针 —常量指针
2.const修饰常量 —指针常量
3.const既修饰指针又修饰常量
int main(){
//1.const修饰指针-- - 常量指针
int a = 10;
int b = 10;
const int * p = &a;
//指针指向的值不可以改,指针的指向(地址)可以改。
//*p = 20;错误
p = &b; //正确
//2.const修饰常量-- - 指针常量
int * const p2 = &a;
//指针指向的值可以改,指针的指向(地址)不可以改
*p2 = 20; //正确
//p2 = &b; //错误
//3.const既修饰指针又修饰常量
const int* const p3 = &a;
//指针指向的值,指针的指向(地址)都不可以改
//*p3 = 20; //错误
//p3 = &b; //错误
system("pause");
return 0;
}
7.6 指针和数组
**作用:**利用指针访问数组中的元素
示例:
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个字节,相当于p->next
cout << "利用指针访问第二个元素:" << *p << endl;
//利用指针遍历数组
int* p2 = arr;
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
cout << *p2 << endl;
p2++;
}
system("pause");
return 0;
}
7.7 指针和函数
void swap01(int a,int b){
int temp = a;
a = b;
b = temp;
}
void swap02(int *p1,int *p2){
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main(){
//1.值传递,实参不会被修改
int a=10;
int b=20;
swap01(a,b);
//2.地址传递
//如果是地址传递,实参会被修改
swap02(&a,&b);
system("pause");
return 0;
}
7.8 指针、数组、函数 综合使用
案例描述:封装一个函数,利用冒泡排序,实现对整型数组的升序排序
例如数组: int arr[10] = {4,3,6,9,1,2,10,8,7,5}
//冒泡排序 参数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] << endl;
}
}
int main(){
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
//数组长度
int len = sizeof(arr) / sizeof(arr[0]);
//调用冒泡排序
Bubblesort(arr, len);//arr表示数组首地址,len表示数组长度
//打印排序后的数组
printArray(arr, len);
system("pause");
return 0;
}//注:传数组的时候一般传首地址进来即可,写函数的时候用指针 int* p 接收首地址。
8 结构体
8.1 结构体的基本概念
结构体属于用户自定义的数据类型,允许用户存储不同的数据类型
8.2 结构体定义和使用
语法: struct 结构体名{结构体成员列表};
通过结构体创建变量的方式有三种:
- struct 结构体名 变量名
- struct 结构体名 变量名={成员值1,成员值2,…}
- 定义结构体时顺便创建变量
示例:
#include<iostream>
#include<string>
//创建一个结构体
struct Student{
string name;
int age;
int score;
}s3;
int mian(){
//通过结构体创建变量的方式有三种:
//1.struct 结构体名 变量名
struct Student s1;
s1.name = "张三";
s1.age = 18;
s1.score = 100;
//2.struct 结构体名 变量名={成员值1,成员值2,.....}
struct Student s2={"李四",19,80};
//3.定义结构体时顺便创建变量
//s3就是一个结构体变量
s3.name = "王五";
s3.age =17;
s3.score = 88;
system("pause");
return 0;
} //推荐使用前两种
8.3 结构体数组
**作用:**将自定义的结构体放入到数组中方便维护
语法: struct 结构体名 数组名[元素个数]={{},{},{},......}
示例:
#include<string>
//1.定义一个结构体
struct Student{
string name;
int age;
int score;
};
int main(){
//2.创建结构体数组
struct Student stuArray[3] ={
{"张三",18,100},
{"李四",28,99},
{"王五",44,88}
};
//3.给结构体数组中的元素赋值
stuArray[2].name = "赵六";
stuArray[2].age = 50;
stuArray[2].score = 87;
//遍历结构体数组
for(int i=0;i<3;i++){
cout<<"姓名:"<<stuArray[i].name
<<"年龄"<<stuArray[i].age
<<"分数"<<stuArray[i].score<<endl;
}
}
8.4 结构体指针
**作用:**通过指针访问结构体中的成员
- 利用操作符
->
可以通过结构体指针访问结构体属性
示例:
//创建一个结构体
struct Student {
string name;
int age;
int score;
};
int main(){
//1.创建学生结构体变量
struct Student s = { "张三",18,100 };
//2.通过指针指向结构体变量
struct Student* p = &s;
//3.通过指针访问结构体变量中的数据
//通过结构体指针 访问结构体的属性,需要利用'->'
cout << "姓名:" << p->name << "年龄:" << p->age << "分数:" << p->score << endl;
system("pause");
return 0;
}
8.5 结构体嵌套结构体
**作用:**结构体中的成员可以是另一个结构体
例如:每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体
//结构体嵌套一个结构体
struct student {
int age;
string name;
int score;
};
struct teacher {
int id;
string name;
int age;
struct student stu;//老师结构体嵌套一个学生结构体,即一个学生结构体变量
};
int main(){
//结构体嵌套一个结构体
teacher t;//创建一个结构体变量,前面的struct关键字可以写可以不写
t.age = 50;
t.id = 10000;
t.name = "王老五";
t.stu.age = 18;
t.stu.name = "小李";
t.stu.score = 80;
cout << "老师的姓名: " << t.name << "老师的编号 " << t.id << "老师的年龄 " <<t.age<< endl;
cout << "小李的姓名: " << t.stu.name << "小李的分数 " << t.stu.score << "小李的年龄 " <<t.stu.age<< endl;
system("pause");
return 0;
}
8.6 结构体做函数参数
//创建一个结构体
struct student {
string name;
int age;
int score;
};
//值传递
void printStudent1(struct student s) {
s.age = 100;
cout << "子函数中 姓名:" << s.name << "年龄:" << s.age << "分数:" << s.score << endl;
}
//地址传递
void printStudent2(struct student * p) {
p->age = 200;
cout << "子函数中 姓名:" <<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;
system("pause");
return 0;
}
总结:如果不想修改主函数中的数据,用值传递,反之用地址传递
8.7 结构体中const使用场景
**作用:**用const来防止误操作
//学生结构体定义
struct student{
//成员列表
string name;
int age;
int score;
};
//const使用场景
//将函数中的形参改为指针,可以减少内存空间,而且不会复制新的副本出来
void printStudent(const student *s){
//s->age = 100;//加了const,一旦修改便会提示操作失败,因为加了const修饰,常量是不可以修改的
cout<<"姓名:"<< s->name << "年龄:"<<s->age<<"分数:"<<s->score<<endl;
}
int main(){
student s={"张三",18,100};//创建结构体变量
printStudent(&s);
system("pause");
return 0;
}
8.8 结构体案例
8.8.1 案例1
案例描述:
每名老师带领5名学生,总共3名老师,需求如下:设计学生和老师的结构体,其中在老师的结构体中,有老师姓名和一个存放5名学生的数组作为成员,学生的成员有姓名,考试分数;创建数组存放3名老师,通过函数给每个老师及所带的学生赋值,最终打印出老师数据以及老师所带的学生数据.
#include<string>
#include<ctime>
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() % 50 + 50;
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 << "学生姓名:" << tArray[i].sArray[j].sName<<
"考试分数:" << tArray[i].sArray[j].score << endl;
}
}
}
int main(){
//随机种子
srand((unsigned)time(NULL));
//创建3名老师的数组
struct teacher tArray[3];
int len = sizeof(tArray) / sizeof(tArray[0]);
allocateSpace(tArray, len);
//打印老师及带学生信息
printInfo(tArray, len);
system("pause");
return 0;
}
8.8.2 案例2
案例描述:
设计一个英雄体的结构,包括成员姓名,年龄,性别;创建结构体数组,数组中存放5名英雄。通过冒泡排序的算法,将数组中的英雄按照年龄进行升序排序,最终打印排序后的结果。
struct hero {
string name;
int age;
string sex;
};
void bubblesort(struct hero p[],int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - i - 1; j++) {
if (p[j].age > p[j + 1].age) {
struct hero temp = p[j]; //创建一个结构体临时变量,拿来存放三个属性
p[j] = p[j + 1];
p[j + 1] = temp;
}
}
}
}
void PrintInfo(struct hero yxArray[], int len) {
for (int i = 0; i < len; i++) {
cout <<"姓名:"<< yxArray[i].name << " 年龄:"<<yxArray[i].age << " 性别:"<<yxArray[i].sex << endl;
}
}
int main(){
struct hero yxArray[5] =
{
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",22,"男"},
{"貂蝉",19,"女"}
};
int len = sizeof(yxArray) / sizeof(yxArray[0]);
bubblesort(yxArray,len);
PrintInfo(yxArray,len);
system("pause");
return 0;
}