【C++学习笔记】函数
值传递
值传递：函数调用时实参将数值传入给形参
做值传递时函数的形参发生改变，并不会影响实参
因为形参的作用域在函数内只有在调用函数时才会为其分配内存，函数调用结束后释放函数内的变量内存。
#include
using namespace std;
void swap(int n1, int n2)
{
cout << "交换前：" << endl;
cout << "n1:" << n1 << endl;
cout << "n2:" << n2 << endl;
int temp = n1;
n1 = n2;
n2 = temp;
cout << "交换后：" << endl;
cout << "n1:" << n1 << endl;
cout << "n2:" << n2 << endl;
}
int main()
{
值传递
int a = 10, b = 20;
cout << "实参：" << endl;
cout << "a:" << n1 << endl;
cout << "a:" << n2 << endl;
swap(n1, n2);
cout << "交换后实参：" << endl;
cout << "a:" << n1 << endl;
cout << "b:" << n2 << endl;
return 0;
}
函数样式
1.无参无返
void test1()
{
cout << "This is Test1()." << endl;
}
2.有参无返
void test2(int a)
{
cout << "This is Test2(), a = " << a << endl;
}
3.有参有返
int test4(int a, int b)
{
cout << "This is Test4(), a = " << a << " b = " << b << endl;
return a + b;
}
4.无参有返
int test3()
{
int a = 10;
cout << "This is Test3() " << endl;
return a;
}
函数声明
在编译阶段告诉编译器 该函数的存在，因此该函数的位置就可以在任意位置，可以在main之后
默认实参
1.一旦函数的某个形参被赋予默认值，其后面的形参都必须要有默认值
2.如果函数的声明有默认参数，则函数的实现不能有默认参数 会导致二义性 所以声明实现只能有一个有默认参数
#include
using namespace std;
// 函数的默认参数
// 1.如果函数的参数列表中某个位置已经有了默认参数，那么从这个位置后，从左到右都必须有默认值
int func(int a, int b = 10, int c = 20)
{
return a + b + c;
}
// 2.如果函数的声明有默认参数，则函数的实现不能有默认参数 会导致二义性 所以声明实现只能有一个有默认参数
int func2(int a, int b = 10); // 函数的声明
int func2(int a, int b) // 函数的实现
{
return a + b;
}
int main()
{
cout << func2(10, 20) << endl;
system("pause");
return 0;
}
函数的占位参数
1.函数的形参列表中可以有占位参数，用来做占位，调用函数时必须填补该位置
语法： 返回值类型 函数名 (数据类型){}
2.占位参数可以有默认参数
void func3(int , int)
{
cout << "this is func" << endl;
}
// 占位参数可以有默认参数
void func4(int a, int = 10)
{
cout << "this is func4" << endl;
}
int main()
{
func3(10, 20);
func4(10);
//system("pause");
return 0;
}
函数的分文件编写
1.后缀名为.h的头文件，存放函数的声明
2.后缀名为.cpp的源文件，写函数的定义
使用形参返回额外的信息
查找字符串中某个字符出现的次数
//返回s中第一次出现c的位置
//引用形参cout统计c出现的次数
string::size_type find_char(const string &s, char c, string::size_type &count)
{
auto len = s.size();
cout = 0;
for (decltype(len) i = 0; i != s.size(); ++i)
{
if(s[i] == c){
if(len == s.size())
len = i;
count++;
}
}
return len;
}
int main()
{
// 使用引用参数返回额外信息
string s = "aoooa";
string::size_type ctr = 0;
auto index = find_char(s, 'o', ctr); // 返回 o 第一次出现的索引
return 0;
}
为什么类型必须是上述这样？
1. 对于待查找的字符串 s 来说，为了避免拷贝长字符串，使用引用类型；同时只执行查找操作，无须改变字符串的内容，所以将其声明为常量引用
2. 对于待查找的字符 c 来说,它的类型是 char,只占1字节,拷贝的代价很低,而且无须操作实参在内存中实际存储的内容，只把它的值拷贝给形参即可，所以不需要使用引用类型。
3. 对于字符出现的次数 count 来说，因为需要把函数内对实参值的更改反映在函数外部，所以必须将其定义成引用类型:但是不能把它定义成常量引用,否则就不能改变所引的内容了
intializer_list: 当函数的实参数量未知但都是同类型时，可用该类型的形参；
intializer_list和vector 一样是一种模板，但是intializer_list中的元素常量
return 返回
return 返回值相对于产生并初始化一个临时量即返回结果；return 不能返回数组，因为数组不能被拷贝,但是可以返回数组的指针或者引用
在定义返回类型为数组的函数时，一般使用别名来定义：
typedef int arrT[10]; // arrT是一个类型别名，表示的类型为含有10个元素的数组
using arrT = int[10]; // arrT的等价声明，同上一行代码作用相同
arrT* func(int i); // func返回一个指向含有10个int型的数组的指针
什么情况下返回的引用无效？：如果所引用的是函数开始前就存在的对象则有效；如果引用的是函数的局部变量，则引用无效，因为局部变量随着函数调用的结束失效。
什么情况下返回常量的引用？：不希望返回的对象被修改时，返回对常量的引用
声明一个返回数组指针的函数
1.格式：Type (*function(parameter_list))[dimension]
Type：为元素类型
dimension：为数组维度，即数组大小
(*function(parameter_list)) 括号必须存在
例如：
int (*func(int j))[10];
func(int j) ：表示调用函数func需要一个int型实参
(*func(int j))：表示可以对函数调用的结果执行解引用
(*func(int j))[10]：表示解引用func的调用会得到一个大小为10的数组
int (*func(int j))[10]：表示数组中的元素类型为int、
2.C++11 尾置返回
auto func(int i) -> int(*)[10];
将函数的返回类型置于函数形参列表之后，可以更清楚的看出func返回的类型为指针，该指针指向大小为10的int型数组
3.使用 decltype
int odd[] = {1,2,3,4,5};
decltype(odd) *arrPtr(int i)
{
return &odd;
}
arrPtr使用[[二、变量和基本类型#^q1zzxe|decltype]]表示返回类型是指针，且该指针的类型与odd相同
递归
int factorial(int val)
{
if(val > 1)
return factorial(val - 1) * val;
return 1;
}
为什么上述递归函数中，不用val–，而是用 val - 1？
因为用val–，操作与读取变量值的操作同处于一条表达式中，可能产生未定义的值。
函数重载
作用：函数名可以相同，形参列表及返回类型不同，可以提高复用性
满足条件：
- 统一作用域
- 函数名相同
- 函数参数类型或者个数或者顺序不同
- 如果函数的名称和参数完全相同，仅仅是返回值类型不同，是无法进行函数重载的
#include
using namespace std;
// 函数重载，提高复用行
// 1.在同一个作用域
// 2.函数名相同
// 3.函数参数的类型或者个数或者顺序不同
int func(int a)
{
cout << "int func(int a) 的调用！" << endl;
return 0;
}
// 参数个数不同
int func(int b, int c)
{
cout << "int func(int b, int c) 的重载调用！" << endl;
return 0;
}
// 参数类型不同
int func(double a)
{
cout << "int func(double a) 的调用！" << endl;
return 0;
}
// 满足重载条件时 返回值不同可以重载
void func(int a, int b, int c)
{
cout << "void func(int a, int b, int c)的调用！" << endl;
}
// 参数顺序不同
void func(int a, double b)
{
cout << "void func(int a, double b) 的调用！" << endl;
}
void func(double a, int b)
{
cout << "void func(double a, int b) 的调用！" << endl;
}
int main()
{
func(10);
func(10, 20);
func(3.14);
func(1, 2, 3);
func(2, 3.14);
func(3.14, 2);
return 0;
}
![[Pasted image 20221207211710.png]]
重载和Const形参
一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来
Record lookup(Phone);
Record lookup(const Phone); //这两个无法区分，相对于重复声明了
Record lookup(Phone*); // 作用于指向Phone的指针
Record lookup(Phone* const) // 与第三个函数相同，重复声明
如果形参是某类型的指针或引用，则通过区分其指向的是常量对象还是非常量对象来区分
Record lookup(Phone&); // 作用与Phone 的引用
Record lookup(const Phone&); // 与第一个函数不同，作用于常量引用
Record lookup(Phone*); // 作用于指向Phone的指针
Record lookup(const Phone*) // 不同于第三个函数， 作用于常量指针
函数注意事项
- 函数重载与引用
- 函数重载与默认参数
#include
using namespace std;
// 引用作为重载条件
void func1(int &a)
{
cout << "func1(int &a)的调用！" << endl;
}
void func1(const int &a) // const int &a = 10
{
cout << "func1(const int &a)的调用！" << endl;
}
// 函数重载与默认参数
void func2(int a)
{
cout << "func1(int a)的调用！" << endl;
}
void func2(int a, int b = 10) //数重载与默认参数
{
cout << "func1(int a = 10)的调用！" << endl;
}
int main()
{
int a = 100;
func1(a); // 调用func1(int &a) 因为a是变量
const int a1 = 100;
func1(a1); // 调用func1(const int &a) 因为a是const修饰的变量 只能调用 有const 的重载函数
func1(10); // 调用func1(const int &a) 因为10是常量
// 调用函数时 编译器相对于创建了一个临时变量 int temp = 10; const int &a = temp;
// 而当func1(a); 调用时，10作为常量是存放在常量区，而引用必须在合法空间（栈区、堆区）因此 int &a = 10; 是不合法的
int val = 10;
// func2(10); // 当函数重载碰到默认参数时会出现二义性，报错 尽量避免
func2(10, 20); // 当函数重载碰到默认参数时赋值默认值时可以调用 有默认参数的重载函数
return 0;
}
内联函数
关键字：inline
意义：避免函数调用的开销，一般把重复利用、规模小、流程直接的函数定义为inline
constexpr函数
[[二、变量和基本类型]]：指能用与常量表达式的函数
返回类型及所有形参必须是字面值类型
函数体内必须有且只有一个return
返回值可以是一个非常量
constexpr int new_sz() {return 42;}
constexpr int foo = new_sz();
内联函数、constexpr函数要放在头文件中
函数匹配
过程：
1. 选定可以调用的重载函数集合，即候选函数
2. 考察调用函数的实参，从候选函数中选出能被实参调用的函数，即可行函数
3. 考察实参是否与形参匹配
含有多个形参的函数匹配原则：
1. 函数的每个实参匹配度不劣于其他可行函数的匹配
2. 至少有一个实参的匹配优于其他可行函数提供的匹配
3.若没有符合上述条件的编译器报错，二义性
函数指针
bool (*pf)(const string &, const strint &); // 未初始化的函数指针
从左到右看：
1. pf前有* 说明去是指针
2. pf后有形参列表，说明去是函数，该函数有两个const string 形参，则pf为指向函数的指针
3. 最前面为其类型bool，说明该函数返回值类型为bool
函数指针指向的函数应该与其定义的函数形参数及类型、及函数返回类型都相同
重载函数指针
函数指针的形参列表要与指向的函数相匹配、返回类型也要相匹配
函数指针形参
函数可以直接作为实参使用， 自动转为指针