值传递

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

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

函数重载

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

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

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

函数注意事项

函数重载与引用
函数重载与默认参数

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

重载函数指针

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

函数指针形参

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

【C++学习笔记】函数

值传递