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