第六章 函数
练习6.1
实参和形参的区别的什么?
解:
实参是函数调用的实际值,是形参的初始值。
练习6.2
请指出下列函数哪个有错误,为什么?应该如何修改这些错误呢?
1 2 3 4 5 6 7 8 (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 ;
解:
应该改为下面这样:
1 2 3 4 5 6 7 8 (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; }
练习6.3
编写你自己的fact
函数,上机检查是否正确。注:阶乘。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #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"
。
练习6.4
编写一个与用户交互的函数,要求用户输入一个数字,计算生成该数字的阶乘。在main函数中调用该函数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #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 ; }
练习6.5
编写一个函数输出其实参的绝对值。
1 2 3 4 5 6 7 8 9 10 11 12 #include <iostream> int abs (int i) { return i > 0 ? i : -i; } int main () { std::cout << abs (-5 ) << std::endl; return 0 ; }
练习6.6
说明形参、局部变量以及局部静态变量的区别。编写一个函数,同时达到这三种形式。
解:
形参定义在函数形参列表里面;局部变量定义在代码块里面;局部静态变量在程序的执行路径第一次经过对象定义语句时初始化,并且直到程序终止时才被销毁。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int count_add (int n) { static int ctr = 0 ; ctr += n; return ctr; } int main () { for (int i = 0 ; i != 10 ; ++i) cout << count_add (i) << endl; return 0 ; }
练习6.7
编写一个函数,当它第一次被调用时返回0,以后每次被调用返回值加1。
解:
1 2 3 4 5 int generate () { static int ctr = 0 ; return ctr++; }
练习6.8
编写一个名为Chapter6.h 的头文件,令其包含6.1节练习中的函数声明。
解:
1 2 3 4 5 6 7 8 9 10 int fact (int val) ;int func () ;template <typename T> T abs (T i) { return i >= 0 ? i : -i; }
编写你自己的fact.cc 和factMain.cc ,这两个文件都应该包含上一小节的练习中编写的 Chapter6.h 头文件。通过这些文件,理解你的编译器是如何支持分离式编译的。
解:
fact.cc :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #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 :
1 2 3 4 5 6 7 8 9 #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
练习6.10
编写一个函数,使用指针形参交换两个整数的值。在代码中调用该函数并输出交换后的结果,以此验证函数的正确性。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #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 ; }
练习6.11
编写并验证你自己的reset函数,使其作用于引用类型的参数。注:reset即置0。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> void reset (int &i) { i = 0 ; } int main () { int i = 42 ; reset (i); std::cout << i << std::endl; return 0 ; }
练习6.12
改写6.2.1节练习中的程序,使其引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢?为什么?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #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 ; }
很明显引用更好用。
练习6.13
假设T
是某种类型的名字,说明以下两个函数声明的区别:一个是void f(T)
, 另一个是void f(&T)
。
解:
void f(T)
的参数通过值传递,在函数中T
是实参的副本,改变T
不会影响到原来的实参。void f(&T)
的参数通过引用传递,在函数中的T
是实参的引用,T
的改变也就是实参的改变。
练习6.14
举一个形参应该是引用类型的例子,再举一个形参不能是引用类型的例子。
解:
例如交换两个整数的函数,形参应该是引用
1 2 3 4 5 6 void swap (int & lhs, int & rhs) { int temp = lhs; lhs = rhs; rhs = temp; }
当实参的值是右值时,形参不能为引用类型
1 2 3 4 5 6 7 8 9 10 int add (int a, int b) { return a + b; } int main () { int i = add (1 ,2 ); return 0 ; }
练习6.15
说明find_char
函数中的三个形参为什么是现在的类型,特别说明为什么s
是常量引用而occurs
是普通引用?为什么s
和occurs
是引用类型而c
不是?如果令s
是普通引用会发生什么情况?如果令occurs
是常量引用会发生什么情况?
解:
因为字符串可能很长,因此使用引用避免拷贝;
而在函数中我们不希望改变s
的内容,所以令s
为常量。
occurs
是要传到函数外部的变量,所以使用引用,occurs
的值会改变,所以是普通引用。
因为我们只需要c
的值,这个实参可能是右值(右值实参无法用于引用形参),所以c
不能用引用类型。
如果s
是普通引用,也可能会意外改变原来字符串的内容。
occurs
如果是常量引用,那么意味着不能改变它的值,那也就失去意义了。
练习6.16
下面的这个函数虽然合法,但是不算特别有用。指出它的局限性并设法改善。
1 bool is_empty (string& s) { return s.empty (); }
解:
局限性在于常量字符串和字符串字面值无法作为该函数的实参,如果下面这样调用是非法的:
1 2 3 const string str;bool flag = is_empty (str); 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 2 (a) bool compare (matrix &m1, matrix &m2) ; (b) vector<int >::iterator change_val (int , vector<int >::iterator) ;
练习6.19
假定有如下声明,判断哪个调用合法、哪个调用不合法。对于不合法的函数调用,说明原因。
1 2 3 4 5 6 7 8 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) 合法。
© 合法。
(d) 合法。
练习6.20
引用形参什么时候应该是常量引用?如果形参应该是常量引用,而我们将其设为了普通引用,会发生什么情况?
解:
应该尽量将引用形参设为常量引用,除非有明确的目的是为了改变这个引用变量。如果形参应该是常量引用,而我们将其设为了普通引用,那么常量实参将无法作用于普通引用形参。
练习6.21
编写一个函数,令其接受两个参数:一个是int
型的数,另一个是int
指针。函数比较int
的值和指针所指的值,返回较大的那个。在该函数中指针的类型应该是什么?
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #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 *
类型。
练习6.22
编写一个函数,令其交换两个int
指针。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #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 ; }
练习6.23
参考本节介绍的几个print
函数,根据理解编写你自己的版本。依次调用每个函数使其输入下面定义的i
和j
:
1 int i = 0 , j[2 ] = { 0 , 1 };
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 #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 ; }
练习6.24
描述下面这个函数的行为。如果代码中存在问题,请指出并改正。
1 2 3 4 5 void print (const int ia[10 ]) { for (size_t i = 0 ; i != 10 ; ++i) cout << ia[i] << endl; }
解:
当数组作为实参的时候,会被自动转换为指向首元素的指针。因此函数形参接受的是一个指针。如果要让这个代码成功运行(不更改也可以运行),可以将形参改为数组的引用。
1 2 3 4 5 void print (const int (&ia)[10 ]) { for (size_t i = 0 ; i != 10 ; ++i) cout << ia[i] << endl; }
练习6.25
编写一个main
函数,令其接受两个实参。把实参的内容连接成一个string
对象并输出出来。
练习6.26
编写一个程序,使其接受本节所示的选项;输出传递给main
函数的实参内容。
解:
包括6.25
1 2 3 4 5 6 7 8 9 10 11 12 #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 ; }
练习6.27
编写一个函数,它的参数是initializer_list
类型的对象,函数的功能是计算列表中所有元素的和。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #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 ; }
练习6.28
在error_msg
函数的第二个版本中包含ErrCode
类型的参数,其中循环内的elem
是什么类型?
解:
elem
是const 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 2 3 4 5 6 7 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
函数根据索引取得数组中的元素的引用。
练习6.33
编写一个递归函数,输出vector
对象的内容。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #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 ; }
练习6.34
如果factorial
函数的停止条件如下所示,将发生什么?
解:如果val
为正数,从结果上来说没有区别(多乘了个1);
如果val
为负数,那么递归永远不会结束。
练习6.35
在调用factorial
函数时,为什么我们传入的值是val-1
而非val--
?
解:
如果传入的值是val--
,那么将会永远传入相同的值来调用该函数,递归将永远不会结束。
练习6.36
编写一个函数声明,使其返回数组的引用并且该数组包含10个string
对象。不用使用尾置返回类型、decltype
或者类型别名。
解:
练习6.37
为上一题的函数再写三个声明,一个使用类型别名,另一个使用尾置返回类型,最后一个使用decltype
关键字。你觉得哪种形式最好?为什么?
解:
1 2 3 4 5 6 7 typedef string str_arr[10 ];str_arr& fun () ;auto fun () ->string (&) [10] ;string s[10 ]; decltype (s)& fun ();
我觉得尾置返回类型最好,就一行代码。
练习6.38
修改arrPtr
函数,使其返回数组的引用。
解:
1 2 3 4 decltype (odd)& arrPtr (int i){ return (i % 2 ) ? odd : even; }
练习6.39
说明在下面的每组声明中第二条语句是何含义。如果有非法的声明,请指出来。
1 2 3 4 5 6 (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) 非法。对于重载的函数来说,它们应该只有形参的数量和形参的类型不同。返回值与重载无关。
© 合法。
练习6.40
下面的哪个声明是错误的?为什么?
1 2 (a) int ff (int a, int b = 0 , int c = 0 ) ; (b) char *init (int ht = 24 , int wd, char bckgrnd) ;
解:
(a) 正确。
(b) 错误。因为一旦某个形参被赋予了默认值,那么它之后的形参都必须要有默认值。
练习6.41
下面的哪个调用是非法的?为什么?哪个调用虽然合法但显然与程序员的初衷不符?为什么?
1 2 3 4 char *init (int ht, int wd = 80 , char bckgrnd = ' ' ) ;(a) init (); (b) init (24 ,10 ); (c) init (14 ,'*' );
解:
(a) 非法。第一个参数不是默认参数,最少需要一个实参。
(b) 合法。
© 合法,但与初衷不符。字符*
被解释成int
传入到了第二个参数。而初衷是要传给第三个参数。
练习6.42
给make_plural
函数的第二个形参赋予默认实参’s’, 利用新版本的函数输出单词success和failure的单数和复数形式。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #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 ; }
练习6.43
你会把下面的哪个声明和定义放在头文件中?哪个放在源文件中?为什么?
1 2 (a) inline bool eq (const BigInt&, const BigInt&) {...} (b) void putValues (int *arr, int size) ;
解:
全部都放进头文件。(a) 是内联函数,(b) 是声明。
练习6.44
将6.2.2节的isShorter
函数改写成内联函数。
解:
1 2 3 4 inline bool is_shorter (const string &lft, const string &rht) { return lft.size () < rht.size (); }
练习6.45
回顾在前面的练习中你编写的那些函数,它们应该是内联函数吗?如果是,将它们改写成内联函数;如果不是,说明原因。
解:
一般来说,内联机制用于优化规模小、流程直接、频繁调用的函数。
练习6.46
能把isShorter
函数定义成constexpr
函数吗?如果能,将它改写成constxpre
函数;如果不能,说明原因。
解:
不能。constexpr
函数的返回值类型及所有形参都得是字面值类型。
练习6.47
改写6.3.2节练习中使用递归输出vector
内容的程序,使其有条件地输出与执行过程有关的信息。例如,每次调用时输出vector
对象的大小。分别在打开和关闭调试器的情况下编译并执行这个程序。
解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 #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 ; }
练习6.48
说明下面这个循环的含义,它对assert的使用合理吗?
1 2 3 string s; while (cin >> s && s != sought) { } assert (cin);
解:
不合理。从这个程序的意图来看,应该用
练习6.49
什么是候选函数?什么是可行函数?
解:
候选函数:与被调用函数同名,并且其声明在调用点可见。可行函数:形参与实参的数量相等,并且每个实参类型与对应的形参类型相同或者能转换成形参的类型。
练习6.50
已知有第217页对函数f
的声明,对于下面的每一个调用列出可行函数。其中哪个函数是最佳匹配?如果调用不合法,是因为没有可匹配的函数还是因为调用具有二义性?
1 2 3 4 (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);
是可行函数。调用合法。
© 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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 #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 (42 ); f (42 , 0 ); f (2.56 , 3.14 ); return 0 ; }
练习6.52
已知有如下声明:
1 2 void manip (int ,int ) ;double dobj;
请指出下列调用中每个类型转换的等级。
1 2 (a) manip ('a' , 'z' ); (b) manip (55.4 , dobj);
解:
(a) 第3级。类型提升实现的匹配。
(b) 第4级。算术类型转换实现的匹配。
练习6.53
说明下列每组声明中的第二条语句会产生什么影响,并指出哪些不合法(如果有的话)。
1 2 3 4 5 6 (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 ) ;
解:
© 不合法。顶层const不影响传入函数的对象。
练习6.54
编写函数的声明,令其接受两个int
形参并返回类型也是int
;然后声明一个vector
对象,令其元素是指向该函数的指针。
解:
1 2 int func (int , int ) ;vector<decltype (func)*> v;
练习6.55
编写4个函数,分别对两个int
值执行加、减、乘、除运算;在上一题创建的vector
对象中保存指向这些函数的指针。
解:
1 2 3 4 5 6 7 8 9 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);
练习6.56
调用上述vector
对象中的每个元素并输出结果。
解:
1 2 3 std::vector<decltype (func) *> vec{ add, subtract, multiply, divide }; for (auto f : vec) std::cout << f (2 , 2 ) << std::endl;