C++基础笔记（五） ---函数、指针、结构体

正直和知府

已于 2024-02-13 01:31:48 修改

阅读量983

点赞数 22

分类专栏： C++ 文章标签：学习笔记 c++

于 2024-02-08 00:05:49 首次发布

本文链接：https://blog.csdn.net/m0_46359434/article/details/136034769

版权

C++ 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

1、函数

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

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

1.1函数的定义

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

1、返回值类型：一个函数可以返回一个值，在函数定义中

2、函数名：给函数起个名

3、参数列表：使用该函数时，传入的数据

4、函数体语句：花括号内的代码，函数内需要执行的语句

5、return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

注：如果函数不需要返回值，声明的时候可以写void

语法：

返回值类型 函数名（参数列表）
{
    函数体语句

    return表达式
}

描述：实现一个加法函数，功能：传入两个整型数据，计算数据相加的结果，并且返回

int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

1.2函数的调用

含义：使用定义好的函数

语法：函数名（参数）

#include <iostream>
using namespace std;

//定义加法函数
/*函数定义的时候，num1和num2并没有真实数据，
只是一个形式上的参数，简称形参*/
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

int main()
{
    int a = 10;
    int b = 20;
    //调用加法函数
    //a和b称为实际参数，简称实参
    //当调用函数时，实参的值会传递给形参
    int c = add(a, b);
    cout << "c=" << c << endl;
    system("pause") ;
    return 0;
}

输出结果：

c=30
请按任意键继续. . .

1.3值传递

所谓值传递，就是函数调用时实参将数值传入给形参

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

#include <iostream>
using namespace std;

//定义函数
//如果函数不需要返回值，声明的时候可以写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;
}


int main()
{
    int a = 10;
    int b = 20;
    cout << "传入形参前：" << endl;
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    //调用函数
    swap(a, b);

    cout << "传入形参后：" << endl;
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    system("pause");
    return 0;
}

输出结果如下：

传入形参前：
a=10
b=20
交换前为：
num1=10
num2=20
交换后为：
num1=20
num2=10
传入形参后：
a=10
b=20
请按任意键继续. . .

解释：此程序在执行的过程中，swap函数会给num1、num2和temp开辟新的内存空间，而不影响a，b的内存空间，所以在值传递的过程中，即使形参发生了改变，实参不会改变。

1.4函数的常见样式

常见的函数样式有4种：

1、无参无返

2、有参无返

3、无参有返

4、有参有返

#include <iostream>
using namespace std;

//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 " ;
    return 1000;
}

//4、有参有返
int test04(int a)
{
    cout << "This is test04 a= " << a ;
    return a;
}

int main()
{
    //1、无参无返函数调用
    test01();
    //2、有参无返函数调用
    test02(100);
    //3、无参有返函数调用
    int num1=test03();
    cout << "num1=" << num1 << endl;
    //4、有参有返函数调用
    int num2=test04(10000);
    cout << "num2=" << num2 << endl;

    system("pause") ;
    return 0;
}

输出结果：

This is test01;
This is test02 a=100
This is test03 num1=1000
This is test04 a= 10000num2=10000
请按任意键继续. . .

1.5函数的声明

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

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

#include <iostream>
using namespace std;

//函数的声明，也可以不写
int max(int a, int b);

//定义比较函数，返回两者较大值
int max(int a, int b)
{
    return a > b ? a : b;
}

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

1.6函数的分文件编写

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

函数分文件编写一般有4个步骤：

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

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

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

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

例子如下：

首先在头文件和源文件分别添加新建项swap.h和swap.cpp。

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

主程序：

#include <iostream>
using namespace std;
#include"swap.h"//别忘了调用头文件

int main()
{
    int a = 10;
    int b = 20;
    swap(a, b);//调用函数
    
    system("pause");
    return 0;
}

输出结果：

a=20
b=10
请按任意键继续. . .

2、指针

2.1指针的基本概念

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

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

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

巧记：指针就是一个地址

2.2指针变量的定义和使用

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

使用：可以通过解引用的方式来找到指针指向的内存。

指针前加*代表解引用，找到指针指向的内存中的数据

#include <iostream>
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;

    system("pause") ;
    return 0;
}

输出结果：

a的地址为：009FFA50
指针p为：009FFA50
a=1000
*p=1000
请按任意键继续. . .

2.3指针所占的内存空间

指针就是一个地址，在32位（x86）操作系统下，（int*、float*、double*、char*）都是占用4个字节空间。在64位（x64）操作系统下，（int*、float*、double*、char*）都是占用8个字节空间。

#include <iostream>
using namespace std;

int main()
{
    int a = 10;
    //定义指针
    int* p;
    //让指针记录变量a的地址（这部分在数组有介绍）
    p = &a;

    //以上两句可以等效为下面这句程序
    //int* p = &a;
    
    cout << "sizeof(int*) = " << sizeof(int*) << endl;
    cout << "sizeof(p) = " << sizeof(p) << endl;
    cout << "sizeof(&a) = " << sizeof(&a) << endl;

    system("pause") ;
    return 0;
}

输出结果：

sizeof(int*) = 4
sizeof(p) = 4
sizeof(&a) = 4
请按任意键继续. . .

2.4空指针和野指针

2.4.1空指针

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

用途：初始化指针变量

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

#include <iostream>
using namespace std;

int main()
{
    
    //定义空指针，用于给指针变量进行初始化
    int* p=NULL;//NULL在程序中代表0
    
    //空指针是不能进行访问的
    //0-255之间的内存编号是系统占用的，因此不可以访问
    // 这句程序是不能执行的，会报错
    //*p = 100;

    system("pause") ;
    return 0;
}

2.4.2野指针

含义：将指针变量指向非法的内存空间

/*定义了一个指针，程序虽然不会报错，
但是这个地址是非法的，没有操作权限，
不能进行内存操作*/
int* p = (int*)0x1100;

总结：空指针和野指针都不是我们申请的空间，因此不要访问

2.5 const修饰指针

const修饰指针的三种情况：

2.5.1 const修饰指针------常量指针

//常量指针
const int* p = &a;

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

*p = 20;//错误，指针指向的值不可以改
p = &b;//正确，指针指向可以改

2.5.2 const修饰常量------指针常量

//指针常量
int* const p = &a;

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

*p = 20;//正确，指针指向的值可以改
p = &b;//错误，指针指向不可以改

2.5.3 const既修饰指针，又修饰常量

//指针常量
const int* const p = &a;

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

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

记忆方法：

名称：看const和*谁在前谁在后，比如：1、常量指针（const *）2、指针常量（*const）

谁不能修改：看*和p谁挨着const，谁挨着谁不能进行操作。

2.6指针和数组

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

#include <iostream>
using namespace std;

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    //数组直接访问第一个元素
    cout<<"数组的第一个元素为：" << arr[0] << endl;

    //arr就是数组首地址。前面数组提到相应的知识点
    int* p=arr;
    //利用指针访问数组第一个元素
    cout << "用指针访问 数组的第一个元素为：" << *p << endl;

    //用指针遍历整个数组元素
    int* p1 = arr;
    for (int i = 0; i < 10; i++)
    {
        cout << *p1 << endl;
        p1++;
    }
   
    system("pause") ;
    return 0;
}

输出结果：

数组的第一个元素为：1
用指针访问 数组的第一个元素为：1
1
2
3
4
5
6
7
8
9
10
请按任意键继续. . .

2.7指针和函数

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

#include <iostream>
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;
    //1、值传递，前面函数部分讲解过，形参的传入不改变实参的值
    //swap01(a,b);
    //cout << "a=" << a << endl;
    //cout << "b=" << b << endl;

    //2、地址传递
    //如果是地址传递，可以修饰实参
    swap02(&a, &b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    system("pause") ;
    return 0;
}

输出结果：

a=20
b=10
请按任意键继续. . .

总结：如果不想修改实参，就用值传递。如果想修改实参，就用地址传递。

2.8指针、数组、函数

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

#include <iostream>
using namespace std;

//定义冒泡排序函数（升序排列）。很重要。一定要记住！！！
void bubbleSort(int * arr, int len)
{
    //总共排序轮数为：元素个数-1
    for (int i = 0; i < len-1; i++)
    {
        ///内层循环对比
        //次数=元素个数-当前轮数-1                            
        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 arrPrint(int* arr,int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << endl;
    }
}

int main()
{
    //创建数组
    int arr[10] = {5,8,6,2,3,9,4,7,1,10};
    //得到数组长度，增强程序综合性
    int len = sizeof(arr) / sizeof(arr[0]);
    //调用冒泡排序函数
    bubbleSort(arr,len);
    //调用数组打印函数
    arrPrint(arr,len);

    system("pause") ;
    return 0;
}

输出结果：

1
2
3
4
5
6
7
8
9
10
请按任意键继续. . .

3、结构体

3.1结构体基本概念

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

3.2结构体定义和使用

语法：

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

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

1、struct 结构体名变量名

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

3、定义结构体时顺便创建变量(不推荐使用)

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//1、创建学生的数据类型：包括（姓名，年龄，分数）
//结构体定义时struct关键字不能省略
struct Student
{
    //成员列表
    string name;
    int age;
    int score;
}s3;//直接在此处定义s3

//2、通过学生类型创建具体学生
int main()
{
    //2.1 struct Student s1
    //struct关键字可以省略
    struct Student s1;
    //给s1属性赋值，通过.访问结构体变量中的属性
    s1.name = "张三";
    s1.age = 18;
    s1.score = 100;
    cout << "姓名:" << s1.name << " 年龄:" << s1.age << " 分数:" << s1.score << endl;

    //2.2 struct Student s2={......}
    struct Student s2 = { "李四",19,80 };
    cout << "姓名:" << s2.name << " 年龄:" << s2.age << " 分数:" << s2.score << endl;

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

    system("pause") ;
    return 0;
}

输出结果：

姓名:张三 年龄:18 分数:100
姓名:李四 年龄:19 分数:80
姓名:王五 年龄:20 分数:60
请按任意键继续. . .

3.3结构体数组

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

语法：

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

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//结构体数组

//结构体定义时struct关键字不能省略
//1、创建学生的数据类型：包括（姓名，年龄，分数）
struct Student
{
    //成员列表
    string name;
    int age;
    int score;
};

int main()
{
    //2、创建结构体数组
    struct Student student_arr[3]=
    {
        {"张三",18,100},
        {"李四",28,99},
        {"王五",38,66}
    };

    //3、修改或者单独给某个空的数组的元素赋值
    student_arr[2].name = "赵六";
    student_arr[2].age = 80;
    student_arr[2].score = 60;

    //4、遍历结构体数组
    for (int i = 0; i < 3; i++)
    {
        //太长的话，可以换行，也不会报错
        cout << "姓名:" << student_arr[i].name << " 年龄:" 
            << student_arr[i].age << " 分数:" << student_arr[i].score << endl;
    }
    
    system("pause") ;
    return 0;
}

结果输出：

姓名:张三 年龄:18 分数:100
姓名:李四 年龄:28 分数:99
姓名:赵六 年龄:80 分数:60
请按任意键继续. . .

3.4结构体指针

作用：通过指针访问结构体中的成员

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

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//结构体指针

//结构体定义时struct关键字不能省略
//1、创建学生的数据类型：包括（姓名，年龄，分数）
struct Student
{
    //成员列表
    string name;
    int age;
    int score;
};

int main()
{
    //2、创建学生结构体变量
    //此struct可以省略
    struct Student s = { "张三",18,100 };

    //3、通过指针指向结构体变量
    //此struct可以省略
    struct Student* p = &s;

    //4、通过指针访问结构体变量中的数据
    //利用->这个符号
    cout << "姓名:" << p->name<< " 年龄:" << p->age << " 分数:" << p->score << endl;

    system("pause") ;
    return 0;
}

输出结果：

姓名:张三 年龄:18 分数:100
请按任意键继续. . .

3.5结构体嵌套结构体

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

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

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//结构体嵌套结构体

//结构体定义时struct关键字不能省略
//定义学生结构体：包括（姓名，年龄，分数）
struct Student
{
    //成员列表
    string name;
    int age;
    int score;
};

//定义老师结构体
struct teacher
{
    int id;
    string name;
    int age;
    struct Student stu;//所以要把学生的结构体定义在前面，要不会因为stu报错
};

int main()
{
    //创建老师结构体变量
    struct teacher t;
    t.id = 10086;
    t.name = "Miss Wang";
    t.age = 50;
    t.stu.name = "Peter";
    t.stu.age = 20;
    t.stu.score = 60;

    cout << "老师姓名:" << t.name << "老师ID：" << t.id << " 老师年龄:" << t.age
        << " 老师辅导的学生为:" << t.stu.name << "学生年龄为：" << t.stu.age 
        << "学生分数为：" << t.stu.score << endl;

    system("pause") ;
    return 0;
}

输出结果为：

老师姓名:Miss Wang老师ID：10086 老师年龄:50 老师辅导的学生为:Peter学生年龄为：20学生分数为：60
请按任意键继续. . .

3.6结构体做函数参数

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

传递方式有两种：

1、值传递

2、地址传递

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//结构体做函数参数

//结构体定义时struct关键字不能省略
//定义学生结构体：包括（姓名，年龄，分数）
struct student
{
    //成员列表
    string name;
    int age;
    int score;
};

//打印学生信息函数
//1、值传递
void print_student1(struct student s)
{
    s.age = 88;//修改年龄
    cout << "print_student1函数中打印： 学生姓名:" << s.name
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;
}

//2、地址传递
void print_student2(struct student *p)//注意指针访问属性需要使用->
{
    p->age = 99;//修改年龄
    cout << "print_student2函数中打印： 学生姓名:" << p->name
        << " 学生年龄:" << p->age << " 学生分数:" << p->score << endl;
}

int main()
{
    //创建学生结构体变量
    struct student s = {"张三",18,100};

    //main函数中打印学生信息
    cout << "main函数1中打印 学生姓名:" << s.name 
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;

    //调用值传递函数
    print_student1(s);
    //注意输出的年龄有没有改变
    cout << "main函数2中打印 学生姓名:" << s.name
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;

    //调用地址传递函数
    print_student2(&s);
    //注意输出的年龄有没有改变
    cout << "main函数3中打印 学生姓名:" << s.name
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;



    system("pause") ;
    return 0;
}

输出结果：

main函数1中打印 学生姓名:张三 学生年龄:18 学生分数:100
print_student1函数中打印： 学生姓名:张三 学生年龄:88 学生分数:100
main函数2中打印 学生姓名:张三 学生年龄:18 学生分数:100
print_student2函数中打印： 学生姓名:张三 学生年龄:99 学生分数:100
main函数3中打印 学生姓名:张三 学生年龄:99 学生分数:100
请按任意键继续. . .

结论：值传递不改变实参。地址传递改变实参。

3.7结构体中const使用场景

作用：用const来防止误操作

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//结构体const使用场景

//结构体定义时struct关键字不能省略
//定义学生结构体：包括（姓名，年龄，分数）
struct student
{
    //成员列表
    string name;
    int age;
    int score;
};

//打印学生信息函数
//将函数中的形参改为指针，可以减少内存空间，只占用4个字节，而且不会复制出新的副本出来
//本质就是地址传递
//但是会改变实参的值，所以我们加入了const
void print_student(const struct student *p)//注意指针访问属性需要使用->
{
    //此时已经不允许修改了，只允许读不允许写
    ///加入const后，一旦有修改的操作会报错，可以防止我们的误操作，对结构体属性进行修改
    //p->age = 99;
    cout << "print_student函数中打印： 学生姓名:" << p->name
        << " 学生年龄:" << p->age << " 学生分数:" << p->score << endl;
}

int main()
{
    //创建学生结构体变量
    struct student s = {"张三",18,100};

    //main函数中打印学生信息
    cout << "main函数1中打印 学生姓名:" << s.name 
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;

    //调用值传递函数
    //使用了地址传递
    print_student(&s);
    //注意输出的年龄有没有改变
    cout << "main函数2中打印 学生姓名:" << s.name
        << " 学生年龄:" << s.age << " 学生分数:" << s.score << endl;

    system("pause") ;
    return 0;
}

输出结果：

main函数1中打印 学生姓名:张三 学生年龄:18 学生分数:100
print_student函数中打印： 学生姓名:张三 学生年龄:18 学生分数:100
main函数2中打印 学生姓名:张三 学生年龄:18 学生分数:100
请按任意键继续. . .

具体解释看注释。

3.8结构体案例

3.8.1案例1

案例描述：

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

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值最终打印出老师数据以及老师所带的学生数据。

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件
#include<ctime>//随机数种子用到了time，但是不声明此头文件好像也不报错

//案例1

//结构体定义时struct关键字不能省略
//定义学生结构体
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() % 100 + 1;//给每位学生产生随机成绩1-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];
    //计算数组长度
    int len = sizeof(tArray) / sizeof(tArray[0]);
    //通过函数给3名老师的信息赋值，并给老师带的学生赋值
    allocateSpace(tArray,len);
    //打印所有老师及所带的学生信息
    printInfo(tArray, len);

    system("pause");
    return 0;
}

输出结果：

老师姓名：Teacher_A
        学生姓名：Student_A 学生成绩：75
        学生姓名：Student_B 学生成绩：50
        学生姓名：Student_C 学生成绩：13
        学生姓名：Student_D 学生成绩：59
        学生姓名：Student_E 学生成绩：35
老师姓名：Teacher_B
        学生姓名：Student_A 学生成绩：37
        学生姓名：Student_B 学生成绩：14
        学生姓名：Student_C 学生成绩：78
        学生姓名：Student_D 学生成绩：56
        学生姓名：Student_E 学生成绩：10
老师姓名：Teacher_C
        学生姓名：Student_A 学生成绩：92
        学生姓名：Student_B 学生成绩：33
        学生姓名：Student_C 学生成绩：27
        学生姓名：Student_D 学生成绩：56
        学生姓名：Student_E 学生成绩：17
请按任意键继续. . .

3.8.2案例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。
五名英雄信息如下:
{“刘备”,23,“男”}，{“关羽”,22,"男"}，{"张飞”,20,“男”}，{“赵云”,21,“男”}，{"貂蝉”,19,"女”}

#include <iostream>
using namespace std;
#include<string>//使用string要声明此头文件

//案例2

//结构体定义时struct关键字不能省略
//定义学生结构体
struct Hero
{   //成员列表
    string name;
    int age;
    string sex;
};

//冒泡排序，对数组年龄进行升序排列
void bubbleSort(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 printHero(struct Hero heroArray[],int len)
{
    cout << "冒泡排序后:" << endl;
    for (int i = 0; i < len; i++)
    {
        cout << "英雄名字：" << heroArray[i].name << " 英雄年龄："
            << heroArray[i].age << " 性别：" << heroArray[i].sex << endl;
    }
}

int main()
{
    //创建英雄数组
    struct Hero heroArray[5] =
    {
        {"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"}
    };
    //计算数组长度
    int len = sizeof(heroArray) / sizeof(heroArray[0]);

    //冒泡排序前输出数组
    cout << "冒泡排序前:" << endl;
    for (int i = 0; i < len; i++)
    {
        cout << "英雄名字：" << heroArray[i].name << " 英雄年龄：" 
            << heroArray[i].age << " 性别：" << heroArray[i].sex << endl;
    }

    //对数组进行冒泡排序，按照年龄进行升序排序
    bubbleSort(heroArray,len);

    //打印排序后的数组信息
    printHero(heroArray, len);

    system("pause");
    return 0;
}

输出结果：

冒泡排序前:
英雄名字：刘备 英雄年龄：23 性别：男
英雄名字：关羽 英雄年龄：22 性别：男
英雄名字：张飞 英雄年龄：20 性别：男
英雄名字：赵云 英雄年龄：21 性别：男
英雄名字：貂蝉 英雄年龄：19 性别：女
冒泡排序后:
英雄名字：貂蝉 英雄年龄：19 性别：女
英雄名字：张飞 英雄年龄：20 性别：男
英雄名字：赵云 英雄年龄：21 性别：男
英雄名字：关羽 英雄年龄：22 性别：男
英雄名字：刘备 英雄年龄：23 性别：男
请按任意键继续. . .