# Chapter 6 Functions

# Function Basics

# 函数基础

• 函数定义：包括返回类型、函数名字和 0 个或者多个形参（parameter）组成的列表和函数体。
• 调用运算符：调用运算符的形式是一对圆括号 () ，作用于一个表达式，该表达式是函数或者指向函数的指针。
• 圆括号内是用逗号隔开的实参（argument）列表。
• 函数调用过程：
  • 1. 主调函数（calling function）的执行被中断。
  • 2. 被调函数（called function）开始执行。
• 形参和实参：形参和实参的个数和类型必须匹配上。
• 返回类型： void 表示函数不返回任何值。函数的返回类型不能是数组类型或者函数类型，但可以是指向数组或者函数的指针。
• 名字：名字的作用于是程序文本的一部分，名字在其中可见。

# 局部对象

• 生命周期：对象的生命周期是程序执行过程中该对象存在的一段时间。
• 局部变量（local variable）：形参和函数体内部定义的变量统称为局部变量。它对函数而言是局部的，对函数外部而言是隐藏的。
• 自动对象：只存在于块执行期间的对象。当块的执行结束后，它的值就变成未定义的了。
• 局部静态对象： static 类型的局部变量，生命周期贯穿函数调用前后。

# 函数声明

• 函数声明：函数的声明和定义唯一的区别是声明无需函数体，用一个分号替代。函数声明主要用于描述函数的接口，也称函数原型。
• 在头文件中进行函数声明：建议变量在头文件中声明；在源文件中定义。
• 分离编译： CC a.cc b.cc 直接编译生成可执行文件； CC -c a.cc b.cc 编译生成对象代码 a.o b.o ； CC a.o b.o 编译生成可执行文件。

# Exercise 6.1

实参和形参的区别的什么？

解：

实参是函数调用的实际值，是形参的初始值。

# Exercise 6.2

请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？

(a) int f() {

         string s;

         // ...

         return s;

   }

(b) f2(int i) { /* ... */ }

(c) int calc(int v1, int v1) { /* ... */ }

(d) double square (double x)  return x * x;

解：

应该改为下面这样：

(a) string f() {

         string s;

         // ...

         return s;

   }

(b) void f2(int i) { /* ... */ }

(c) int calc(int v1, int v2) { /* ... */ return ; }

(d) double square (double x) { return x * x; }

# Exercise 6.3

编写你自己的 fact 函数，上机检查是否正确。注：阶乘。

解：

#include <iostream>

int fact(int i)

{

    if(i<0)

    {

        std::runtime_error err("Input cannot be a negative number");

        std::cout << err.what() << std::endl;

    }

    return i > 1 ? i * fact( i - 1 ) : 1;

}

int main()

{

    std::cout << std::boolalpha << (120 == fact(5)) << std::endl;

    return 0;

}

启用 std::boolalpha ，可以输出 "true" 或者 "false" 。

# Exercise 6.4

编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在 main 函数中调用该函数。

#include <iostream>

#include <string>

int fact(int i)

{

    return i > 1 ? i * fact(i - 1) : 1;

}

void interactive_fact()

{

    std::string const prompt = "Enter a number within [1, 13) :\n";

    std::string const out_of_range = "Out of range, please try again.\n";

    for (int i; std::cout << prompt, std::cin >> i; )

    {

        if (i < 1 || i > 12)

        {

            std::cout << out_of_range; 

            continue;

        }

        std::cout << fact(i) << std::endl;

    }

}

int main()

{

    interactive_fact();

    return 0;

}

# Exercise 6.5

编写一个函数输出其实参的绝对值。

#include <iostream>

int abs(int i)

{

   return i > 0 ? i : -i;

}

int main()

{

   std::cout << abs(-5) << std::endl;

   return 0;

}

# Exercise 6.6

说明形参、局部变量以及局部静态变量的区别。编写一个函数，同时达到这三种形式。

解：

形参定义在函数形参列表里面；局部变量定义在代码块里面；
局部静态变量在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止时才被销毁。

// 例子

int count_add(int n)       //n 是形参

{

    static int ctr = 0;    //ctr 是局部静态变量

    ctr += n;

    return ctr;

}

int main()

{

    for (int i = 0; i != 10; ++i)  //i 是局部变量

      cout << count_add(i) << endl;

    return 0;

}

# Exercise 6.7

编写一个函数，当它第一次被调用时返回 0，以后每次被调用返回值加 1。

解：

int generate()

{

    static int ctr = 0;

    return ctr++;

}

# Exercise 6.8

编写一个名为 Chapter6.h 的头文件，令其包含 6.1 节练习中的函数声明。

解：

int fact(int val);

int func();

template <typename T> // 参考：https://blog.csdn.net/fightingforcv/article/details/51472586

T abs(T i)

{

    return i >= 0 ? i : -i;

}

# Exercise 6.9 : fact.cc | factMain.cc

编写你自己的 fact.cc 和 factMain.cc ，这两个文件都应该包含上一小节的练习中编写的 Chapter6.h 头文件。通过这些文件，理解你的编译器是如何支持分离式编译的。

解：

fact.cc：

#include "Chapter6.h"

#include <iostream>

int fact(int val)

{

    if (val == 0 || val == 1) return 1;

    else return val * fact(val-1);

}

int func()

{

    int n, ret = 1;

    std::cout << "input a number: ";

    std::cin >> n;

    while (n > 1) ret *= n--;

    return ret;

}

factMain.cc：

#include "Chapter6.h"

#include <iostream>

int main()

{

    std::cout << "5! is " << fact(5) << std::endl; 

    std::cout << func() << std::endl; 

    std::cout << abs(-9.78) << std::endl;

}

编译： g++ factMain.cpp fact.cpp -o main

# Argument Passing

# 参数传递

• 形参初始化的机理和变量初始化一样。
• 引用传递（passed by reference）：又称传引用调用（called by reference），指形参是引用类型，引用形参是它对应的实参的别名。
• 值传递（passed by value）：又称传值调用（called by value），指实参的值是通过拷贝传递给形参。

# 传值参数

• 当初始化一个非引用类型的变量时，初始值被拷贝给变量。
• 函数对形参做的所有操作都不会影响实参。
• 指针形参：常用在 C 中， C++ 建议使用引用类型的形参代替指针。

# 传引用参数

• 通过使用引用形参，允许函数改变一个或多个实参的值。
• 引用形参直接关联到绑定的对象，而非对象的副本。
• 使用引用形参可以用于返回额外的信息。
• 经常用引用形参来避免不必要的复制。
• void swap(int &v1, int &v2)
• 如果无需改变引用形参的值，最好将其声明为常量引用。

# const 形参和实参

• 形参的顶层 const 被忽略。 void func(const int i); 调用时既可以传入 const int 也可以传入 int 。
• 我们可以使用非常量初始化一个底层 const 对象，但是反过来不行。
• 在函数中，不能改变实参的局部副本。
• 尽量使用常量引用。

# 数组形参

• 当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。
• 要注意数组的实际长度，不能越界。

# main 处理命令行选项

• int main(int argc, char *argv[]){...}
• 第一个形参代表参数的个数；第二个形参是参数 C 风格字符串数组。

# 可变形参

initializer_list 提供的操作（ C++11 ）：

initializer_list 使用 demo：

void err_msg(ErrCode e, initializer_list<string> il){

    cout << e.msg << endl;

    for (auto bed = il.begin(); beg != il.end(); ++ beg)

        cout << *beg << " ";

    cout << endl;

}

err_msg(ErrCode(0), {"functionX", "okay});

• 所有实参类型相同，可以使用 initializer_list 的标准库类型。
• 实参类型不同，可以使用 可变参数模板 。
• 省略形参符： ... ，便于 C++ 访问某些 C 代码，这些 C 代码使用了 varargs 的 C 标准功能。

# Exercise 6.10

编写一个函数，使用指针形参交换两个整数的值。
在代码中调用该函数并输出交换后的结果，以此验证函数的正确性。

解：

#include <iostream>

#include <string>

void swap(int* lhs, int* rhs)

{

	int tmp;

	tmp = *lhs;

	*lhs = *rhs;

	*rhs = tmp;

}

int main()

{

	for (int lft, rht; std::cout << "Please Enter:\n", std::cin >> lft >> rht;)

	{

		swap(&lft, &rht);

		std::cout << lft << " " << rht << std::endl;

	}

	return 0;

}

# Exercise 6.11

编写并验证你自己的 reset 函数，使其作用于引用类型的参数。注：reset 即置 0。

解：

#include <iostream>

void reset(int &i)

{

    i = 0;

}

int main()

{

    int i = 42;

    reset(i);

    std::cout << i  << std::endl;

    return 0;

}

# Exercise 6.12

改写 6.2.1 节练习中的程序，使其引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？

#include <iostream>

#include <string>

void swap(int& lhs, int& rhs)

{

    int temp = lhs;

    lhs = rhs;

    rhs = temp;

}

int main()

{

    for (int left, right; std::cout << "Please Enter:\n", std::cin >> left >> right; )

    {

        swap(left, right);

        std::cout << left << " " << right << std::endl;

    }

    return 0;

}

很明显引用更好用。

# Exercise 6.13

假设 T 是某种类型的名字，说明以下两个函数声明的区别：
一个是 void f(T) , 另一个是 void f(&T) 。

解：

void f(T) 的参数通过值传递，在函数中 T 是实参的副本，改变 T 不会影响到原来的实参。
void f(&T) 的参数通过引用传递，在函数中的 T 是实参的引用， T 的改变也就是实参的改变。

# Exercise 6.14

举一个形参应该是引用类型的例子，再举一个形参不能是引用类型的例子。

解：

例如交换两个整数的函数，形参应该是引用

void swap(int& lhs, int& rhs)

{

	int temp = lhs;

	lhs = rhs;

	rhs = temp;

}

当实参的值是右值时，形参不能为引用类型

int add(int a, int b)

{

	return a + b;

}

int main()

{

	int i = add(1,2);

	return 0;

}

# Exercise 6.15

说明 find_char 函数中的三个形参为什么是现在的类型，特别说明为什么 s 是常量引用而 occurs 是普通引用？
为什么 s 和 occurs 是引用类型而 c 不是？
如果令 s 是普通引用会发生什么情况？
如果令 occurs 是常量引用会发生什么情况？

解：

• 因为字符串可能很长，因此使用引用避免拷贝；
• 而在函数中我们不希望改变 s 的内容，所以令 s 为常量。
• occurs 是要传到函数外部的变量，所以使用引用， occurs 的值会改变，所以是普通引用。
• 因为我们只需要 c 的值，这个实参可能是右值 (右值实参无法用于引用形参)，所以 c 不能用引用类型。
• 如果 s 是普通引用，也可能会意外改变原来字符串的内容。
• occurs 如果是常量引用，那么意味着不能改变它的值，那也就失去意义了。

# Exercise 6.16

下面的这个函数虽然合法，但是不算特别有用。指出它的局限性并设法改善。

bool is_empty(string& s) { return s.empty(); }

解：

局限性在于常量字符串和字符串字面值无法作为该函数的实参，如果下面这样调用是非法的：

const string str;

bool flag = is_empty(str); // 非法

bool flag = is_empty("hello"); // 非法

所以要将这个函数的形参定义为常量引用：

bool is_empty(const string& s) { return s.empty(); }

# Exercise 6.17

编写一个函数，判断 string 对象中是否含有大写字母。
编写另一个函数，把 string 对象全部改写成小写形式。
在这两个函数中你使用的形参类型相同吗？为什么？

解：

两个函数的形参不一样。第一个函数使用常量引用，第二个函数使用普通引用。

# Exercise 6.18

为下面的函数编写函数声明，从给定的名字中推测函数具备的功能。

• (a) 名为 compare 的函数，返回布尔值，两个参数都是 matrix 类的引用。
• (b) 名为 change_val 的函数，返回 vector 的迭代器，有两个参数：一个是 int ，另一个是 vector 的迭代器。

解：

(a) bool compare(matrix &m1, matrix &m2);

(b) vector<int>::iterator change_val(int, vector<int>::iterator);

# Exercise 6.19

假定有如下声明，判断哪个调用合法、哪个调用不合法。对于不合法的函数调用，说明原因。

double calc(double);

int count(const string &, char);

int sum(vector<int>::iterator, vector<int>::iterator, int);

vector<int> vec(10);

(a) calc(23.4, 55.1);

(b) count("abcda",'a');

(c) calc(66);

(d) sum(vec.begin(), vec.end(), 3.8);

解：

• (a) 不合法。 calc 只有一个参数。
• (b) 合法。
• (c) 合法。
• (d) 合法。

# Exercise 6.20

引用形参什么时候应该是常量引用？如果形参应该是常量引用，而我们将其设为了普通引用，会发生什么情况？

解：

应该尽量将引用形参设为常量引用，除非有明确的目的是为了改变这个引用变量。
如果形参应该是常量引用，而我们将其设为了普通引用，那么常量实参将无法作用于普通引用形参。

# Exercise 6.21

编写一个函数，令其接受两个参数：一个是 int 型的数，另一个是 int 指针。
函数比较 int 的值和指针所指的值，返回较大的那个。
在该函数中指针的类型应该是什么？

解：

#include <iostream>

using std::cout;

int larger_one(const int i, const int *const p)

{

    return (i > *p) ? i : *p;

}

int main()

{

    int i = 6;

    cout << larger_one(7, &i);

    return 0;

}

应该是 const int * 类型。

# Exercise 6.22

编写一个函数，令其交换两个 int 指针。

解：

#include <iostream>

#include <string>

void swap(int*& lft, int*& rht)

{

    auto tmp = lft;

    lft = rht;

    rht = tmp;

}

int main()

{

    int i = 42, j = 99;

    auto lft = &i;

    auto rht = &j;

    swap(lft, rht);

    std::cout << *lft << " " << *rht << std::endl;

    return 0;

}

# Exercise 6.23

参考本节介绍的几个 print 函数，根据理解编写你自己的版本。
依次调用每个函数使其输入下面定义的 i 和 j :

int i = 0, j[2] = { 0, 1 };

解：

#include <iostream>

using std::cout; using std::endl; using std::begin; using std::end;

void print(const int *pi)

{

    if(pi)

        cout << *pi << endl;

}

void print(const char *p)

{

    if (p)

        while (*p) cout << *p++;

    cout << endl;

}

void print(const int *beg, const int *end)

{

    while (beg != end)

        cout << *beg++ << endl;

}

void print(const int ia[], size_t size)

{

    for (size_t i = 0; i != size; ++i) {

        cout << ia[i] << endl;

    }

}

void print(int (&arr)[2])

{

    for (auto i : arr)

        cout << i << endl;

}

int main()

{

    int i = 0, j[2] = { 0, 1 };

    char ch[5] = "pezy";

    print(ch);

    print(begin(j), end(j));

    print(&i);

    print(j, end(j)-begin(j));

    print(j);

    return 0;

}

# Exercise 6.24

描述下面这个函数的行为。如果代码中存在问题，请指出并改正。

void print(const int ia[10])

{

	for (size_t i = 0; i != 10; ++i)

		cout << ia[i] << endl;

}

解：

当数组作为实参的时候，会被自动转换为指向首元素的指针。
因此函数形参接受的是一个指针。
如果要让这个代码成功运行 (不更改也可以运行），可以将形参改为数组的引用。

void print(const int (&ia)[10])

{

	for (size_t i = 0; i != 10; ++i)

		cout << ia[i] << endl;

}

# Exercise 6.25

编写一个 main 函数，令其接受两个实参。把实参的内容连接成一个 string 对象并输出出来。

# Exercise 6.26

编写一个程序，使其接受本节所示的选项；输出传递给 main 函数的实参内容。

解：

包括 6.25

#include <iostream>

#include <string>

int main(int argc, char **argv)

{

    std::string str;

    for (int i = 1; i != argc; ++i)

        str += std::string(argv[i]) + " ";

    std::cout << str << std::endl;

    return 0;

}

# Exercise 6.27

编写一个函数，它的参数是 initializer_list 类型的对象，函数的功能是计算列表中所有元素的和。

解：

#include <iostream>

#include <initializer_list>

int sum(std::initializer_list<int> const& il)

{

    int sum = 0;

    for (auto i : il) sum += i;

    return sum;

}

int main(void)

{

    auto il = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    std::cout << sum(il) << std::endl;

    return 0;

}

# Exercise 6.28

在 error_msg 函数的第二个版本中包含 ErrCode 类型的参数，其中循环内的 elem 是什么类型？

解：

elem 是 const string & 类型。

# Exercise 6.29

在范围 for 循环中使用 initializer_list 对象时，应该将循环控制变量声明成引用类型吗？为什么？

解：

应该使用常量引用类型。 initializer_list 对象中的元素都是常量，我们无法修改 initializer_list 对象中的元素的值。

# Return Types and the return Statement

# 返回类型和 return 语句

# 无返回值函数

没有返回值的 return 语句只能用在返回类型是 void 的函数中，返回 void 的函数不要求非得有 return 语句。

# 有返回值函数

• return 语句的返回值的类型必须和函数的返回类型相同，或者能够隐式地转换成函数的返回类型。
• 值的返回：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。
• 不要返回局部对象的引用或指针。
• 引用返回左值：函数的返回类型决定函数调用是否是左值。调用一个返回引用的函数得到左值；其他返回类型得到右值。
• 列表初始化返回值：函数可以返回花括号包围的值的列表。（ C++11 ）
• 主函数 main 的返回值：如果结尾没有 return ，编译器将隐式地插入一条返回 0 的 return 语句。返回 0 代表执行成功。

# 返回数组指针

• Type (*function (parameter_list))[dimension]
• 使用类型别名： typedef int arrT[10]; 或者 using arrT = int[10;] ，然后 arrT* func() {...}
• 使用 decltype ： decltype(odd) *arrPtr(int i) {...}
• 尾置返回类型： 在形参列表后面以一个 -> 开始： auto func(int i) -> int(*)[10] （ C++11 ）

# Exercise 6.30

编译第 200 页的 str_subrange 函数，看看你的编译器是如何处理函数中的错误的。

解：

编译器信息：

g++ (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609

编译错误信息：

ch6.cpp:38:9: error: return-statement with no value, in function returning ‘bool’ [-fpermissive]

# Exercise 6.31

什么情况下返回的引用无效？什么情况下返回常量的引用无效？

解：

当返回的引用的对象是局部变量时，返回的引用无效；当我们希望返回的对象被修改时，返回常量的引用无效。

# Exercise 6.32

下面的函数合法吗？如果合法，说明其功能；如果不合法，修改其中的错误并解释原因。

int &get(int *array, int index) { return array[index]; }

int main()

{

    int ia[10];

    for (int i = 0; i != 10; ++i)

        get(ia, i) = i;

}

解：

合法。 get 函数根据索引取得数组中的元素的引用。

# Exercise 6.33

编写一个递归函数，输出 vector 对象的内容。

解：

#include <iostream>

#include <vector>

using std::vector; using std::cout;

using Iter = vector<int>::const_iterator;

void print(Iter first, Iter last)

{

    if (first != last)

    {

        cout << *first << " ";

        print(++first, last);

    }

}

int main()

{

    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    print(vec.cbegin(), vec.cend());

    return 0;

}

# Exercise 6.34

如果 factorial 函数的停止条件如下所示，将发生什么？

if (val != 0)

解：
如果 val 为正数，从结果上来说没有区别（多乘了个 1）;
如果 val 为负数，那么递归永远不会结束。

# Exercise 6.35

在调用 factorial 函数时，为什么我们传入的值是 val-1 而非 val-- ？

解：

如果传入的值是 val-- ，那么将会永远传入相同的值来调用该函数，递归将永远不会结束。

# Exercise 6.36

编写一个函数声明，使其返回数组的引用并且该数组包含 10 个 string 对象。
不用使用尾置返回类型、 decltype 或者类型别名。

解：

string (&fun())[10];

# Exercise 6.37

为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用 decltype 关键字。
你觉得哪种形式最好？为什么？

解：

typedef string str_arr[10];

str_arr& fun();

auto fun()->string(&)[10];

string s[10];

decltype(s)& fun();

我觉得尾置返回类型最好，就一行代码。

# Exercise 6.38

修改 arrPtr 函数，使其返回数组的引用。

解：

decltype(odd)& arrPtr(int i)

{

    return (i % 2) ? odd : even;

}

# Overloaded Functions

# 函数重载

• 重载：如果同一作用域内几个函数名字相同但形参列表不同，我们称之为重载（overload）函数。
• main 函数不能重载。
• 重载和 const 形参：
  • 一个有顶层 const 的形参和没有它的函数无法区分。 Record lookup(Phone* const) 和 Record lookup(Phone*) 无法区分。
  • 相反，是否有某个底层 const 形参可以区分。 Record lookup(Account*) 和 Record lookup(const Account*) 可以区分。
• 重载和作用域：若在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体，在不同的作用域中无法重载函数名。

# Exercise 6.39

说明在下面的每组声明中第二条语句是何含义。
如果有非法的声明，请指出来。

(a) int calc(int, int);

	int calc(const int, const int);

(b) int get();

	double get();

(c) int *reset(int *);

	double *reset(double *);

解：

• (a) 非法。因为顶层 const 不影响传入函数的对象，所以第二个声明无法与第一个声明区分开来。
• (b) 非法。对于重载的函数来说，它们应该只有形参的数量和形参的类型不同。返回值与重载无关。
• (c) 合法。

# Features for Specialized Uses

# 特殊用途语言特性

# 默认实参

• string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');
• 一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。

# 内联（inline）函数

• 普通函数的缺点：调用函数比求解等价表达式要慢得多。
• inline 函数可以避免函数调用的开销，可以让编译器在编译时内联地展开该函数。
• inline 函数应该在头文件中定义。

# constexpr 函数

• 指能用于常量表达式的函数。
• constexpr int new_sz() {return 42;}
• 函数的返回类型及所有形参类型都要是字面值类型。
• constexpr 函数应该在头文件中定义。

# 调试帮助

• assert 预处理宏（preprocessor macro）： assert(expr);

开关调试状态：

CC -D NDEBUG main.c 可以定义这个变量 NDEBUG 。

void print(){

    #ifndef NDEBUG

        cerr << __func__ << "..." << endl;

    #endif

}

# Exercise 6.40

下面的哪个声明是错误的？为什么？

(a) int ff(int a, int b = 0, int c = 0);

(b) char *init(int ht = 24, int wd, char bckgrnd);

解：

(a) 正确。
(b) 错误。因为一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。

# Exercise 6.41

下面的哪个调用是非法的？为什么？哪个调用虽然合法但显然与程序员的初衷不符？为什么？

char *init(int ht, int wd = 80, char bckgrnd = ' ');

(a) init();

(b) init(24,10);

(c) init(14,'*');

解：

• (a) 非法。第一个参数不是默认参数，最少需要一个实参。
• (b) 合法。
• (c) 合法，但与初衷不符。字符 * 被解释成 int 传入到了第二个参数。而初衷是要传给第三个参数。

# Exercise 6.42

给 make_plural 函数的第二个形参赋予默认实参's', 利用新版本的函数输出单词 success 和 failure 的单数和复数形式。

解：

#include <iostream>

#include <string>

using std::string;

using std::cout;

using std::endl;

string make_plural(size_t ctr, const string& word, const string& ending = "s")

{

	return (ctr > 1) ? word + ending : word;

}

int main()

{

	cout << "single: " << make_plural(1, "success", "es") << " "

		<< make_plural(1, "failure") << endl;

	cout << "plural : " << make_plural(2, "success", "es") << " "

		<< make_plural(2, "failure") << endl;

	return 0;

}

# Exercise 6.43

你会把下面的哪个声明和定义放在头文件中？哪个放在源文件中？为什么？

(a) inline bool eq(const BigInt&, const BigInt&) {...}

(b) void putValues(int *arr, int size);

解：

全部都放进头文件。(a) 是内联函数，(b) 是声明。

# Exercise 6.44

将 6.2.2 节的 isShorter 函数改写成内联函数。

解：

inline bool is_shorter(const string &lft, const string &rht) 

{

    return lft.size() < rht.size();

}

# Exercise 6.45

回顾在前面的练习中你编写的那些函数，它们应该是内联函数吗？
如果是，将它们改写成内联函数；如果不是，说明原因。

解：

一般来说，内联机制用于优化规模小、流程直接、频繁调用的函数。

# Exercise 6.46

能把 isShorter 函数定义成 constexpr 函数吗？
如果能，将它改写成 constxpre 函数；如果不能，说明原因。

解：

不能。 constexpr 函数的返回值类型及所有形参都得是字面值类型。

# Exercise 6.47

改写 6.3.2 节练习中使用递归输出 vector 内容的程序，使其有条件地输出与执行过程有关的信息。
例如，每次调用时输出 vector 对象的大小。
分别在打开和关闭调试器的情况下编译并执行这个程序。

解：

#include <iostream>

#include <vector>

using std::vector; using std::cout; using std::endl;

void printVec(vector<int> &vec)

{

#ifndef NDEBUG

    cout << "vector size: " << vec.size() << endl;

#endif

    if (!vec.empty())

    {

        auto tmp = vec.back();

        vec.pop_back();

        printVec(vec);

        cout << tmp << " ";

    }

}

int main()

{

    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    printVec(vec);

    cout << endl;

    return 0;

}

# Exercise 6.48

说明下面这个循环的含义，它对 assert 的使用合理吗？

string s;

while (cin >> s && s != sought) { } // 空函数体

assert(cin);

解：

不合理。从这个程序的意图来看，应该用

assert(s == sought);

# Function Matching

# 函数匹配

• 重载函数匹配的三个步骤：1. 候选函数；2. 可行函数；3. 寻找最佳匹配。
• 候选函数：选定本次调用对应的重载函数集，集合中的函数称为候选函数（candidate function）。
• 可行函数：考察本次调用提供的实参，选出可以被这组实参调用的函数，新选出的函数称为可行函数（viable function）。
• 寻找最佳匹配：基本思想：实参类型和形参类型越接近，它们匹配地越好。

# Exercise 6.49

什么是候选函数？什么是可行函数？

解：

候选函数：与被调用函数同名，并且其声明在调用点可见。
可行函数：形参与实参的数量相等，并且每个实参类型与对应的形参类型相同或者能转换成形参的类型。

# Exercise 6.50

已知有第 217 页对函数 f 的声明，对于下面的每一个调用列出可行函数。
其中哪个函数是最佳匹配？
如果调用不合法，是因为没有可匹配的函数还是因为调用具有二义性？

(a) f(2.56, 42)

(b) f(42)

(c) f(42, 0)

(d) f(2.56, 3.14)

解：

• (a) void f(int, int); 和 void f(double, double = 3.14); 是可行函数。
  该调用具有二义性而不合法。
• (b) void f(int); 是可行函数。调用合法。
• (c) void f(int, int); 和 void f(double, double = 3.14); 是可行函数。
  void f(int, int); 是最佳匹配。
• (d) void f(int, int); 和 void f(double, double = 3.14); 是可行函数。
  void f(double, double = 3.14); 是最佳匹配。

# Exercise 6.51

编写函数 f 的 4 版本，令其各输出一条可以区分的消息。
验证上一个练习的答案，如果你的回答错了，反复研究本节内容直到你弄清自己错在何处。

解：

#include <iostream>

using std::cout; using std::endl;

void f()

{

    cout << "f()" << endl;

}

void f(int)

{

    cout << "f(int)" << endl;

}

void f(int, int)

{

    cout << "f(int, int)" << endl;

}

void f(double, double)

{

    cout << "f(double, double)" << endl;

}

int main()

{

    //f(2.56, 42); // error: 'f' is ambiguous.

    f(42);

    f(42, 0);

    f(2.56, 3.14);

    return 0;

}

# Exercise 6.52

已知有如下声明：

void manip(int ,int);

double dobj;

请指出下列调用中每个类型转换的等级。

(a) manip('a', 'z');

(b) manip(55.4, dobj);

解：

• (a) 第 3 级。类型提升实现的匹配。
• (b) 第 4 级。算术类型转换实现的匹配。

# Exercise 6.53

说明下列每组声明中的第二条语句会产生什么影响，并指出哪些不合法（如果有的话）。

(a) int calc(int&, int&); 

	int calc(const int&, const int&); 

(b) int calc(char*, char*);

	int calc(const char*, const char*);

(c) int calc(char*, char*);

	int calc(char* const, char* const);

解：

(c) 不合法。顶层 const 不影响传入函数的对象。

# Pointers to Functions

# 函数指针

• 函数指针：是指向函数的指针。

• bool (*pf)(const string &, const string &); 注：两端的括号不可少。

• 函数指针形参：

  • 形参中使用函数定义或者函数指针定义效果一样。
  • 使用类型别名或者 decltype 。

  需要注意的是，decltype 返回函数类型，此时不会将函数类型自动转换成指针类型。因为 decltype 的结果是函数类型，所以只有结果起那面加上 * 才能得到指针。

• 返回指向函数的指针：1. 类型别名；2. 尾置返回类型。

  和数组类似，虽然不能返回一个函数，但是能返回指向函数类型的指针。然而，我们必须把返回类型写成指针形式，编译器不会自动地将函数返回类型当成对应的指针类型处理。

  	using F = int(int*, int); // F 是函数类型，不是指针
  	using PF = int(*)(int*, int); // PF 是指针类型

  必须时刻注意的是，和函数类型的形参不一样，返回类型不会自动地转换成指针。

  	PF f1(int); // 正确：PF 是指向函数的指针，f1 返回指向函数的指针
  	F f1(int); // 错误：F 是函数类型，f1 不能返回一个函数
  	F *f1(int); // 正确：显示地执行返回类型是指向函数的指针

• 将 auto 和 decltype 用于函数指针类型

  牢记当我们将 decltype 作用于某个函数时，它返回函数类型而非指针类型。因此，我们显式地加上 * 以表明我们需要返回指针，而非函数本身。

# Exercise 6.54

编写函数的声明，令其接受两个 int 形参并返回类型也是 int ；然后声明一个 vector 对象，令其元素是指向该函数的指针。

解：

int func(int, int);

vector<decltype(func)*> v;

# Exercise 6.55

编写 4 个函数，分别对两个 int 值执行加、减、乘、除运算；在上一题创建的 vector 对象中保存指向这些函数的指针。

解：

int add(int a, int b) { return a + b; }

int subtract(int a, int b) { return a - b; }

int multiply(int a, int b) { return a * b; }

int divide(int a, int b) { return b != 0 ? a / b : 0; }

v.push_back(add);

v.push_back(subtract);

v.push_back(multiply);

v.push_back(divide);

# Exercise 6.56

调用上述 vector 对象中的每个元素并输出结果。

解：

std::vector<decltype(func) *> vec{ add, subtract, multiply, divide };

for (auto f : vec)

          std::cout << f(2, 2) << std::endl;

# Chapter Summary

🍓：）