C++基础入门（超详细）

文章目录
C++基础入门
1 C++初识
1.1 第一个C++程序
1.2 注释
1.3 变量
1.4 常量
1.5 关键字
1.6 标识符命名规则
2、数据类型
2.1 整型
2.2 sizeof关键字
2.3 实型（浮点型）
2.4 字符型
2.5 转义字符
2.6 字符串型
2.7 布尔类型bool
2.8 数据的输入
3、运算符
3.1 算术运算符
3.2 赋值运算符
3.3 比较运算符
4 程序流程结构
4.1 选择结构
4.1.1 if语句
4.1.2 三目运算符
4.1.3 switch语句
4.2 循环结构
4.2.1 while循环语句
4.2.2 do...while循环语句
4.2.3 for循环语句
4.2.4 嵌套循环
4.3 跳转语句
4.3.1 break语句
4.3.2 continue语句
4.3.3 goto语句
5.数组
5.1 概述
5.2 一维数组
5.2.2一维数组数组名
5.3 二维数组
6 函数
6.1 概述
6.2 函数的定义
6.3 值传递
6.5 函数的常见形式
6.6 函数的声明
6.7 函数的分文件编写
7 指针
7.1 指针的基本概念
7.2 指针变量的定义和使用
7.3 指针所占用内存空间
7.4 空指针和野指针
7.5 const修饰指针
7.6 指针和数组
7.7 指针和函数
7.8 案例：利用冒泡升序排序
8 结构体
8.1 结构体基本概念
8.2 结构体的定义和使用
8.3 结构体数组
8.4 结构体指针
8.5 结构体嵌套结构体
8.6 结构体做函数参数
8.7 结构体中const使用场景
C++基础入门
1 C++初识
1.1 第一个C++程序
#include
using namespace std;
int main()
{
    cout << "hello world" << endl;
    system("pause");

    return 0;
}
1
2
3
4
5
6
7
8
9
1.2 注释
单行注释：//

多行注释：/**/

1.3 变量
数据类型 变量名 = 变量初始值；

1.4 常量
（1）作用：记录程序中不可更改的数据

（2）定义常量的两种方式：

#define 宏常量：#define 常量名 常量值（通常定义在文件上方，一旦修改就会报错）
const修饰的变量：const 数据类型 常量名=常量值（通常在变量定义前加关键字const)
1.5 关键字
说明：在定义变量或者常量的时候，不能使用关键字

double\int\long\......
1
1.6 标识符命名规则
说明：给变量起名的时候要做到见名知意

（1）标识符不能是关键字

（2）标识符只能由字母、数字、下划线

（3）第一个字符必须是字符或者下划线

（4）标识符中区分大小写

2、数据类型
说明：数据类型存在的意义是给变量分配合适的内存空间

2.1 整型
区别：在于所占内存空间不同

//短整型(-32768~32767)
    short num1 = 32769;//输出就是一个负数-32768
    //整型
    int num2 = 10;
    //长整型
    long num3 = 10;
    //长长整型
    long long num4 = 10;
    cout << "num1= " << num1 << endl;
    cout << "num2= " << num2 << endl;
    cout << "num3= " << num3 << endl;
    cout << "num4= " << num4 << endl;
1
2
3
4
5
6
7
8
9
10
11
12
2.2 sizeof关键字
作用：利用sizeof关键字统计数据类型所占内存大小

b = sizeof(a);
1
2.3 实型（浮点型）
作用：表示小数

两种表示形式：

1、单精度： float；占用空间：4字节；有效数字范围：7位有效数字
2、双精度：double；占用空间：8字节；有效数字范围：15~16位有效数字
float f1 = 3.14f;//不加f会默认double类型的，会多一步转化
    cout << f1 << endl;
    double d1 = 3.14;
    cout << d1 << endl;
    //统计float和double所占内存空间
    cout <<"float占用的内存空间："<< sizeof(float) << endl;
    cout << "double占用的内存空间：" << sizeof(double) << endl;
    //科学计数法
    float f2 = 3e2;//3*10^2;
    cout << "f2=" << f2 << endl;
    float f3 = 3e-2;//3*0.1^2;
    cout << "f3=" << f3 << endl;
1
2
3
4
5
6
7
8
9
10
11
12
2.4 字符型
作用：显示单个字符，只占用1个字节

语法：char ch=‘a’;

//1、字符型变量创建方式
    char ch = 'a';
    cout << ch << endl;
    //2、字符型变量所占内存空间大小
    cout << "char字符型所占内存：" << sizeof(ch) << endl;
    //3、字符型变量对应的ASCII编码
    cout << (int)ch << endl;

1
2
3
4
5
6
7
8
2.5 转义字符
作用：表示一些不能显示出来的ASCII字符

\n：换行
\t：水平制表：\t占用8个字符，如aaa+5个空格；aaaa+4个空格
\ \：代表反斜线字符“\”
2.6 字符串型
两种形式：

C：char 变量名[ ]=“字符串值”
C++：string 变量名= “字符串值”
//C风格
    char str[] = "hello world";
    cout << str << endl;
    //C++风格
    string ss = "hello C++";  //需要一个#include头文件
    cout << ss << endl;
1
2
3
4
5
6
2.7 布尔类型bool
作用：代表真和假的值

bool类型只有两个值，占1个字节大小

true：真（本质是1）//非0的值都代表着真
false：假（本质是0）
//1、创建bool类型
    bool flag = true;
    bool flag1 = false;
    cout << flag << endl;
    cout << flag1 << endl;
    //2、查看内存空间
    cout << "bool类型所占的内存空间：" << sizeof(flag) << endl;
1
2
3
4
5
6
7
2.8 数据的输入
关键字：cin>>变量，从键盘上获取数据

cout << "请输入a的值：" << endl;
cin >> a;
1
2
3、运算符
3.1 算术运算符
注意：

两数相除，除数不可以为0
两个小数不可以进行取模运算
3.2 赋值运算符

3.3 比较运算符

4 程序流程结构
顺序结构：程序按照顺序执行，不发生跳转
选择结构：依据条件是否满足，有选择的执行相应的功能
循环结构：依据条件是否满足，循环多次执行某段代码
4.1 选择结构
4.1.1 if语句
#include
using namespace std;
int main()
{
    system("color 5F");
    cout << "请输入一个分数：" << endl;
    int score;
    cin >> score;
    //注意：if条件后面不要加分号
    if (score > 600)
        printf("你考上一本大学\n");
    else if(score>500)
        printf("你考上了二本\n");
    else
        printf("你什么都没有考上，二战吧\n");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
嵌套的if语句：

案例需求：如果上述大于600考上了一本大学，如果分数大于650就可以考上双一流

    if (score > 600)
    {
        printf("你考上一本大学\n");
        if (score > 650)
        {
            printf("可以上双一流了\n");
        }
    }
    else if (score > 500)
        printf("你考上了二本\n");
    else
        printf("你什么都没有考上，二战吧\n");
1
2
3
4
5
6
7
8
9
10
11
12
4.1.2 三目运算符
int a = 10;
    int b = 20;
    int c = 0;
    c = (a > b ? a : b);
    cout << "c= " << c << endl;
    //C++中三目运算符返回的是变量，可以继续赋值
    (a > b ? a : b) = 66;
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
1
2
3
4
5
6
7
8
9

4.1.3 switch语句
语法：

switch(表达式)
{
    case 结果1：执行语句；break；
    case 结果2：执行语句；break;
    ....
    default:执行语句；break;
}
1
2
3
4
5
6
7
示例：给电影打分

cout << "请给电影打分：" << endl;
    int score = 0;
    cin >> score;
    switch (score)
    {
        case 3: cout << "你打的电影评分是：" << score << endl; break;
        case 6: cout << "你打的电影评分是：" << score << endl; break;
        case 9: cout << "你打的电影评分是：" << score << endl; break;
        case 4: cout << "你打的电影评分是：" << score << endl; break;
        default:cout << "你打的是其他分数：" << score << endl; break;

    }
1
2
3
4
5
6
7
8
9
10
11
12
4.2 循环结构
4.2.1 while循环语句
语法：while（循环条件）{循环语句}

注意：了解循环条件，避免死循环

//在屏幕打印0-9
    int num = 0;
    while (num < 10)
    {
        cout << num << endl;
        num++;
    }
1
2
3
4
5
6
7

4.2.2 do…while循环语句
语法：do{循环语句}while{循环条件}与while的区别是先执行一次循环语句，再判断循环条件

int num = 0;
do
{
    cout << num << endl;
    num++;
} while (num < 10);
1
2
3
4
5
6
4.2.3 for循环语句
语法：for(起始表达式；条件表达式；末尾循环体){ 循环语句；}

//在屏幕打印0-9
for (int i = 0; i < 10; i++)
{
    cout << i << endl;
}
1
2
3
4
5
4.2.4 嵌套循环
作用：循环中再加一层循环

    //在屏幕打印10x10的*阵
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            cout <<"* ";
        }
        cout << endl;
    }
1
2
3
4
5
6
7
8
9

示例：打印乘法口诀表

#include
using namespace std;
int main()
{
    system("color 5F");
    for (int i = 1; i < 10; i++)
    {
        for (int j = 1; j <=i; j++)
        {
            cout << j << " x " << i << " = " << (i*j)<<"  ";
        }
        cout << endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.3 跳转语句
4.3.1 break语句
作用：结束循环

    //在屏幕打印10x5的*阵
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            if(j==5)
                break;
            cout <<"* ";
        }
        cout << endl;
    }
1
2
3
4
5
6
7
8
9
10
11
4.3.2 continue语句
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

//在屏幕输出10以内偶数
    for (int i = 0; i < 10; i++)
    {
        if (i % 2 != 0)
            continue;
        cout << i << endl;
    }
1
2
3
4
5
6
7

4.3.3 goto语句
作用：goto标记之后，跳转到标记的语句

#include
using namespace std;
int main()
{
    system("color 5F");
    //执行goto语句
    cout << "1.xxxxx" << endl;
    goto Flag;
    cout << "2.xxxxx" << endl;

    cout << "3.xxxxx" << endl;

    cout << "4.xxxxx" << endl;
    Flag:
    cout << "5.xxxxx" << endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

5.2 一维数组
1、定义方式

数据类型 数组名[数组长度];
数据类型 数据名[数组长度]={值1，值2…};
数据类型 数组名[ ]={值1，值2…};
2、数组特点

放在一块连续的内存空间，数组中每个元素都是相同的数据类型。

int main()
{
    system("color 5F");
    //1、数据类型 数组名[数组长度];
    int arr[5];
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    arr[4] = 50;
    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
    //2、数据类型 数据名[数组长度]={值1，值2.....};
    //若初始化没有五个数据，剩下的将会由0填补
    int arr1[5] = { 10,20,30,40};
    for (int i = 0; i < 5; i++)
    {
        cout << arr1[i] << " ";
    }
    cout << endl;
    //3、数据类型 数组名[ ]={值1，值2.....};
    int arr3[] = { 1,2,3,4,5 ,6,5,8,9};
    for (int i = 0; i < 9; i++)
    {
        cout << arr3[i] << " ";
    }
    cout << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

5.2.2一维数组数组名
用途：

统计整个数组在内存中的长度
可以获取数组在内存中的首地址
#include
using namespace std;
int main()
{
    system("color 5F");
    int arr[5] = { 1,2,3,4,5 };
    //1、通过数组名统计整个数组占用内存大小
    cout << "每个数组占用内存空间大小："<     cout << "每个元素所占用的内存空间大小：" << sizeof(arr[0]) << endl;
    cout << "数组中元素的个数为：" << sizeof(arr)/ sizeof(arr[0]) << endl;
    //2、通过数组名查看首地址
    cout << "数组首地址为：" << (int)arr << endl;
    cout << "数组中第一个元素地址：" << (int)&arr[1] << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习案例：数组元素逆置

请声明一个5个元素的数组，并且将元素逆置

#include
using namespace std;
int main()
{
    system("color 5F");
    int arr[5] = { 1,2,3,4,5 };
    //1、数组逆置前序列
    cout << "数组逆置前序列:" << endl;
    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }
    cout << 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] << " ";
    }
    cout << endl;

    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

5.3 二维数组
1、二维数组的四种定义类型：

数据类型 数组名[行数] [列数];
数据类型 数组名[行数] [列数]={{数据1，数据2}，{数据3，数据4}}；
数据类型 数组名[行数] [列数]={数据1，数据2，数据3，数据4}；
数据类型 数组名[ ] [列数]={数据1，数据2，数据3，数据4}；
#include
using namespace std;
int main()
{
    system("color 5F");
    /*
        - 数据类型 数组名[行数] [列数];
        - 数据类型 数组名[行数] [列数]={{数据1，数据2}，{数据3，数据4}}；
        - 数据类型 数组名[行数] [列数]={数据1，数据2，数据3，数据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] = 5;
    arr[1][2] = 6;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    //2、数据类型 数组名[行数] [列数]={{数据1，数据2}，{数据3，数据4}}；
    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 << arr[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    //3、数据类型 数组名[行数] [列数]={数据1，数据2，数据3，数据4}；
    int arr3[2][3] = { 1,2,3,4,5,6 };
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    //4、数据类型 数组名[ ] [列数]={数据1，数据2，数据3，数据4}；
    int arr4[][3] = { 1,2,3,4,5,6 };
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
2、二维数组数组名

int arr[2][3]=
    {
        {1,2,3},
        {4,5,6}
    };
    //1、查看占用内存空间大小
    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;
    //2、查看二维数组的首地址
    cout << " 二维数组首地址: " << (int)arr << endl;
    cout << " 二维数组第一行元素首地址: " << (int)arr[0] << endl;
    cout << " 二维数组第二行元素首地址: " << (int)arr[1] << endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6 函数
6.1 概述
说明：将一段经常使用的代码封装起来，减少代码重复

6.2 函数的定义
步骤：

1、返回值类型
2、函数名
3、参数列表
4、函数体语句
5、return表达式
返回值类型 函数名 （参数列表）
{
    函数体语句；
    return 表达式；
}
1
2
3
4
5
#include
using namespace std;
int add(int num1, int num2)
{
    //num1、num2没有真正的数据。是一个形式参数，也叫形参
    int sum = num1 + num2;
    return sum;
}
int main()
{
    system("color 5F");
    //a、b有实际的值，叫实参
    //当函数调用时，实参的值会传递给形参
    int a, b;
    cin >> a >> b;
    cout <     cout << "num1=" << num1 << endl;
    cout << "num2=" << num2 << endl;
    int temp;
    temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "交换后：" << endl;
    cout << "num1=" << num1 << endl;
    cout << "num2=" << num2 << endl;

}
int main()
{
    system("color 5F");
    int a = 10, b = 20;
    //当做值传递的时候，函数的形参发生改变，不会影响实参
    swap(a, b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
6.5 函数的常见形式
1、无参无返
2、有参无返
3、无参有返
4、有参有返
#include
using namespace std;
//1、无参无返
void test01()
{
    cout << "this is 01" << endl;
}
//2、有参无返
void test02(int a)
{
    cout << "this is 02 a=" << a << endl;
}
//3、无参有返
int test03()
{
    cout << "this is 03" << endl;
    return 666;
}
//4、有参有返
int test04(int a)
{
    cout << "this is 04 a=" << a << endl;
    return 888;
}
int main()
{
    system("color 5F");
    //无参无返函数调用
    test01();
    //有参无返函数调用
    test02(3);
    //无参有返函数调用
    int num = test03();
    cout << "无参有返的num=" << num << endl;
    //有参有返函数调用
    cout << "有参有返的num=" << test04(20) << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

6.6 函数的声明
作用：提前告诉编译器函数的存在，声明可以写多次，定义只能写一次。声明是说明存在这个函数，定义是说明这个函数如何写。

6.7 函数的分文件编写
作用：让代码结构更加清晰

步骤：

1、创建后缀名为.h的头文件
2、创建后缀名为.cpp的源文件
3、在头文件中写函数的声明
4、在源文件中写函数的定义
//在头文件中写函数的声明
#pragma once
#include
using namespace std;
//函数声明
void swap(int a, int b);

1
2
3
4
5
6
7
//在源文件中写函数的定义
#include"swap.h"  //双引号是自定义头文件
void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
}
1
2
3
4
5
6
7
8
9
10
//调用之后直接运行
#include
#include"swap.h"
using namespace std;
int main()
{
    system("color 5F");
    int a = 10;
    int b = 20;
    swap(a, b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
7 指针
7.1 指针的基本概念
作用：可以通过指针间接访问内存

内存编号从0开始记录，一般用十六进制数字表示
可以利用指针变量保存地址
7.2 指针变量的定义和使用
指针定义语法： 数据类型 * 变量名；

#include
using namespace std;
int main()
{
    system("color 5E");
    //1、定义指针
    int a = 10;

    //指针定义的语法：数据类型 * 指针变量名
    int * p;
    //让指针记录变量a的地址
    p = &a;
    cout << "a的地址为：" << p << endl;
    //2、使用指针
    //可以通过解引用的方式来找到指针指向的内存
    //指针前加*代表解引用，找到指针指向的内存中的数据
    cout << "a的值是：" << *p << endl;
    if (a == *p)
        cout << "一样" << endl;
    else
        cout << "不一样" << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7.3 指针所占用内存空间
问： 指针也是种数据类型，那么占用多少内存呢？

答： 在32位操作系统下：占4个字节空间；在64为操作系统：占8个字节

#include
using namespace std;
int main()
{
    system("color 5E");
    int a = 10;
    int *p;
    p = &a;
    cout << "sizeof(int *)=" << sizeof(int *) << endl;
    cout << "sizeof(double *)=" << sizeof(double *) << endl;
    cout << "sizeof(char *)=" << sizeof(char *) << endl;
    cout << "sizeof(float *)=" << sizeof(float *) << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.4 空指针和野指针
（1）空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

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

（2）野指针：指针变量指向非法的内存空间

7.5 const修饰指针
const修饰指针有三种情况：

（1）const修饰指针：常量指针

const int *p=&a;
1
特点：指针的指向可以修改，但是指针指向的值不可以修改

*p=20（×）

p=&b（√）

（2）const修饰常量：指针常量

int * const p=&a;
1
特点：指针指向不可以改，指针指向的值可以改

*p=20（√）

p=&b（×）

（3）const即修饰指针又修饰常量

const int * const p=&a;
1
特点：指针指向不可以改，指针指向的值也不可以改

*p=20（x）

p=&b（×）

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

    int arr[10] = { 1,2,3,4,5,6,7,8,9 };
    int *p = arr;//arr就是数组的首地址
    cout << "利用指针指向第一个元素：" << *p << endl;
    p++;//指针偏移4个字节
    cout << "利用指针指向第二个元素：" << *p << endl;
    for(int i=2;i<10;i++)
    {
        cout << *p << " ";
        p++;
    }
1
2
3
4
5
6
7
8
9
10
7.7 指针和函数
作用：利用指针作为函数参数，可以修改实参的值

#include
using namespace std;
void swap(int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    cout << "swap *p1=" << *p1 << endl;
    cout << "swap *p2=" << *p2 << endl;
}
int main()
{
    system("color 5E");
    //地址传递
    int a = 10;
    int b = 20;
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
    swap(&a, &b);
    cout << endl << "交换后的a,b的值：" << endl;
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7.8 案例：利用冒泡升序排序
序列：int arr[10] = { 4,2,3,6,1,8,7,9,5,1 };

#include
using namespace std;
void bubbleSort(int *arr, int len)
{
    for (int i = 0; i < len; 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;
            }
                    
        }
    }
        
}
int main()
{
    //system("color 1E");
    //创建一个数组
    int arr[ ] = { 4,2,3,6,1,5,8,7,9,1 };
    //求数组的长度
    int len = sizeof(arr) / sizeof(arr[0]);
    //排序前的序列
    cout << "排序前的序列:" << endl;
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";
    cout << endl;
    //利用冒泡排序
    bubbleSort(arr, len);
    cout << "排序后的序列:" << endl;
    for (int i = 0; i < len ; i++)
        cout << arr[i] << " ";
    cout << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

8 结构体
8.1 结构体基本概念
结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。

8.2 结构体的定义和使用
语法：struct 结构体名 {结构体成员列表};

结构体创建的方式三种：

（1）struct 结构体名 变量名
（2）struct 结构体名 变量名={成员1值，成员2值…}
（3）定义结构体是顺便创建变量
#include
#include
using namespace std;
//创建学生数据类型：学生包括（姓名，年龄，分数）
struct Student
{
    //成员列表

    //姓名
    string name;
    //年龄
    int age;
    //分数
    int score;
}s3;  //3、定义结构体是顺便创建变量

int main()
{
    system("color 5E");
    //1、struct 结构体名 变量名
    struct Student s1;
    s1.name = "张铁蛋";
    s1.age= 23;
    s1.score = 100;
    cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
    //2、struct 结构体名 变量名={成员1值，成员2值......}
    struct Student s2 = { "徐铁柱",24,100 };
    cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

    s3.name = "憨憨";
    s3.age = 23;
    s3.score = 99;
    cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

注意：结构体定义的时候不能省略struct，创建变量的时候可以省略

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

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

int main()
{
    system("color 5E");
    //创建结构体数组
    struct Student arr[3] =
    {
        {"张铁蛋",18,100},
        {"徐铁住",23,99},
        {"憨憨",22,90}
    };
    arr[2].name = "徐傻傻";
    for(int i=0;i<3;i++)
        cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" <<             arr[i].score << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
8.4 结构体指针
作用：通过指针访问结构体中的成员

利用操作符“->”可以通过结构体指针访问结构体属性
    //创建结构体变量
    struct student s = { "张三",18,100 };
    //通过指针指向结构体变量
    struct student *p=&s;
    //通过指针访问结构体中的数据
    p->name = "铁蛋";
    cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
1
2
3
4
5
6
7
8.5 结构体嵌套结构体
作用：结构体的成员可以是另一个结构体

如：每个老师辅导一个学员，一个老师是一个结构体，记录一个学生结构体

#include
#include
using namespace std;
//定义学生结构体
struct student
{
    int num;//学号
    string name;
    int age;
};
//定义老师结构体
struct teacher
{
    int id;
    string name;
    int age;
    struct student stu;
};
int main()
{
    system("color 5E");
    //创建老师、学生
    teacher ter = { 2311,"王老师",35,{20180505,"张三",22} };
    cout << "老师的编号：" << ter.id << endl;
    cout << "老师的名字：" << ter.name << endl;
    cout << "老师的年龄：" << ter.age << endl;
    cout << "老师的学生学号：" << ter.stu.num << endl;
    cout << "老师的学生的名字：" << ter.stu.name << endl;
    cout << "老师的学生的年龄：" << ter.stu.age << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

8.6 结构体做函数参数
作用：将结构体作为参数向函数中传递

传递的方式：

值传递
地址传递
#include
#include
using namespace std;
//定义学生结构体
struct student
{
    string name;
    int age;
    int score;
};
//值传递
void printStudent(struct student s)
{
    s.age = 55;
    cout << "子函数1打印的结果：" << endl;
    cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}
//地址传递
void printfStudent1(struct student *s)
{
    cout << "子函数2打印的结果：" << endl;
    cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
    s->name = "张铁蛋";
    s->score = 999;

}
int main()
{
    system("color 5E");
    student s = { "张三",23,99 };
    printStudent(s);
    cout << "main打印的结果：" << endl;
    cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
    cout << endl;
    printfStudent1(&s);
    cout << "main打印的结果：" << endl;
    cout << "姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

8.7 结构体中const使用场景
作用：用const来防止误操作

#include
#include
using namespace std;
//定义学生结构体
struct student
{
    string name;
    int age;
    int score;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本
void printStudent(const struct student *s)
{
    //s->age = 55;
    //加入const之后，一旦有修改的操作就会报错，防止误操作
    cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
}
int main()
{
    system("color 5E");
    student s = { "张三",23,99 };
    //只读，不可修改
    printStudent(&s);
    return 0;
}