明德香蜜-C班-D12-函数

张kk

2026-04-09 16:31:20

发布于：广东

14阅读

0回复

0点赞

C++ 函数笔记（信奥校队专用）

一、函数分类

函数就像一个个“小工具箱”，每个工具箱能完成一件特定的事情。使用函数，可以让我们的代码更整洁，避免重复写相同的代码。

1. 系统函数

定义：别人（C++ 标准库）已经写好，我们直接拿来用的函数。
特点：需要包含对应的头文件，就像借工具要先找到工具箱在哪。
例子：
- cout、cin —— 输入输出，需要 #include <iostream>
- sqrt(x) —— 计算平方根，需要 #include <cmath>
- pow(x, y) —— 计算 x 的 y 次方，也需要 #include <cmath>
- rand() —— 生成随机数，需要 #include <cstdlib>

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

int main() {
    cout << sqrt(16) << endl;  // 输出 4
    cout << pow(2, 3) << endl; // 输出 8
    return 0;
}

2. 自定义函数

定义：自己写的函数，用来解决自己的问题。
特点：可以根据需要任意定义，想实现什么功能就写什么。
例子：打印一排星星、计算两个数的和、判断一个数是不是素数……

// 自定义函数：打印一排星星
void printStars() {
    cout << "**********" << endl;
}

二、函数定义 & 调用

1. 定义函数（造工具箱）

语法：

返回类型 函数名(参数列表) {
    函数体;          // 要执行的代码
    return 返回值;   // 如果有返回值，必须用 return 返回
}

说明：
- 返回类型：函数返回的数据类型，比如 int（整数）、double（小数）、void（没有返回值）。
- 函数名：自己取名字，最好能看出函数的作用（比如 add、print）。
- 参数列表：调用函数时传给函数的数据，可以没有（空括号），也可以有多个（用逗号隔开）。
- 函数体：花括号里的代码，实现具体功能。
- return：如果返回类型不是 void，必须用 return 返回一个值，值的类型要和返回类型一致。
例子：

// 没有返回值，也没有参数
void sayHello() {
    cout << "你好！" << endl;
}

// 有返回值，有参数
int add(int a, int b) {
    int sum = a + b;
    return sum;
}

2. 调用函数（用工具箱）

语法：函数名(参数)
执行过程：遇到函数调用，程序会跳进函数里面执行，执行完再回到调用处继续往下走。

int main() {
    sayHello();               // 调用 sayHello，输出 "你好！"

    int result = add(3, 5);   // 调用 add，把 3 和 5 传进去，得到返回值 8，存到 result 里
    cout << result << endl;   // 输出 8

    return 0;
}

三、函数传参 & 变量生命周期

1. 参数传递

形参：定义函数时写的参数，比如 int a, int b，它们是“形式上的参数”。
实参：调用函数时传给函数的实际值，比如 3, 5。
传递过程：调用时，把实参的值复制一份给形参，函数内部使用形参。

void doubleNumber(int x) {   // x 是形参
    x = x * 2;
    cout << "函数内部：" << x << endl;
}

int main() {
    int num = 10;
    doubleNumber(num);        // num 是实参，把 10 复制给 x
    cout << "函数外部：" << num << endl;  // 输出 10，num 没变
    return 0;
}

注意：函数内部修改形参，不会影响实参（除非用引用，但这是后面的知识）。

2. 变量的生命周期

变量不是永远存在的，它有自己的“出生”和“死亡”时间，这叫生命周期。

局部变量
- 出生：函数被调用时，函数内部定义的变量（包括参数）被创建。
- 死亡：函数执行完毕，这些变量就被自动销毁，不能再用。
- 作用域：只在它所在的函数内部有效。
```
void func() {
    int a = 5;   // a 是局部变量
    cout << a;
} // 执行到这，a 消失

int main() {
    func();
    // cout << a;  // 错误！a 已经不存在了
}
```

全局变量

出生：程序开始运行时创建。
死亡：程序结束时销毁。
作用域：整个程序的所有函数都能访问和修改。
定义位置：在所有函数外面（通常在 #include 下面）。

#include <iostream>
using namespace std;

int global = 100;   // 全局变量

void show() {
    cout << global << endl;  // 可以访问
}

int main() {
    cout << global << endl;  // 可以访问
    global = 200;            // 可以修改
    show();                  // 输出 200
    return 0;
}

局部变量和全局变量同名：

在函数内部，局部变量会“遮盖”全局变量，优先使用局部变量。

int x = 10;   // 全局

void test() {
    int x = 20;   // 局部，和全局同名
    cout << x;    // 输出 20（局部）
}

建议：尽量少用全局变量，因为容易被不小心修改，导致程序难调试。能用局部变量就用局部变量。

四、为什么要使用函数？（必要性和优势）

1. 避免重复代码（复用）

如果没有函数，你要多次执行相同操作，就得一遍遍写相同的代码，既麻烦又容易出错。
例子：要计算多个圆的面积，每次都得写 3.14 * r * r。有了函数，只需写一次，然后调用它。

2. 让程序更清晰（模块化）

把一个大问题分解成多个小函数，每个函数只做一件事。这样主程序（main 函数）就像一张“任务清单”，一目了然。
比如，做一道复杂的数学题，可以分成“输入数据”、“计算”、“输出结果”三个函数。

3. 方便调试和修改

如果程序出错了，可以单独测试每个函数，快速定位问题。
如果想修改某个功能，只需要改对应的函数，其他地方不用动。

4. 团队合作

写大程序时，可以让不同的人写不同的函数，最后组装起来，互不影响。

5. 让思路更清晰

写函数时，你会思考它需要什么数据（参数），返回什么结果，这能帮助你更好地理解问题。

总结

函数：把一段代码打包，起个名字，以后随时调用。
系统函数：现成的，直接拿过来用。
自定义函数：自己写的，想干啥就干啥。
参数：给函数送原材料。
返回值：函数加工后送出来的成品。
局部变量：函数内部用，用完就丢。
全局变量：所有人都能用，但容易惹麻烦。

记住：多用函数，能让你的代码更漂亮、更聪明！

课堂笔记

函数：实现一个功能需要用到30+行代码，尽量用函数封装起来

一、函数分类：
系统函数：别人定义好了，你直接使用 
sqrt() printf()
自定义函数： 自己根据需求来定义
二、函数定义：
1、定义语法：
返回值类型 函数名(参数类型 参数名1,参数类型 参数名2...){//形式参数 
	函数体;（你要实现这个函数的功能代码） 
	可能包含返回值：return(返回值，同时结束这个函数) 
}
无返回值函数定义：
void 函数名(参数列表){
	函数体;
	return;
}
2、调用函数： 
语法：函数名(实参列表);//实际参数 

三、生命周期 

局部变量和全局变量：
1、局部变量：定义在一个代码段里面的变量（比如定义在函数里面的变量、for循环里面的变量）
出生：当你执行了这个代码段的适合
死亡（结束消失）：这个代码段运行结束之后，会被回收 
使用范围：只能在这个代码段里面进行使用
2、全局变量：定义在main函数外面的变量
出生：程序运行的时候
死亡：整个程序运行结束之后才结束回收
使用范围：定义全局变量下面的所有代码均能使用
四、函数传参
1、值传递:
#include<bits/stdc++.h>
using namespace std;
// 完成求和的add函数，并且使用add函数答题
void tst(int a, int b) {
	int t=a;
    a=b;
    b=t;
    //return a.b;
}
int main() {
    int a,b;
    cin>>a>>b;
    tst(a,b);
    cout<<a<<" "<<b;
	return 0;
}
2、引用传递
#include<bits/stdc++.h>
using namespace std;
// 完成求和的add函数，并且使用add函数答题
void tst(int &a, int b) {
	int t=a;
    a=b;
    b=t;
    //return a.b;
}
int main() {
    int a,b;
    cin>>a>>b;
    tst(a,b);
    cout<<a<<" "<<b;
	return 0;
}