第六章:函数

　　笔记

　　　　1. 通过调用运算符(call operator)来执行函数。调用运算符的形式是一对圆括号，它作用于一个表达式，该表达式是一个函数或指向函数的指针。

　　　　2. 在c++语言中，名字有作用域，对象有生命周期。

　　　　　　　a. 名字的作用域是程序文本的一部分，名字在其中可见。

　　　　　　　b. 对象的生命周期是程序执行过程中该对象存在的一段时间。

　　　　3. 函数体是一个语句块，块构成一个新的作用域。

　　　　4. 形参和函数体内部定义的变量统称为局部变量(local variable)。

　　　　5. 局部静态对象(local static object)在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止才被销毁。

　　　　6. 函数只能定义一次，但可以声明多次。函数的声明也称作函数原型。

　　　　7. 每次调用函数时都会重新创建它的形参，并用传入的实参对形参进行初始化。

　　　　8. 在c++语言中，建议使用引用类型的形参替代指针。

　　　　9. 使用引用避免拷贝。拷贝大的类类型对象或者容器对象比较低效，甚至有的类类型(包括IO类型在内)根本就不支持拷贝操作。

　　　　10. 如果函数无须改变引用形参的值，最好将其声明为常量引用。

　　　　// 不良设计：第一个形参的类型应该是const string&　　　　string::size_type find_char(string &s, char c,                                             string::size_type &occurs);　　　　// 只能将find_char函数作用于string对象。　　　　find_char("Hello World", 'o', ctr);    // 错误　　　　// 尽量使用常量引用

　　　　11. 可以使用非常量初始化一个底层cosnt对象，但是反过来不行。

　　　　12. 数组的两个特殊性质对我们定义和使用作用在数组上的函数由影响：a. 不允许拷贝数组；b. 使用数组时通常会将其转换成指针。

　　　　13. c++语言允许将变量定义成数组的引用，形参也可以是数组的应用。

　　　　// 正确：形参是数组的应用，维度是类型的一部分　　　　void print(int (&arr)[10])   // &arr两端的括号必不可少　　　　{   　　　　 for (auto elem : arr)       　　　　 cout << elem << endl;　　　　}

　　　　14. 传递多维数组。数组的第二维的大小都是数组类型的一部分，不能省略。

　　　　// matrix 指向数组的首元素，该数组的元素是由10个整数构成的数组　　　　void print(int (*matrix)[10], int rowSize)      { /*  ...  */}　　　　//  再次强调， *matrix两端的括号必不可少　　　　//  int *matrix[10];        10个指针构成的数组　　　　//  int (*matrix)[10];      指向含有10个整数的数组的指针　　　　// 等价定义　　　　void print(int matrix[][10], int rowSize) { /*  ...  */}　　　　// matrix 的声明看起来是一个二维数组，实际上形参是指向含有10个整数的数组的指针

　　　　15. main：处理命令行选项：

　　　　int main(int argc, char *argv[])　　　　// 第二个形参argv是一个一维数组，它的元素是指向C风格字符串的指针　　　　// 等价定义　　　　int main(int argc, char **argv)    { ... }

　　　　16. C++新标准提供了两种主要方法：如果所有的实参类型相同，可以传递一个名为initializer_list的标准库类型。和vector不一样的是，initializer_list对象中的元素永远是常量值，我们无法改变initializer_list对象中元素的值。

　　　　17. return语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换成函数的返回类型。

　　　　　　返回一个值的方式和初始化一个变量或形参的方式完全一样：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。

　　　　18. 不要返回局部对象的引用或指针。

　　　　// 严重错误：这个函数试图返回局部对象的引用　　　　const string &manip()　　　　{  　　　　  string ret; 　　　　   //  以某种方式改变一下ret 　　　　   if (!ret.empty())   　　　　     return ret;            //  错误：返回局部对象的引用　　　　    else     　　　　   return "Empty";   //  错误："Empty"是一个局部临时量　　　　}　　　　// 上面的两条return语句都将返回未定义的值，也就是，试图使用manip函数的返回值将　　　　//  发生未定义的行为。对于第一条return语句来说，显然它返回的是局部对象的引用。在　　　　// 第二条return语句中，字符串字面值转换成一个局部临时string对象，对于manip来说　　　　// 该对象和ret一样都是局部的。当函数结束时临时对象占用的空间也就随之释放掉了，所　　　　// 以两条return语句都指向了不再可用的内存空间。

　　　　19. 引用返回左值。调用一个返回引用的函数得到左值，其他返回类型得到右值。

　　　　// 我们能为返回类型是非常量引用的函数　　　　char &get_val(string &str, string::size_type ix)　　　　{ 　　　　   return str[ix];　　　　}　　　　int main()　　　　{  　　　　  string s("a value");　　　　    cout << s << endl;           // 输出a value　　　　    get_val(s, 0) = 'A';            // 将s[0]的值改为A　　　　    cout << s << endl;　　　　    return 0;　　　　}　　　　// 如果返回类型是常量引用，我们不能给调用的结果赋值

　　　　20. C++新标准规定，函数可以返回花括号包围的值得列表，类似于其他返回结果，此处的列表也用来表示返回的临时量进行初始化。

　　　　vector
     
       process()　　　　{   　　　　 // ...  　　　　  // expected 和 actual是string对象  　　　　  if (expected.empty())  　　　　      return {}; 　　　　   else if (expected == actual) 　　  　　     return { "functionX", "okay"};  　　　　  else        return { "functionX", expected, actual };　　　　} 　　　　// 如果函数返回的是类类型，由类本身定义初始化值如何定义
     

　　　　21. 在c++11新标准中可以使用尾置返回类型。

　　　　// func接受一个int类型的实参，返回一个指针，该指针指向含有10个整数的数组　　　　auto func(int i) -> int (*)[10];

　　　　22. 使用decltype

　　　　　　注意：decltype并不负责把数组类型转换成对应的指针，所以decltype的结果是个数组，要想返回指针还必须在函数声明时加一个*符号。

　　　　int odd[] = {
   1, 3, 5, 7, 9};　　　　int even[] = {
   0, 2, 4, 6, 8};　　　　// 返回一个指针，该指针指向含有5个整数的数组　　　　decltype(odd) *arrPtr(int i)　　　　{  　　　　  return (i % 2) ? &odd : &even;　　　　}

　　　　23. 函数匹配(function matching)是指一个过程，在这个过程中我们把函数调用与一组重载函数中的某一个关联起来，函数匹配也叫做函数确定(overload resolution)。

　　　　24. 一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值。

　　　　25. 当设计含有默认实参的函数时，其中一项任务是合理设置形参的顺序，尽量让不怎么使用的默认值的形参出现在前面，而让那些经常使用默认值的形参出现在后面。

　　　　26. 内联函数可以避免函数调用的开销。将函数指定为内联函数，通常就是将它们在每个调用点上"内联地"展开。另外，内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求。

　　　　27. 把内联函数和constexpr函数放在头文件内，毕竟，编译器要想展开函数仅有函数的声明是不够的，还需要函数的定义。

　　　　28. 调试帮助：assert预处理宏。所谓预处理宏其实就是一个预处理变量。 assert的行为依赖于一个名为NDEBUG的预处理变量的状态。我们可以使用一个#define语句定义NDEBUG，从而关闭调试状态。

　　重点知识点总结：

　　　　函数重载：

　　　　　　如果同一作用域的几个函数名字相同但形参列表不同，我们称之为重载(overloaded)函数。

　　　　　　一. 重载和const形参：顶层const不影响传入函数对象。一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来：

　　　　Record lookup(Phone);　　　　Record lookup(const Phone);       //  重复声明了Record lookup(Phone)　　　　Record lookup(Phone*);　　　　Record lookup(Phone* const);     // 重复声明了Record lookup(Phone*)

　　　　另一方面，如果形参是某种类型的指针或引用，则通过区分其指向的是常量对象还是非常量对象可以实现函数重载，此时的const是底层的：

　　　　// 对于接受引用或指针的函数来说，对象是常量还是非常量对应的形参不同　　　　// 定义了4个独立的重载函数　　　　Record lookup(Account&);            // 函数作用于Account的引用　　　　Record lookup(const Account&);   // 新函数，作用于常量引用　　　　Record lookup(Account*);          // 新函数，作用于指向Account的指针　　　　Record lookup(const Account*); // 新函数，作用于指向常量的指针

　　　　分析：上面的例子中，编译器可以通过实参是否是常量来推断应该调用哪个函数。因为const不能转换成其他类型，所以我们只能把const对象(或指向const的指针)传递给cosnt形参。相反的，因为非常量可以转换成const，所以上面的四个函数都能作用于非常量或者指向非常量的指针。不过，当我们传递非常量对象或者非常量对象的指针时，编译器会优先选择非常量版本的函数。

　　　　　　二. const_cast和重载

　　　　　　const_cast 在重载函数的情景中最有用。例如：

　　　　// 比较两个string对象的长度，返回较短的那个引用　　　　const string &shorterString(const string &s1, const string &s2)　　　　{   　　　　 return s1.size() <= s2.size() ? s1 : s2;　　　　}　　　　// 上面的返回结果仍然是const stirng的引用，因此我们需要一种新的shorterString函数　　　　// ，当它的实参不是常量时，得到的结果是一个普通的引用，使用const_cast可以做到这一点　　　　string &shorterString(string &s1, string &s2)　　　　{ 　　　　   auto &r = shorterString(const_cast
     
      (s1), 　　　　                                           const_cast
      
       (s2));　　　　    return const_cast
       
        (r);　　　　}　　　　// 这个引用事实上绑定在了某个初始的非常量的实参上，所以，我们可以再将其转换回一个　　　　// 普通的stirng&，这显然是安全的
       
      
     

 　　　　　　三. constexpr函数

　　　　　　　　　　constexpr函数只能用于常量表达式的函数。该函数的返回值类型及所有形参的类型都得是字面值类型，而且函数体中必须有且只有一条return语句。

　　　　　　　　const int new_sz()  { return 42; }　　　　　　　　const int foo = new_sz();    // 正确:foo是一个常量表达式

　　　　　　　　　　编译器把对constexpr函数的调用替换成其结果值。

　　　　　　四.函数匹配(p217)(待写)

　　　　　　五.函数指针(p221)(待写)

　　术语

　　　　调用运算符(call operator)、自动对象(automatic object)、局部静态对象(local static object)、

　　　　函数原型(function prototype)、引用传递(passed by reference)、值传递(passed by value)、

　　　　递归循环(recursion loop)、最佳匹配(best match)、预处理宏(preprocessor marco)、可行函数(viable function)、

　　　　二义性调用(ambiguous call)。