第六章 函数

练习6.1

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

解:

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

练习6.2

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

  1. (a) int f() {
  2. string s;
  3. // ...
  4. return s;
  5. }
  6. (b) f2(int i) { /* ... */ }
  7. (c) int calc(int v1, int v1) { /* ... */ }
  8. (d) double square (double x) return x * x;

解:

应该改为下面这样:

  1. (a) string f() {
  2. string s;
  3. // ...
  4. return s;
  5. }
  6. (b) void f2(int i) { /* ... */ }
  7. (c) int calc(int v1, int v2) { /* ... */ return ; }
  8. (d) double square (double x) { return x * x; }

练习6.3

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

解:

  1. #include <iostream>
  2. int fact(int i)
  3. {
  4. if(i<0)
  5. {
  6. std::runtime_error err("Input cannot be a negative number");
  7. std::cout << err.what() << std::endl;
  8. }
  9. return i > 1 ? i * fact( i - 1 ) : 1;
  10. }
  11. int main()
  12. {
  13. std::cout << std::boolalpha << (120 == fact(5)) << std::endl;
  14. return 0;
  15. }

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

练习6.4

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

  1. #include <iostream>
  2. #include <string>
  3. int fact(int i)
  4. {
  5. return i > 1 ? i * fact(i - 1) : 1;
  6. }
  7. void interactive_fact()
  8. {
  9. std::string const prompt = "Enter a number within [1, 13) :\n";
  10. std::string const out_of_range = "Out of range, please try again.\n";
  11. for (int i; std::cout << prompt, std::cin >> i; )
  12. {
  13. if (i < 1 || i > 12)
  14. {
  15. std::cout << out_of_range;
  16. continue;
  17. }
  18. std::cout << fact(i) << std::endl;
  19. }
  20. }
  21. int main()
  22. {
  23. interactive_fact();
  24. return 0;
  25. }

练习6.5

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

  1. #include <iostream>
  2. int abs(int i)
  3. {
  4. return i > 0 ? i : -i;
  5. }
  6. int main()
  7. {
  8. std::cout << abs(-5) << std::endl;
  9. return 0;
  10. }

练习6.6

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

解:

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

  1. // 例子
  2. int count_add(int n) // n是形参
  3. {
  4. static int ctr = 0; // ctr 是局部静态变量
  5. ctr += n;
  6. return ctr;
  7. }
  8. int main()
  9. {
  10. for (int i = 0; i != 10; ++i) // i 是局部变量
  11. cout << count_add(i) << endl;
  12. return 0;
  13. }

练习6.7

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

解:

  1. int generate()
  2. {
  3. static int ctr = 0;
  4. return ctr++;
  5. }

练习6.8

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

解:

  1. int fact(int val);
  2. int func();
  3. template <typename T> //参考:https://blog.csdn.net/fightingforcv/article/details/51472586
  4. T abs(T i)
  5. {
  6. return i >= 0 ? i : -i;
  7. }

练习6.9 : fact.cc | factMain.cc

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

解:

fact.cc:

  1. #include "Chapter6.h"
  2. #include <iostream>
  3. int fact(int val)
  4. {
  5. if (val == 0 || val == 1) return 1;
  6. else return val * fact(val-1);
  7. }
  8. int func()
  9. {
  10. int n, ret = 1;
  11. std::cout << "input a number: ";
  12. std::cin >> n;
  13. while (n > 1) ret *= n--;
  14. return ret;
  15. }

factMain.cc:

  1. #include "Chapter6.h"
  2. #include <iostream>
  3. int main()
  4. {
  5. std::cout << "5! is " << fact(5) << std::endl;
  6. std::cout << func() << std::endl;
  7. std::cout << abs(-9.78) << std::endl;
  8. }

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

练习6.10

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

解:

  1. #include <iostream>
  2. #include <string>
  3. void swap(int* lhs, int* rhs)
  4. {
  5. int tmp;
  6. tmp = *lhs;
  7. *lhs = *rhs;
  8. *rhs = tmp;
  9. }
  10. int main()
  11. {
  12. for (int lft, rht; std::cout << "Please Enter:\n", std::cin >> lft >> rht;)
  13. {
  14. swap(&lft, &rht);
  15. std::cout << lft << " " << rht << std::endl;
  16. }
  17. return 0;
  18. }

练习6.11

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

解:

  1. #include <iostream>
  2. void reset(int &i)
  3. {
  4. i = 0;
  5. }
  6. int main()
  7. {
  8. int i = 42;
  9. reset(i);
  10. std::cout << i << std::endl;
  11. return 0;
  12. }

练习6.12

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

  1. #include <iostream>
  2. #include <string>
  3. void swap(int& lhs, int& rhs)
  4. {
  5. int temp = lhs;
  6. lhs = rhs;
  7. rhs = temp;
  8. }
  9. int main()
  10. {
  11. for (int left, right; std::cout << "Please Enter:\n", std::cin >> left >> right; )
  12. {
  13. swap(left, right);
  14. std::cout << left << " " << right << std::endl;
  15. }
  16. return 0;
  17. }

很明显引用更好用。

练习6.13

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

解:

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

练习6.14

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

解:

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

  1. void swap(int& lhs, int& rhs)
  2. {
  3. int temp = lhs;
  4. lhs = rhs;
  5. rhs = temp;
  6. }

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

  1. int add(int a, int b)
  2. {
  3. return a + b;
  4. }
  5. int main()
  6. {
  7. int i = add(1,2);
  8. return 0;
  9. }

练习6.15

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

解:

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

练习6.16

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

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

解:

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

  1. const string str;
  2. bool flag = is_empty(str); //非法
  3. bool flag = is_empty("hello"); //非法

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

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

练习6.17

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

解:

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

练习6.18

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

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

解:

  1. (a) bool compare(matrix &m1, matrix &m2);
  2. (b) vector<int>::iterator change_val(int, vector<int>::iterator);

练习6.19

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

  1. double calc(double);
  2. int count(const string &, char);
  3. int sum(vector<int>::iterator, vector<int>::iterator, int);
  4. vector<int> vec(10);
  5. (a) calc(23.4, 55.1);
  6. (b) count("abcda",'a');
  7. (c) calc(66);
  8. (d) sum(vec.begin(), vec.end(), 3.8);

解:

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

练习6.20

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

解:

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

练习6.21

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

解:

  1. #include <iostream>
  2. using std::cout;
  3. int larger_one(const int i, const int *const p)
  4. {
  5. return (i > *p) ? i : *p;
  6. }
  7. int main()
  8. {
  9. int i = 6;
  10. cout << larger_one(7, &i);
  11. return 0;
  12. }

应该是const int *类型。

练习6.22

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

解:

  1. #include <iostream>
  2. #include <string>
  3. void swap(int*& lft, int*& rht)
  4. {
  5. auto tmp = lft;
  6. lft = rht;
  7. rht = tmp;
  8. }
  9. int main()
  10. {
  11. int i = 42, j = 99;
  12. auto lft = &i;
  13. auto rht = &j;
  14. swap(lft, rht);
  15. std::cout << *lft << " " << *rht << std::endl;
  16. return 0;
  17. }

练习6.23

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

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

解:

  1. #include <iostream>
  2. using std::cout; using std::endl; using std::begin; using std::end;
  3. void print(const int *pi)
  4. {
  5. if(pi)
  6. cout << *pi << endl;
  7. }
  8. void print(const char *p)
  9. {
  10. if (p)
  11. while (*p) cout << *p++;
  12. cout << endl;
  13. }
  14. void print(const int *beg, const int *end)
  15. {
  16. while (beg != end)
  17. cout << *beg++ << endl;
  18. }
  19. void print(const int ia[], size_t size)
  20. {
  21. for (size_t i = 0; i != size; ++i) {
  22. cout << ia[i] << endl;
  23. }
  24. }
  25. void print(int (&arr)[2])
  26. {
  27. for (auto i : arr)
  28. cout << i << endl;
  29. }
  30. int main()
  31. {
  32. int i = 0, j[2] = { 0, 1 };
  33. char ch[5] = "pezy";
  34. print(ch);
  35. print(begin(j), end(j));
  36. print(&i);
  37. print(j, end(j)-begin(j));
  38. print(j);
  39. return 0;
  40. }

练习6.24

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

  1. void print(const int ia[10])
  2. {
  3. for (size_t i = 0; i != 10; ++i)
  4. cout << ia[i] << endl;
  5. }

解:

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

  1. void print(const int (&ia)[10])
  2. {
  3. for (size_t i = 0; i != 10; ++i)
  4. cout << ia[i] << endl;
  5. }

练习6.25

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

练习6.26

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

解:

包括6.25

  1. #include <iostream>
  2. #include <string>
  3. int main(int argc, char **argv)
  4. {
  5. std::string str;
  6. for (int i = 1; i != argc; ++i)
  7. str += std::string(argv[i]) + " ";
  8. std::cout << str << std::endl;
  9. return 0;
  10. }

练习6.27

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

解:

  1. #include <iostream>
  2. #include <initializer_list>
  3. int sum(std::initializer_list<int> const& il)
  4. {
  5. int sum = 0;
  6. for (auto i : il) sum += i;
  7. return sum;
  8. }
  9. int main(void)
  10. {
  11. auto il = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  12. std::cout << sum(il) << std::endl;
  13. return 0;
  14. }

练习6.28

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

解:

elemconst string &类型。

练习6.29

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

解:

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

练习6.30

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

解:

编译器信息:

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

编译错误信息:

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

练习6.31

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

解:

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

练习6.32

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

  1. int &get(int *array, int index) { return array[index]; }
  2. int main()
  3. {
  4. int ia[10];
  5. for (int i = 0; i != 10; ++i)
  6. get(ia, i) = i;
  7. }

解:

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

练习6.33

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

解:

  1. #include <iostream>
  2. #include <vector>
  3. using std::vector; using std::cout;
  4. using Iter = vector<int>::const_iterator;
  5. void print(Iter first, Iter last)
  6. {
  7. if (first != last)
  8. {
  9. cout << *first << " ";
  10. print(++first, last);
  11. }
  12. }
  13. int main()
  14. {
  15. vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  16. print(vec.cbegin(), vec.cend());
  17. return 0;
  18. }

练习6.34

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

  1. if (val != 0)

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

练习6.35

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

解:

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

练习6.36

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

解:

  1. string (&fun())[10];

练习6.37

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

解:

  1. typedef string str_arr[10];
  2. str_arr& fun();
  3. auto fun()->string(&)[10];
  4. string s[10];
  5. decltype(s)& fun();

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

练习6.38

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

解:

  1. decltype(odd)& arrPtr(int i)
  2. {
  3. return (i % 2) ? odd : even;
  4. }

练习6.39

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

  1. (a) int calc(int, int);
  2. int calc(const int, const int);
  3. (b) int get();
  4. double get();
  5. (c) int *reset(int *);
  6. double *reset(double *);

解:

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

练习6.40

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

  1. (a) int ff(int a, int b = 0, int c = 0);
  2. (b) char *init(int ht = 24, int wd, char bckgrnd);

解:

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

练习6.41

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

  1. char *init(int ht, int wd = 80, char bckgrnd = ' ');
  2. (a) init();
  3. (b) init(24,10);
  4. (c) init(14,'*');

解:

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

练习6.42

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

解:

  1. #include <iostream>
  2. #include <string>
  3. using std::string;
  4. using std::cout;
  5. using std::endl;
  6. string make_plural(size_t ctr, const string& word, const string& ending = "s")
  7. {
  8. return (ctr > 1) ? word + ending : word;
  9. }
  10. int main()
  11. {
  12. cout << "single: " << make_plural(1, "success", "es") << " "
  13. << make_plural(1, "failure") << endl;
  14. cout << "plural : " << make_plural(2, "success", "es") << " "
  15. << make_plural(2, "failure") << endl;
  16. return 0;
  17. }

练习6.43

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

  1. (a) inline bool eq(const BigInt&, const BigInt&) {...}
  2. (b) void putValues(int *arr, int size);

解:

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

练习6.44

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

解:

  1. inline bool is_shorter(const string &lft, const string &rht)
  2. {
  3. return lft.size() < rht.size();
  4. }

练习6.45

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

解:

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

练习6.46

能把isShorter函数定义成constexpr函数吗?
如果能,将它改写成constxpre函数;如果不能,说明原因。

解:

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

练习6.47

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

解:

  1. #include <iostream>
  2. #include <vector>
  3. using std::vector; using std::cout; using std::endl;
  4. void printVec(vector<int> &vec)
  5. {
  6. #ifndef NDEBUG
  7. cout << "vector size: " << vec.size() << endl;
  8. #endif
  9. if (!vec.empty())
  10. {
  11. auto tmp = vec.back();
  12. vec.pop_back();
  13. printVec(vec);
  14. cout << tmp << " ";
  15. }
  16. }
  17. int main()
  18. {
  19. vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  20. printVec(vec);
  21. cout << endl;
  22. return 0;
  23. }

练习6.48

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

  1. string s;
  2. while (cin >> s && s != sought) { } //空函数体
  3. assert(cin);

解:

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

  1. assert(s == sought);

练习6.49

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

解:

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

练习6.50

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

  1. (a) f(2.56, 42)
  2. (b) f(42)
  3. (c) f(42, 0)
  4. (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);是最佳匹配。

练习6.51

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

解:

  1. #include <iostream>
  2. using std::cout; using std::endl;
  3. void f()
  4. {
  5. cout << "f()" << endl;
  6. }
  7. void f(int)
  8. {
  9. cout << "f(int)" << endl;
  10. }
  11. void f(int, int)
  12. {
  13. cout << "f(int, int)" << endl;
  14. }
  15. void f(double, double)
  16. {
  17. cout << "f(double, double)" << endl;
  18. }
  19. int main()
  20. {
  21. //f(2.56, 42); // error: 'f' is ambiguous.
  22. f(42);
  23. f(42, 0);
  24. f(2.56, 3.14);
  25. return 0;
  26. }

练习6.52

已知有如下声明:

  1. void manip(int ,int);
  2. double dobj;

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

  1. (a) manip('a', 'z');
  2. (b) manip(55.4, dobj);

解:

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

练习6.53

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

  1. (a) int calc(int&, int&);
  2. int calc(const int&, const int&);
  3. (b) int calc(char*, char*);
  4. int calc(const char*, const char*);
  5. (c) int calc(char*, char*);
  6. int calc(char* const, char* const);

解:

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

练习6.54

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

解:

  1. int func(int, int);
  2. vector<decltype(func)*> v;

练习6.55

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

解:

  1. int add(int a, int b) { return a + b; }
  2. int subtract(int a, int b) { return a - b; }
  3. int multiply(int a, int b) { return a * b; }
  4. int divide(int a, int b) { return b != 0 ? a / b : 0; }
  5. v.push_back(add);
  6. v.push_back(subtract);
  7. v.push_back(multiply);
  8. v.push_back(divide);

练习6.56

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

解:

  1. std::vector<decltype(func) *> vec{ add, subtract, multiply, divide };
  2. for (auto f : vec)
  3. std::cout << f(2, 2) << std::endl;