C++ Primer 5 CH6 函数

6.1 函数基础

• 函数包括：返回类型、函数名字、形参、函数体。
• 通过 “调用运算符”（一对圆括号）来执行函数，它作用于一个表达式，该表达式是函数或者指向函数的指针。
• 函数调用完成两项工作：用实参初始化形参；将控制权交给被调函数。
• return 语句完成两项工作：返回 return 语句的值（用于初始化调用表达式的结果）；将控制权交给主调函数。
• 形参列表的形参用逗号隔开，每个形参都是含有一个声明符的声明。
• 函数的返回值不能是数组类型或者函数类型，但可以是指向数组或者函数的指针。
• 形参是一种自动对象，函数开始时为形参申请存储空间，函数结束时形参被销毁。
• 局部静态对象，（定义成 static 类型）在程序的执行路径第一次经过对象语句时初始化，直到程序终止时销毁。

int count_calls() {
    static int cnt = 0;
    return ++cnt;
}
int main() {
    for (int i = 0; i < 10; ++i)
        cout << count_calls() << endl;
    return 0;
}

• 函数只能定义一次，可以声明多次。特例，如果一个函数永远不会被用到，可以只有声明没有定义。函数声明也叫函数原型。
• 函数三要素：返回类型、函数名、形参类型。
• 建议变量和函数在头文件中声明，在源文件中定义，确保同一函数的所有声明保持一致。

6.2 参数传递

• 形参是引用类型：绑定到对应的实参上；否则，将实参的值拷贝后赋给形参。
• 指针形参：可以通过指针修改它所指的对象的值。

void reset(int *p) {
    *p = 0;
    p = 0;
}
int main() {
    int i = 42;
    reset(&i);
    cout << i <<endl; // 0
}

• 通过使用引用形参，改变实参的值，使用引用避免拷贝。
• 可以使用引用形参来返回多个结果。
• 当用实参初始化形参时会忽略（形参的）顶层 const，当形参有顶层 const 时，传给它常量对象或者非常量对象都是可以的。

void func(const int i)
void func(int i) // 两个函数参数完全一样

• 数组形参

// 三种等价，形参都是 const *int 类型
void print(const *int);
void print(const int[]);
void print(const int[10]);

6.3 返回类型和 return 语句

• 如果函数返回引用，该引用仅是它所引对象的一个别名。
• 不要返回局部对象的引用或指针，函数终止时将指向不再有效的内存区域。
• 调用一个 “返回引用的函数” 得到左值，其他返回类型得到右值，可以像使用其他左值那样来使用 “返回引用的函数” 的调用。
• 函数可以返回花括号包围的值的列表，如果返回的是内置类型，花括号包围的列表 最多包含一个值；如果返回的是类类型，由类本身定义初始值如何使用。
• 函数不能返回数组，但是可以返回数组的指针或引用。

typedef int arrT[10]; // 含有 10 个整数的数组
using arrT = int[10]; // 等价声明
arrT* func(int i); // 返回指向 “含 10 个整数的数组” 的指针

• 返回数组指针的函数形式如下

Type (*function(parameter_list))[dimention]
eg. int (*func(int i))[10]

• 使用尾置返回类型

auto func(int i)->int(*)[10];

• 使用 decltype 声明返回类型

int even[] = {0,2,4,6,8};
int odd[] = {1,3,5,7,9};
decltype(odd) *arrPtr(int i) {
    return i % 2 ? &odd : &even;
}

6.4 函数重载

• 重载函数：函数名字相同但形参列表不同。
• 不允许两个函数除了返回类型之外其他都相同。
• 顶层 const 不影响传入的函数对象，底层 const 影响。

// 顶层 const
Record lookup(Phone);
Record lookup(const Phone); // 重复定义
// 底层 const
Record lookup(Accond*);
Record lookup(const Accond*); // 新函数

• const_cast 和重载

const string &shorterString(const string &s1, const string &s2) {
    return s1.size() < s2.size() ? s1 : s2;
}

string &shorterString(string s1, string s2) {
    auto r = shorterString(const_cast<const string&>(s1),
                           const_cast<const string&>(s2));
    return const_cast<string&>(r);
}

• 调用重载函数的三种可能
  
  找到最佳匹配函数，生成调用该函数的代码；
  
  找不到任何匹配函数，发出无匹配错误；
  
  多于一个函数可以匹配，但每一个都不是最佳匹配，发生 “二义性” 调用错误。

6.5 特殊用途语言特性

• 用作默认实参的名字在函数声明所在的作用域内解析，而这些名字的求值过程发生在函数调用时。

int a = 0, b = 1, c =2;
void f1(int a = a, int b = b, int c= c) {
    cout << a << b << c << endl;
}
void f2() {
    int a = 4; b = 5;
    f1(); // 隐藏外层的 a，局部变量与传给 f1 的默认实参无关
}
int main() {
    f1(); // 012
    f2(); // 052
    return 0;
}

• 内联函数（inline），在每个调用点展开，避免函数调用的开销。
• contexpr 函数，函数的返回类型以及所有形参的类型都是字面值类型，函数体只能有一条 return 语句。
• 允许 contexpr 函数返回值不是常数。

constexpr int foo(int cnt) {return 2 * cnt;}
foo(2); // 正确
int i = 2; foo(i); // 错误，i 不是常量表达式

• 内联函数和 contexpr 函数通常放在头文件中。
• assert 预处理宏，assert(expr)。

6.6 函数匹配

• 确定候选函数
• 与被调用的函数同名；
• 其声明在调用点可用。
• 确定可行函数
• 形参数量与实参数量相等；
• 每个实参类型与对应的形参类型相同，或者能够转换成形参类型；
• 寻找最佳匹配（如果有的话）
  
  寻找一个函数
• 该函数每个实参匹配不劣于其他函数的匹配；
• 至少一个实参的匹配优于其他函数的匹配；
  
  没有的话，二义性错误。
• 匹配等级
  
  
• 所有算术类型的转换级别都一样，不存在哪个转换级别更高。

void manip(long);
void manip(float);
manip(3.14); // 二义性错误

• const 实参：编译器通过实参是否是常量决定选择哪个函数。

Record lookup(Account&);
Record lookup(const Account&);
const Account a;
Account b;
lookup(a); // 选择 Record lookup(const Account&)
lookup(b); // 选择 Record lookup(Account&)

6.7 函数指针

• 函数类型由它的返回类型和形参类型决定。
• 声明：用指针替换函数名。

bool (*p) (const string&, const string&); // 未初始化
bool *p (const string&, const string&); // p 是一个返回值为 bool 指针的函数

• 当我们把函数名作为一个值使用时，该函数自动转换为指针，可以直接使用指针调用该函数，无需解引用指针。

foo2 = foo1; foo2 = &foo1; // 等价赋值
foo2(); (*foo2)(); foo1(); // 等价调用

• 重载函数指针：编译器通过指针类型决定选用哪个函数，指针类型必须与重载函数中的某一个精确匹配。
• 函数指针形参

// 等价声明
void foo1(string s1, string s2, bool foo2(int a, int b));
void foo1(string s1, string s2, bool (*foo2)(int a, int b));
// 调用
foo1(s1, s2, foo2);