C语言基础知识整理

在线课程

黑马：

C++开发全套教程 网盘链接：https://pan.baidu.com/s/1vTXgoXql0JZIuThKIMJJCA 提取码：1234

浙大翁恺[C语言程序设计]

https://www.icourse163.org/course/ZJU-9001

数据类型

整型

sizeof

用法sizeof(type/var)

实型

在默认情况下，输出一个小数，最多显示6位有效数字

    float f1 = 3.14f; // 默认会当作double,因此要添加f作为提示
    cout << "f1 = " << f1 << endl;    //f1 = 3.14159

    double d1 = 3.14;
    cout << "d1 = " << d1 << endl;    //d1 = 3.14159

科学计数法

    float f3 = 3e2; // 3 * 10^2
    float f4 = 3e-2;// 3 * -0.1^2
    cout << "f3 = " << f3 << endl;  //f3 = 300
    cout << "f4 = " << f4 << endl;  //f4 = 0.03

字符型

语法：char ch = 'a';

• c和c++中字符型变量只占用1个字节。
• 字符型变量将ASCII编码放入到存储单元。
• 单引号内只能有一个字符

在字符变量前添加（int）即可查看对应的ASCII编码。

字符型变量对应的ASCII编码：

• a 75
• A 97

转译字符

作用 ：用于表示一些==不能显示出来的ASCII字符==

现阶段我们常用的转义字符有：\n \\ \t

字符串

用双引号包含

c风格

==char str[] = "value"==

c++风格

==string str = "value"==

使用前需要引入

#include <string>

布尔类型

占用1B

本质上否为0,真为1(任何非0的数值都为真)

bool flag = true;
cout << flag << endl;// 1

// if flag = false, it would be 0

运算符

作用：用于执行代码的运算

本章我们主要讲解以下几类运算符：

算术运算符

作用：用于处理四则运算

算术运算符包括以下符号：

示例1：

//加减乘除
int main() {

    int a1 = 10;
    int b1 = 3;

    cout << a1 + b1 << endl;
    cout << a1 - b1 << endl;
    cout << a1 * b1 << endl;
    cout << a1 / b1 << endl;  //两个整数相除结果依然是整数

    int a2 = 10;
    int b2 = 20;
    cout << a2 / b2 << endl; 

    int a3 = 10;
    int b3 = 0;
    //cout << a3 / b3 << endl; //报错，除数不可以为0


    //两个小数可以相除
    double d1 = 0.5;
    double d2 = 0.25;
    cout << d1 / d2 << endl;

    system("pause");

    return 0;
}

总结：在除法运算中，除数不能为0

示例2：

//取模
int main() {

    int a1 = 10;
    int b1 = 3;

    cout << 10 % 3 << endl;

    int a2 = 10;
    int b2 = 20;

    cout << a2 % b2 << endl;

    int a3 = 10;
    int b3 = 0;

    //cout << a3 % b3 << endl; //取模运算时，除数也不能为0

    //两个小数不可以取模
    double d1 = 3.14;
    double d2 = 1.1;

    //cout << d1 % d2 << endl;

    system("pause");

    return 0;
}

总结：只有整型变量可以进行取模运算

示例3：

//递增
int main() {

    //后置递增
    int a = 10;
    a++; //等价于a = a + 1
    cout << a << endl; // 11

    //前置递增
    int b = 10;
    ++b;
    cout << b << endl; // 11

    //区别
    //前置递增先对变量进行++，再计算表达式
    int a2 = 10;
    int b2 = ++a2 * 10;
    cout << b2 << endl;

    //后置递增先计算表达式，后对变量进行++
    int a3 = 10;
    int b3 = a3++ * 10;
    cout << b3 << endl;

    system("pause");

    return 0;
}

总结：前置递增先对变量进行++，再计算表达式，后置递增相反

赋值运算符

作用：用于将表达式的值赋给变量

赋值运算符包括以下几个符号：

示例：

int main() {

    //赋值运算符

    // =
    int a = 10;
    a = 100;
    cout << "a = " << a << endl;

    // +=
    a = 10;
    a += 2; // a = a + 2;
    cout << "a = " << a << endl;

    // -=
    a = 10;
    a -= 2; // a = a - 2
    cout << "a = " << a << endl;

    // *=
    a = 10;
    a *= 2; // a = a * 2
    cout << "a = " << a << endl;

    // /=
    a = 10;
    a /= 2;  // a = a / 2;
    cout << "a = " << a << endl;

    // %=
    a = 10;
    a %= 2;  // a = a % 2;
    cout << "a = " << a << endl;

    system("pause");

    return 0;
}

比较运算符

作用： 用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

示例：

int main() {

    int a = 10;
    int b = 20;

    cout << (a == b) << endl; // 0 

    cout << (a != b) << endl; // 1

    cout << (a > b) << endl; // 0

    cout << (a < b) << endl; // 1

    cout << (a >= b) << endl; // 0

    cout << (a <= b) << endl; // 1

    system("pause");

    return 0;
}

注意：C和C++ 语言的比较运算中， ==“真”用数字“1”来表示， “假”用数字“0”来表示。==

逻辑运算符

作用： 用于根据表达式的值返回真值或假值

逻辑运算符有以下符号：

示例1： 逻辑非

//逻辑运算符  --- 非
int main() {

    int a = 10;

    cout << !a << endl; // 0

    cout << !!a << endl; // 1

    system("pause");

    return 0;
}

总结： 真变假，假变真

示例2： 逻辑与

//逻辑运算符  --- 与
int main() {

    int a = 10;
    int b = 10;

    cout << (a && b) << endl;// 1

    a = 10;
    b = 0;

    cout << (a && b) << endl;// 0 

    a = 0;
    b = 0;

    cout << (a && b) << endl;// 0

    system("pause");

    return 0;
}

总结：逻辑==与==运算符总结： ==同真为真，其余为假==

示例3： 逻辑或

//逻辑运算符  --- 或
int main() {

    int a = 10;
    int b = 10;

    cout << (a || b) << endl;// 1

    a = 10;
    b = 0;

    cout << (a || b) << endl;// 1 

    a = 0;
    b = 0;

    cout << (a || b) << endl;// 0

    system("pause");

    return 0;
}

逻辑==或==运算符总结： ==同假为假，其余为真==

程序流程

switch语句

作用： 执行多条件分支语句

语法：

switch(表达式)

{

    case 结果1：执行语句;break;

    case 结果2：执行语句;break;

    ...

    default:执行语句;break;

}

示例：

int main() {

    //请给电影评分 
    //10 ~ 9   经典   
    // 8 ~ 7   非常好
    // 6 ~ 5   一般
    // 5分以下 烂片

    int score = 0;
    cout << "请给电影打分" << endl;
    cin >> score;

    switch (score)
    {
    case 10:
    case 9:
        cout << "经典" << endl;
        break;
    case 8:
        cout << "非常好" << endl;
        break;
    case 7:
    case 6:
        cout << "一般" << endl;
        break;
    default:
        cout << "烂片" << endl;
        break;
    }

    system("pause");

    return 0;
}

注意1：switch语句中表达式类型只能是整型或者字符型

注意2：case里如果没有break，那么程序会一直向下执行

总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

do…while循环语句

作用： 满足循环条件，执行循环语句

语法： do{ 循环语句 } while(循环条件);

注意： 与while的区别在于==do…while会先执行一次循环语句==，再判断循环条件

示例：

int main() {

    int num = 0;

    do
    {
        cout << num << endl;
        num++;

    } while (num < 10);


    system("pause");

    return 0;
}

总结：与while循环区别在于，do…while先执行一次循环语句，再判断循环条件

while输出0～9

示例：

int main() {

    int num = 0;
    while (num < 10)
    {
        cout << "num = " << num << endl;
        num++;
    }

    system("pause");

    return 0;
}

注意：在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环

水仙花数

//案例描述：水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身

//例如：1^3 + 5^3+ 3^3 = 153

//请利用do...while语句，求出所有3位数中的水仙花数
#include <iostream>
#include <math.h>
using namespace std;

int main()
{
    int i = 100;
    do
    {
        int hundredsPlace = i / 100;
        int tensPlace = (i % 100) / 10;
        int onesPlace = i % 10;
        if (pow(hundredsPlace, 3) + pow(tensPlace, 3) + pow(onesPlace, 3) == i)
        {
            cout << i << endl;
        }
        i++;

    } while (i < 1000);
}

goto语句

作用： 可以无条件跳转语句

语法： goto 标记;

解释： 如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

示例：

int main() {

    cout << "1" << endl;

    goto FLAG;

    cout << "2" << endl;
    cout << "3" << endl;
    cout << "4" << endl;

    FLAG: //使用：号来指定这是标记

    cout << "5" << endl;

    system("pause");

    return 0;
}

注意：在程序中不建议使用goto语句，以免造成程序流程混乱

数组

一维数组

一维数组定义方式

一维数组定义的三种方式：

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

示例

int main() {

    //定义方式1
    //数据类型 数组名[元素个数];
    int score[10];

    //利用下标赋值
    score[0] = 100;
    score[1] = 99;
    score[2] = 85;

    //利用下标输出
    cout << score[0] << endl;
    cout << score[1] << endl;
    cout << score[2] << endl;


    //第二种定义方式
    //数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
    //如果{}内不足10个数据，剩余数据用0补全
    int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };

    //逐个输出
    //cout << score2[0] << endl;
    //cout << score2[1] << endl;

    //一个一个输出太麻烦，因此可以利用循环进行输出
    for (int i = 0; i < 10; i++)
    {
        cout << score2[i] << endl;
    }

    //定义方式3
    //数据类型 数组名[] =  {值1，值2 ，值3 ...};
    int score3[] = { 100,90,80,70,60,50,40,30,20,10 };

    for (int i = 0; i < 10; i++)
    {
        cout << score3[i] << endl;
    }

    system("pause");

    return 0;
}

总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名

总结2：数组中下标是从0开始索引

一维数组数组名

一维数组名称的用途：

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

示例：

int main() {

    //数组名用途
    //1、可以获取整个数组占用内存空间大小
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    cout << "整个数组所占内存空间为： " << sizeof(arr) << endl; // 40B
    cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl; // 4B
    cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl; // 10 

    //2、可以通过数组名获取到数组首地址
    cout << "数组首地址为： " << (int)arr << endl; // 0x7ff7b89592c0
    cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl; // 0x7ff7b89592c0
    cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl; // 0x7ff7b89592c4

    //arr = 100; 错误，数组名是常量，因此不可以赋值


    system("pause");

    return 0;
}

注意：数组名是常量，不可以赋值

总结1：直接打印数组名，可以查看数组所占内存的首地址

总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

练习案例2： 数组元素逆置

案例描述： 请声明一个5个元素的数组，并且将元素逆置.

(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

int main()
{
    // 数组元素逆置
    int arr[] = {1, 2, 3, 4, 5};
    int start = 0;
    int end = (sizeof(arr) / sizeof(arr[0])) - 1;
    while (start < end)
    {
        int temp = arr[end];
        arr[end] = arr[start];
        arr[start] = temp;
        start++;
        end--;
    }
    for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++)
    {
        cout << arr[i];
    }
    return 0;
}

冒泡排序

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

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

示例： 将数组 { 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++)
    {
        for (int j = 0; j < 9 - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    for (int i = 0; i < 9; i++)
    {
        cout << arr[i] << endl;
    }

    system("pause");

    return 0;
}

排序总轮数：长度 - 1

每轮对比次数：长度 - 轮数 - 1

二维数组

二维数组就是在一维数组上，多加一个维度。

二维数组定义方式

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

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

建议：以上4种定义方式，利用==第二种更加直观，提高代码的可读性==

示例：

int main() {

    //方式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;
    }

    //方式2 
    //数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
    int arr2[2][3] =
    {
        {1,2,3},
        {4,5,6}
    };

    //方式3
    //数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
    int arr3[2][3] = { 1,2,3,4,5,6 }; 

    //方式4 
    //数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
    int arr4[][3] = { 1,2,3,4,5,6 };

    system("pause");

    return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

二维数组数组名

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

示例：

int main() {

    //二维数组数组名
    int arr[2][3] =
    {
        {1,2,3},
        {4,5,6}
    };

    cout << "二维数组大小： " << sizeof(arr) << endl; // 24B
    cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;  // 12B
    cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl; // 4B

    //地址
    cout << "二维数组首地址：" << arr << endl; // 0x7ff7be5552b0
    cout << "二维数组第一行地址：" << arr[0] << endl; // 0x7ff7be5552b0
    cout << "二维数组第二行地址：" << arr[1] << endl; // 0x7ff7be5552bc ( 0 + 3*4 = c)

    cout << "二维数组第一个元素地址：" << &arr[0][0] << endl; // 0x7ff7b2bf82b0
    cout << "二维数组第二个元素地址：" << &arr[0][1] << endl; // 0x7ff7b2bf82b4

    system("pause");

    return 0;
}

总结1：二维数组名就是这个数组的首地址

总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

函数

值传递

• 所谓值传递，就是函数调用时实参将数值传入给形参
• 值传递时，==如果形参发生，并不会影响实参==

示例：

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() {

    int a = 10;
    int b = 20;

    swap(a, b);

    cout << "mian中的 a = " << a << endl;
    cout << "mian中的 b = " << b << endl;

    system("pause");

    return 0;
}

总结： 值传递时，形参是修饰不了实参的

函数的分文件编写

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

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

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

示例：

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

//main函数文件
#include "swap.h"
int main() {

    int a = 100;
    int b = 200;
    swap(a, b);

    system("pause");

    return 0;
}

指针

常见应用场景

• 交换变量
• 多个返回值
• 返回运算状态

指针所占内存空间

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

示例：

int main() {

    int a = 10;

    int * p;
    p = &a; //指针指向数据a的地址

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

    system("pause");

    return 0;
}

*p为解引用

所有指针类型在32位操作系统下是4个字节

所有指针类型在64位操作系统下是8个字节

空指针和野指针

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

用途： 初始化指针变量

注意： 空指针指向的内存是不可以访问的，内存编号0 ~255为系统占用内存，不允许用户访问

示例1：空指针

int main() {

    //指针变量p指向内存地址编号为0的空间
    int * p = NULL;

    //访问空指针报错 
    //内存编号0 ~255为系统占用内存，不允许用户访问
    cout << *p << endl; // 0x0

    system("pause");

    return 0;
}

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

示例2：野指针

int main() {

    //指针变量p指向内存地址编号为0x1100的空间
    int * p = (int *)0x1100;

    //访问野指针报错 
    cout << *p << endl;

    system("pause");

    return 0;
}

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

const修饰指针

const修饰指针有三种情况

1. const修饰指针 --- 常量指针
2. const修饰常量 --- 指针常量
3. const既修饰指针，又修饰常量

记忆方法：==不变的是前面的两个字==

常量指针（const pointer）

落点是指针，说明常量指针是一个指针,不同的是它指向的是一个常量。

const int a = 5;
const int * p = &a;

从右向左看首先是一个(指针的标志)，首先说明p是一个指针，再向左看，是一个指向常量的指针,所以p指向的是一个常量我们就不能更改p的值,但是p本身不是一个常量所以我们可以改变p 指向的变量。

const修饰的是指针，指针指向可以改，指针指向的值不可以更改

指针常量(pointer to const)

落点在常量上，这说明了指针常量是一个常量，类型是指针类型。 如果写int const a = 5那么a就是一个整型常量(尽管我们一般不是这么描述),所以指针常量应该如下定义,

int *const p = #

从右向左看,离p最近的是const,首先说明了p是一个常量。在这里，const是一个顶层const因为它本身是一个常量，我们初始化的时候将p指向num，完成了初始化， 所以常量p不能在指向其他的变量(或是常量),也就是说们再写p = &num2;;编译是不会通过的。

const修饰的是常量，指针指向不可以改，指针指向的值可以更改

const既修饰指针又修饰常量

示例：

int main() {

    int a = 10;
    int b = 10;

    //const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    const int * p1 = &a; 
    p1 = &b; //正确
    //*p1 = 100;  报错


    //const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    int * const p2 = &a;
    //p2 = &b; //错误
    *p2 = 100; //正确

    //const既修饰指针又修饰常量
    const int * const p3 = &a;
    //p3 = &b; //错误
    //*p3 = 100; //错误

    system("pause");

    return 0;
}

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

数组和指针

数组变量是特殊的指针

数组变量本⾝表达地址，所以:

• int a[10]; int*p=a; // ⽆需⽤&取地址
• 但是数组的单元表达的是变量，需要⽤&取地址
• a == &a[0]

[]运算符可以对数组做，也可以对指针做：

• p[0] <=> a[0]

*运算符可以对指针做，也可以对数组做：

• *a = 25;

数组变量是const的指针，所以不能被赋值:

• int a[] <==> int * const a=….

以下四种函数原型是等价的：

• int sum(int *ar, int n);
• int sum(int *, int);
• int sum(int ar[], int n);
• int sum(int [], int);

结构体

结构体定义和使用

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

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

• struct 结构体名 变量名
• struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
• 定义结构体时顺便创建变量

示例：

//结构体定义
struct student
{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
}stu3; //结构体变量创建方式3 


int main() {

    //结构体变量创建方式1
    struct student stu1; //struct 关键字可以省略

    stu1.name = "张三";
    stu1.age = 18;
    stu1.score = 100;

    cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

    //结构体变量创建方式2
    struct student stu2 = { "李四",19,60 };

    cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;


    stu3.name = "王五";
    stu3.age = 18;
    stu3.score = 80;


    cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

    system("pause");

    return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3：结构体变量利用操作符 ''.'' 访问成员

结构体指针

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

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

示例：

//结构体定义
struct student
{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
};


int main() {

    struct student stu = { "张三",18,100, };

    struct student * p = &stu;

    p->score = 80; //指针通过 -> 操作符可以访问成员

    cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;

    system("pause");

    return 0;
}

总结：结构体指针可以通过 -> 操作符 来访问结构体中的成员

结构体做函数参数

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

传递方式有两种：

• 值传递
• 地址传递

示例：

//学生结构体定义
struct student
{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
};

//值传递
void printStudent(student stu )
{
    stu.age = 28;
    cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递
void printStudent2(student *stu)
{
    stu->age = 28;
    cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {

    student stu = { "张三",18,100};
    //值传递
    printStudent(stu);
    cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

    cout << endl;

    //地址传递
    printStudent2(&stu);
    cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

    system("pause");

    return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

结构体中 const使用场景

作用： 用const来防止误操作

示例：

//学生结构体定义
struct student
{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
};

//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
    //stu->age = 100; //操作失败，因为加了const修饰
    cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

    student stu = { "张三",18,100 };

    printStudent(&stu);

    system("pause");

    return 0;
}