C++函数
语法
1返回类型 函数名称(参数1, 参数2, 参数3, ...参数N)
2{
3 函数功能;
4 return 返回值;
5}
参数类型
指针参数
非指针参数
1#include<iostream>
2
3struct Role
4{
5 int Hp;
6 int Mp;
7};
8
9int exp(Role role)
10{
11 return role.Hp + role.Mp;
12}
13
14int main()
15{
16 Role role;
17 role.Hp = 100;
18 role.Mp = 200;
19
20 int result = exp(role);
21 std::cout << "结果: " << result << std::endl;
22
23 return 0;
24}
指针参数
1#include<iostream>
2
3struct Role
4{
5 int Hp;
6 int Mp;
7};
8
9int exp(Role* role)
10{
11 return role->Hp + role->Mp;
12}
13
14int main()
15{
16 Role role;
17 role.Hp = 100;
18 role.Mp = 200;
19
20 int result = exp(&role);
21 std::cout << "结果: " << result << std::endl;
22
23 return 0;
24}
使用指针参数之后，计算速度提高？
数组参数
传参的时候如果(int a[])，这样写是无法获取到数组的大小的。
1#include<iostream>
2
3void sort(int* a, unsigned size)
4{
5 for (int i = 0; i < size; i++)
6 {
7 for (int j = i; j < size; j++)
8 {
9 if (a[i] > a[j])
10 {
11 int temp = a[i];
12 a[i] = a[j];
13 a[j] = temp;
14 }
15 }
16 }
17}
18
19int main()
20{
21 int a[4]{ 6,5,7,4 };
22 sort(a, 4);
23
24 for (int i = 0; i < 4; i++)
25 {
26 std::cout << a[i] << std::endl;
27 }
28}
引用参数
1#include<iostream>
2
3struct Role
4{
5 int hp;
6 int mp;
7 int damage;
8};
9
10bool act(Role& acter, Role& beAct)
11{
12 beAct.hp -= acter.damage;
13 return beAct.hp < 0;
14}
15
16int main()
17{
18 Role user{ 200, 300, 500 };
19 Role monster{ 800, 300, 50 };
20 if (act(user, monster))
21 {
22 std::cout << "怪物死亡，获取经验值：xxxx" << std::endl;
23 }
24
25 return 0;
26}
区别：指针可以传入nullptr，而应用必须初始化。
1#include<iostream>
2
3struct Role
4{
5 int hp;
6 int mp;
7 int damage;
8};
9
10// 如果需要在act中改变beAct的内容可以使用指正引用参数
11bool act(const Role* acter, Role*& beAct)
12{
13 beAct->hp -= acter->damage;
14 // beAct = (ROle*) &acter
15 return beAct->hp < 0;
16}
17
18int main()
19{
20 Role user{ 200, 300, 900 };
21 Role monster{ 800, 300, 50 };
22
23 Role* pRole = &monster;
24
25 if (act(&user, pRole))
26 {
27 std::cout << "怪物死亡，获取经验值：xxxx" << std::endl;
28 }
29
30 return 0;
31}
默认实参
1void sort(int arr[], unsigned count, bool bigSort=true)
2{
3 ...
4}
5
6// 指定参数bigSort调用
7sort(a, 10, true);
8
9// 使用参数默认值调用
10sort(b, 10);
11// bigSort参数的默认值是true
有默认值的参数必须放在参数列表的最后，否则无法知道该函数省略的到底是前面的参数还是后面的参数。
引用必须要给一个实例的地址，不可以随便指向。但是指针可以。
不定量参数
main函数
1int main(unsigned count, char* args[])
2{
3
4}
自定义
引入头文件<cstdarg>
1#include<iostream>
2#include<cstdarg>
3
4int average(int count, ...)
5{
6 // va_list args; 等价于下面一句
7 char* args;
8 // 初始化args
9 va_start(args, count);
10
11 int sum = 0;
12 for (int i{}; i < count; i++)
13 {
14 // 每调用一次va_arg, 指针向后移动一次
15 // 此时指向下一个参数
16 sum += va_arg(args, int);
17 }
18
19 // 释放指针空间
20 va_end(args);
21 return sum / count;
22}
23
24
25int main()
26{
27 std::cout << "平均值="<< average(1,2,3,4,5) << std::endl;
28 return 0;
29}
第二种
封装参数
1#include<iostream>
2
3struct SArg
4{
5 int count;
6 char* args;
7};
8
9int average(SArg& args)
10{
11
12 int count = args.count;
13 char* tempArgs = args.args;
14
15 int sum = 0;
16 for (int i{}; i < count; i++)
17 {
18 sum += (int)tempArgs[i];
19 }
20
21 return sum / count;
22}
23
24
25int main()
26{
27 SArg args;
28 args.count = 5;
29 args.args = new char[5]{1, 2,3,4,5};
30 std::cout << "平均值=" << average(args) << std::endl;
31 return 0;
32}
函数指针
定义
1函数返回类型 (*函数指针变量名)(参数类型 参数名称, ...参数类型 参数名称)
2
3如：
4int (*pAdd) (int a, int b);
1#include<iostream>
2
3// 声明一个函数指针类型
4typedef int (*pfAdd)(int, int);
5
6// 声明一个函数指针类型
7useing pfAdd = int (*)(int, int)
8
9int add_1(int a, int b)
10{
11 return a + b;
12}
13
14int add_2(int a, int b)
15{
16 return a * 10 + b;
17}
18
19float add_3(int a, int b)
20{
21 return (a + b) / 2;
22}
23
24int main()
25{
26 int (*pAdd) (int, int) = add_1;
27 std::cout << "结果=" << pAdd(1, 2) << std::endl;
28
29 pAdd = add_2;
30 std::cout << "结果=" << pAdd(1, 2) << std::endl;
31
32 pAdd = (int (*)(int, int))add_3;
33 std::cout << "结果=" << pAdd(1, 2) << std::endl;
34
35 pfAdd pAdd = (pfAdd)add_3;
36 std::cout << "结果=" << pAdd(1, 2) << std::endl;
37 return 0;
38}
结构体函数
参数是结构体
1#include<iostream>
2
3// 声明一个函数指针类型
4typedef int (*pfAdd)(int, int);
5
6struct Role
7{
8 int hp;
9 int mp;
10};
11
12
13int add_4(Role role)
14{
15 return role.hp + role.mp;
16}
17
18int main()
19{
20 // 虽然add_4传入的是一个结构体，但实际上是还分开传值的开销较大
21 // 可以使用引用
22 pfadd = (pfAdd)add_4;
23 std::cout << "结果=" << pfadd(1, 2) << std::endl;
24 return 0;
25}
26
27输出：
28结果=3
函数本质
函数返回
返回指针
返回引用
右值引用
从函数角度认识栈
— END —