第 6 章笔记

封装了代码，用于反复利用

• 函数头
  • 需要是一个合法的标识符
  • 形式参数：函数输入的参数(parameter)
  • 返回类型：函数执行完成后得到的结果
• 函数体：语句块（必须带大括号），包含具体的计算逻辑

• 声明：只有函数头，没有函数体
• 定义：两者都有
• 声明可出现多次，定义只能出现一次（编译器无法选择哪段对应的汇编代码）
• 编译执行顺序为从头到尾，因此需要函数的前置声明（告诉编译器该函数存在，在最后引入函数的定义）
• 通常将声明加入 header 中，使用时包含即可
• 只有声明没有定义会出现链接错误，这是因为链接期会寻找函数的定义。

• 需要函数名与实际参数(argument)
• 实际参数会通过拷贝初始化交给形式参数进行参数传递
• 返回值会通过拷贝初始化进行返回
• 拷贝过程可能会被省略（涉及到优化及C++的新feature）

调用函数时，函数内部的变量（局部变量）是通过 stack frame 的结构进行组织的。当牵涉到多重调用时，越往后调用的函数越处于 stack 的上方。

int Add(int x, int y)
{....}
int main()
{
    int x = 1;
    int y = 2;
    // Add 在 stack 中处于 main() 的上方
    // 从下到上，内存地址是逐渐减小的
    Add(1,2); 
}

• 保存顺序：实参→返回地址→本地变量

以下面的程序为例：

int Add(int x, int y)
{
    return x + y;
}

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

int main(int argc, char const *argv[])
{
    /* code */
    return 0;
}

# list all external link of demo
nm demo
# 需要关注的内容
# main
0000000140001476 T main
# add & sub
# 注意是 mangling 的名称
# 编译器友好形式
0000000140001450 T _Z3Addii
0000000140001464 T _Z3Subii

#demangle
nm demo | c++filt -t

# 结果，链接中实际保存了参数的信息
# 阅读友好形式
0000000140001450 T Add(int, int)
0000000140001464 T Sub(int, int)

• 函数的形参可以是 0 到多个，参数列表为 0 时可以用 void 代替
• 函数形参可以没有参数名称，但必须要有确定的参数类型
  • 函数类型用于编译器检查
  • 名称用于传入数值
• 形参的变化不会引入新的函数
  • 编译器只检查函数类型
• 初始化的顺序与形参的顺序无关
• C++ 17 会强制省略复制临时对象

// 0参数 等价形式
void fun(){};
void fun(void){};

// 无参数名称的函数
void fun(int, int y) {}

// 名称不影响函数在编译器内的匹配
// redefination
void fun(int, int y) {};
void fuin(int a, int b) {};

// C++ 17 强制省略复制临时对象
struct Str
{
    Str() = default;
    Str(const Str&) {};
}
void fun(Str) {};
int main() 
{
    // 拷贝构造
    Str a;
    fun(a);
    // 临时对象不会拷贝构造
    fun(Str{});
}

都是拷贝初始化的过程，但是行为不同：

• 值传递：将值复制后进行传递
• 地址（指针）传递：解引用→找到内存地址→修改内存内容
• 引用传递：引用绑定了内存地址→修改内存内容

• 数组传递中，参数会由数组类型退化为指向数组首地址的指针类型
• 数组长度无法传递
• 多维数组的最高位才会产生退化

// 注意这里的函数参数
// int (*)[] 指参数类型是指向元素为一维数组的数组指针
void func2(int (*par)[]) { }
// 等价写法
// 注意 [4]，元素数组的长度必须与 argument 匹配
void func2(int [][4]) {}
int main()
{
    int a[3][4];
    func2(a);
    return 0;
}

• 如果需要阻止类型退化，以引用的形式作为参数

// 注意引用和指针的区别
// 此时不会退化，因此以二维数组的作为实参的形参必须是二维数组的引用
// 该方法可以传递数组长度
void func4(int (&ref)[3][4]) {}
int main()
{
    int a[3][4];
    func4(a);
    // error: invalid initialization of reference of type
    int b[2][4];
    func4(b);
}

• 需要使用 <initializer_list>
• 所有参数必须类型相同

• 成员函数

// 自定义缺省参数
void fun(int x = 0) {};
// 调用 fun(0)
fun();

• 多参数情况下，若某个参数有缺省参数，其右边的所有参数都必须有缺省参数
• 同个翻译单元中，缺省参数只能定义一次

// 声明中可以进行缺省参数默认值的定义
// 但同单元只能定义一次

void fun(int x, int y = 2, int z = 3);

//error: previous specification 
void fun(int x, int y = 2, int z = 3)
{
    std::cout << x + y + z << std::endl;
}

int main()
{
    fun(1);
    return 0;
}

• 如果函数存在多个声明，只要缺省参数的定义不重复，可以组合到一起使用

// ok
void fun(int x, int y = 2, int z = 3);
void fun(int x = 1, int y, int z);

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

int main(int argc, char const *argv[])
{
    fun();
    return 0;
}

• 缺省参数为变量时，编译器会将默认参数视作该变量

int x = 3;
void fun(int y = x){}

// 调用 fun(x)，而不是fun(3)
fun();

int main(int argc, char const *argv[])
{
    for(int i =0; i < argc; ++i)
    {
        std::cout << argv[i] << "\n";
    }
    return 0;
}

# args 
# 1 为 argc = 0; 存储于 argv[0]
# ...
# 4 存储于 argv[3]
demo 1 2 3 4

• argv[0] 一定是指当前程序名，可以用其表示当前程序名

std::cerr << "Usage: " << argv[0] << "detals ....";

• void 函数通常是隐式返回
• main() 也支持隐式返回，返回类型为 int，正常结束的程序返回值为 0
• 有返回类型的函数通常需要显式返回
  • 使用 return + 语句 / 表达式 / 初始化列表

// void 的显式返回
// 可以用作跳出当前函数体的手段
// 如果有返回值类型，那么返回值必须匹配该类型
return;

std::vector<int> fun2()
{
    return {1,2,3,4,5};
}

• 自动对象（临时，局部变量）被返回时一定要注意其生存周期
• 不要返回局部变量的引用和指针
  • 静态局部变量的生存周期不受函数影响，因此可以使用

• 分为具名和非具名返回值
• C++ 17 会进行强制性的临时对象（非具名）返回优化：返回临时对象不会调用拷贝构造函数

# 初始化和返回默认情况下都会进行拷贝构造
# 系统会开辟内存->拷贝到内存->初始化
# 将拷贝的行为替换为直接在申请内存上直接构造，省略拷贝的过程
# 关闭返回值优化
# not work on C++ 17
fno-elide-constructors

• 返回类型在编译期会确定，表示函数的计算结果类型
• 返回类型不能省略

// 经典返回
int fun(int a, int b) {}
// 尾部返回 C++11
// 使用泛型编程的时候，参数的类型由模板参数决定，在后面写返回类型更方便
// 返回类的成员函数的自定义类型，在后面写更方便
// 尾部返回可以自动查找域
auto fun(int a, int b) -> int {}

// 自动推导返回 C++14
// 基于 return 语句进行推导
// 返回 int
auto fun(int a, int b) { return a + b; }

// 与运行期条件不同，constexpr 在编译器生效
// 通过 constexpr value 来舍弃某个分支的 return
// 实际上编译结果只存在一个 return 的类型
constexpr bool value = true;
auto fun()
{
    if constexpr (value) 
    { 
        return 1; 
    } 
    else 
    {
        return 3.14; 
    }
}

struct Str
{
    int x;
    int y;
};

Str fun()
{
    return Str{};
}

int main(int argc, char const *argv[])
{

    // C++ 17
    // v1 v2 实际上是引用
    // 使用 v1, v2 直接绑定了 x 和 y
    auto [v1, v2] = fun();
    v1;
    v2;

    //Str res = fun();
    return 0;
}

• 防止函数的返回结果没有被正确的利用
• 防止内存泄漏

// 使用 warning 提醒该返回值非常重要，不能忽略
[[nodiscard]] int fun(int a, int b) 
{
    return a + b;
}

int main()
{
    // 返回值没有用到
    // warning: ignoring return value
    fun(2, 3);
}

• 使用相同函数名定义多个不同参数列表的函数
  • 参数数量不同
  • 参数类型不同
  • 跟参数名和返回类型无关

重载函数会被 mangle 为以下的格式：

# 除了函数名，还有参数的信息
000000014000145c T _Z3fund
0000000140001450 T _Z3funi

• 限定查找（只会在指定区域内查找）
• 非限定查找
  • 优先查找所在域，没找到回去上级
  • 查找顺序从上到下
  • 如果希望优先本域的函数，需要做前置声明
    • 两个同名函数在同域时，在调用重载函数的位置之前声明

void fun()
{
    std::cout << "global fun\n";
}

namespace myNS
{
    void fun()
    {
        std::cout << "NS fun\n";
    }
    void g() 
    {
        fun();
    }
}

int main(int argc, char const *argv[])
{
    // 限定名称查找
    // 指定了查找的区域
    // 域可以由 Namespace，class(sub class) 形成
    ::fun();
    myNS::fun();

    // 非限定名称查找
    // 会从当前的域(myNS)开始查找
    // 一旦查找到名称，就会停止 name lookup
    // 调用 myNS::fun()
    myNS::g();

    // 如果当前域不存在 fun() 则会去上级查找
    // 查找的顺序从上到下，如果域内的 myNS::fun() 的定义在 g() 之后
    // 那么会调用 ::fun()
    // 可以提前声明 myNS::fun() 来告诉编译器本域中存在 myNS::fun() 的定义
    return 0;
}

• name lookup 只按照名字来，不区分实体（比如变量与函数同名时，优先选择变量）
• 也是逐级往上查找

• 如果是结构体的对象作为参数，结构体的内部会被纳入域
• 只对自定义类型生效
• 函数模板会进行实例化，实例化的过程中会导致查找范围扩大

1. 过滤不能被调用的版本（non-viable candidate）
   1. 参数数量不匹配
   2. 实参无法被转变为形参
   3. 实参不满足形参的限制条件
2. Best match
   1. 单个参数
      1. 选择匹配等级高的版本

级别越低，匹配程度越高

• rank 1：完美匹配或平凡转换（加一个 const）
• rank 2：提升（小尺寸到大尺寸）或者提升加平凡转换
• rank 3：标准转换 / 标准转换加平凡转换
• rank 4：自定义转换：类的类型转换
• rank 5：调用形参为省略号的版本

// 左值会优先选择非 const 版本
// 编译器会倾向选择保证对应变量的访问权限的函数
void fun(int& x){}
void fun(const int& x){}

// int& 
fun(x);
// const int&
fun(3);

• 多个参数时，最佳匹配函数中的所有参数匹配都优先级都要高于其他候选

• 通常用于描述复杂的迭代过程

• 普通函数会有额外的开销
  • 运行期会建立 stack frame 用于保护函数的掉用
• 内联函数是一种优化机制：如果函数的内部逻辑较为简单，则将函数的内容直接在 main 中执行
• 编译器替换的机制：
  • 取决于编译器的实现机制
  • 对于逻辑复杂的函数，overhead 的 cost 不是很明显
• 展开不是简单的替换
  • 替换需要保证替换前和替换后执行效果是一样的，需要检测很多问题（比如命名冲突）
• 定义在翻译单元外的函数无法内联：内联发生在编译期，而翻译单元以外的定义处理在链接期

• inline 关键字修饰的函数可以重复定义。
• 实际上，inline 函数保证同时只有一个定义用于链接期。这使得函数定义的范围从翻译单元变为了跨翻译单元。
• inline 的定义应该与其声明处于同一位置