【C++学习笔记】函数

值传递

值传递：函数调用时实参将数值传入给形参
做值传递时函数的形参发生改变，并不会影响实参
因为形参的作用域在函数内只有在调用函数时才会为其分配内存，函数调用结束后释放函数内的变量内存。

#include<iostream>
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<iostream>
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–，操作与读取变量值的操作同处于一条表达式中，可能产生未定义的值。

函数重载

作用：函数名可以相同，形参列表及返回类型不同，可以提高复用性
满足条件：

1. 统一作用域
2. 函数名相同
3. 函数参数类型或者个数或者顺序不同
4. 如果函数的名称和参数完全相同，仅仅是返回值类型不同，是无法进行函数重载的

#include<iostream>

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*) // 不同于第三个函数， 作用于常量指针

函数注意事项

1. 函数重载与引用
2. 函数重载与默认参数

#include<iostream>
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
函数指针指向的函数应该与其定义的函数形参数及类型、及函数返回类型都相同

重载函数指针

函数指针的形参列表要与指向的函数相匹配、返回类型也要相匹配

函数指针形参

函数可以直接作为实参使用， 自动转为指针