第七章函数

函数基础

函数：封装了一段代码，可以在一次执行过程中被反复调用。
- 函数头
  - 函数名称——标识符，用于后续的调用
  - 形式参数——代表函数的输入参数
  - 返回类型——函数执行完成后所返回的结果类型
- 函数体
  - 为一个语句块（block），包含了具体的计算逻辑
函数声明与定义
- 函数声明只包含函数头，不包含函数体，通常至于头文件中
- 函数声明可出现多次，但函数定义通常只能出现一次（存在例外）
函数调用
- 需要提供函数名与实际参数
- 实际参数拷贝初始化形式参数
  - argument——>实参
  - parameter——>形参
- 返回值会被拷贝给函数的调用者
- 栈帧结构
  - Frame（帧），每一个function按栈帧在memory中堆放，先入后出；

int Add(int x, int y)
{
    int x1 = x + 1; // 局部变量
    return x + y;
}

int Sub(int x, int y)
{
    return x - y;
}

int main()
{
    int z = Add(2, 3);
    std::cout << z << std::endl;
    
    z = Sub(2, 3);
    std::cout << z << std::endl;
}

拷贝过程的（强制）省略
- 返回值优化
- C++17强制省略拷贝临时对象
函数的外部链接——mangle&demangle

// ---------------------------------------------------------------------------------------------------------
extern "C"  //C类 型函数
int Add(int x, int y)
{
    return x + y;
}

函数详解

参数

函数可以在函数头的小括号中包含零到多个形参
- 包含零个形参时，可以使用void标记
- 对于非模板函数来说，其每个形参都有确定的类型，但形参可以没有名称
- 形参名称的变化并不会引入函数的不同版本
- 实参到形参的<u>拷贝求值顺序不定</u>，C++17强制<u>忽略复制临时对象</u>
```
#include <iostream>

void fun(int x, int y)
{
    std::cout << y;
}

int main()
{
    fun(1, 2);       // 拷贝求值顺序不定
    fun(1, int{});   // 临时变量会被C++17标准强制忽略，C++17标准之前由编译器决定
}
```
  - -fno-elide-constructors忽略C++11（C++17标准之前）中对复制临时对象强制忽略的约束

函数传值、传址、传引用

#include <iostream>

void fun(int par)
{
    ++par;
}

int main()
{
    int arg = 3;
    fun(arg);
    std::cout << arg << '\n';   // 传值
}

#include <iostream>

void fun(int* par)
{
    ++(*par);
}

int main()
{
    int arg = 3;
    fun(&arg);
    std::cout << arg << '\n';   // 传址
}

#include <iostream>

void fun(int& par)
{
    ++par;
}

int main()
{
    int arg = 3;
    fun(arg);
    std::cout << arg << '\n';   // 传引用
}

函数传参过程中的类型退化

#include <iostream>

void fun(int par[])   // void fun(int* par)
{
    // ...
}

int main()
{
    int a[3];
    fun(a);
}

变长参数

initializer_list

#include <iostream>
#include <initializer_list>

void fun(std::initializer_list<int> par)
{
    // ...
}

int main()
{
    fun({1, 2, 3, 4, 5});      // right
    fun({1, 2, 3, "123", 5});  // wrong
}

可变长度模板参数
使用省略号表示形式参数

函数可以定义缺省实参
- 如果某个形参具有缺省实参，那么它右侧的形参都必须具有缺省实参
- 在一个翻译单元中，每个形参的缺省实参只能定义一次
- 具有缺省实参的函数调用时，传入的实参会按照从左到右的顺序匹配形参
- 缺省实参为对象时，传入的缺省值会随对象值的变化而变化
main函数的两个版本
- 无形参版本
- 带两个形参的版本

int main(){
}

int main(int argc, char *argv[]){
  if(argc != 3){
    std::cerr<<"Usage: "<<argv[0]<<" param1 param2\n";
    return -1;
  }
  std::cout<<"argc = "<<argc<<std::endl;
  for(int i = 0; i < argc ; ++i){
    std::cout<<argv[i]<<"\n";
  }
}

函数体

函数体形成域
- 其中包含了自动对象（内部声明的对象以及形参对象）
- 也可包含局部静态对象

函数体执行完成时的返回

隐式返回

#include <iostream>

void fun()
{
    std::cout << "Hello" << std::endl;
}

int main()
{
    fun();
}

显式返回关键字：return
- return;语句
- return 表达式;
- return 初始化列表;

小心返回自动对象的引用或指针(容易返回已经销毁的对象)

#include <iostream>
#include <initializer_list>

std::initializer_list<int> fun()
{
    std::cout << "Hello" << std::endl;
    return {1, 2, 3, 4, 5};
    std::cout << "World" << std::endl;
}

int main()
{
    auto x = fun();
}

#include <iostream>

int& fun()
{
  int x = 3;
  return x;
}

int main{}
{
  int& ref = fun();
}

返回值优化（Return Value Optimization, RVO）—— C++17对返回临时对象的强制优化

具名返回值优化
非具名返回值优化

#include <iostream>

struct Str
{
    Str() = default;
    Str(const Str&)
    {
        std::cout << "Copy constructor is called\n";
    }
};

Str fun()
{
    Str x;
    return x;
}

int main()
{
    Str res = fun(); //两次拷贝构造，因此会输出两次"Copy constructor is called"
}

返回类型

返回类型表示了函数计算结果的类型，可以为void
返回类型的几种书写方法
- 经典方法：位于函数头的前部
- C++11引入的方式：位于函数头的后部（泛型编程和类的成员函数编写可能会简化编写）
- C++14引入的方式：返回类型的自动推导
  - 使用constexpr if构造“具有不同返回类型”的函数，接收常量表达式
返回类型与结构化绑定（C++17）语法糖

[[nodiscard]]属性（C++17）表明返回值很重要需要保留

函数重载与重载解析

函数重载：使用相同的函数名定义多个函数，每个函数具有不同的参数列表(参数个数或者参数类型不同)
- 不能基于不同的返回类型进行重载
- 函数重载与name mangling
编译器如何选择正确的版本完成函数调用？
- 参考资源：Calling Functions: A Tutorial
名称查找
- 限定查找（qualified lookup）与非限定查找（unqualified lookup）
  
  限定查找
- 非限定查找会进行域的逐级查找——名称隐藏（hiding）
- 查找通常只会在已声明的名称集合中进行
- 实参依赖查找（Argument Dependent Lookup: ADL）
  - 只对自定义类型生效
    
    因为obj在是Str对象，所以会去MyNS域中查找
重载解析：在名称查找的基础上进一步选择合适的调用函数
- 过滤不能被调用的版本（non-viable candidates）
  - 参数个数不对
  - 无法将实参转换为形参
  - 实参不满足形参的限制条件
- 在剩余版本中查找与调用表达式最匹配的版本，匹配级别越低越好（有特殊规则）
  - 级别1：完美匹配或平凡转换（比如加一个const）
  - 级别2：promotion 或 promotion加平凡转换
  - 级别3：标准转换或标准转换加平凡转换
  - 级别4*：自定义转换或自定义转换加平凡转换或自定义转换加标准转换
  - 级别5*：形参为省略号的版本
  - 函数包含多个形参时，所选函数的所有形参的匹配级别都要优于或等于其他函数
[站外图片上传中...(image-37f2f5-1690910469933)]

函数相关的其他内容

递归函数：在函数体中调用其自身的函数
- 通常用于描述复杂的迭代过程（示例）比如二分查找
内联函数/constexpr函数（表示在编译器执行，也可以在运行期执行）（C++11起）/consteval函数（C++20起）（只能在编译期执行）
内联函数的展开：
1.逻辑简单的函数可能会被展开 2.内联函数展开并不是简单的替换 3. inline void fun() ,inline关键字保证在多个翻译单元定义后只选择一次，由程序一次定义原则转为翻译单元一次定义原则。4.inline关键字声明一定要有函数定义。

constexpr函数