标签：const 函数形参 int 练习引用第六章

第六章函数

函数基础

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

练习6.1

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

解：

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

练习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; }

练习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"。

练习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;
}

练习6.5

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

#include <iostream>

int abs(int i)
{
   return i > 0 ? i : -i;
}

int main()
{
   std::cout << abs(-5) << std::endl;
   return 0;
}

局部对象

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

练习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;
}

练习6.7

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

解：

int generate()
{
    static int ctr = 0;
    return ctr++;
}

函数声明

函数声明：函数的声明和定义唯一的区别是声明无需函数体，用一个分号替代。函数声明主要用于描述函数的接口，也称函数原型。

练习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;
}

在头文件中进行函数声明：建议变量在头文件中声明；在源文件中定义。
分离编译： CC a.cc b.cc直接编译生成可执行文件；CC -c a.cc b.cc编译生成对象代码a.o b.o； CC a.o b.o编译生成可执行文件。

练习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

参数传递

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

传值参数

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

练习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;
}

传引用参数

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

练习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;
}

练习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;
}

很明显引用更好用。

练习6.13

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

解：

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

练习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;
}

练习6.15

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

解：

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

const形参和实参

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

练习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(); }

练习6.17

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

解：

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

练习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);

练习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) 合法。

练习6.20

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

解：

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

数组形参

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

练习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 *类型。

练习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;
}

练习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;
}

练习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;
}

main处理命令行选项

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

练习6.25

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

练习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;
}

可变形参

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

操作	解释
`initializer_list<T> lst;`	默认初始化；`T`类型元素的空列表
`initializer_list<T> lst{a,b,c...};`	`lst`的元素数量和初始值一样多；`lst`的元素是对应初始值的副本；列表中的元素是`const`。
`lst2(lst)`	拷贝或赋值一个`initializer_list`对象不会拷贝列表中的元素；拷贝后，原始列表和副本共享元素。
`lst2 = lst`	同上
`lst.size()`	列表中的元素数量
`lst.begin()`	返回指向`lst`中首元素的指针
`lst.end()`	返回指向`lst`中微元素下一位置的指针

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标准功能。

练习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;
}

练习6.28

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

解：

elem是const string &类型。

练习6.29

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

解：

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

返回类型和return语句

无返回值函数

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

有返回值函数

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

练习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]

练习6.31

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

解：

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

练习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函数根据索引取得数组中的元素的引用。

练习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;
}

练习6.34

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

if (val != 0)

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

练习6.35

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

解：

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

返回数组指针

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）

练习6.36

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

解：

string (&fun())[10];

练习6.37

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

解：

typedef string str_arr[10];
str_arr& fun();

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

string s[10];
decltype(s)& fun();

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

练习6.38

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

解：

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

函数重载

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

练习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) 合法。

特殊用途语言特性

默认实参

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

练习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) 错误。因为一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。

练习6.41

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

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

解：

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

练习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;
}

内联（inline）函数

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

constexpr函数

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

练习6.43

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

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

解：

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

练习6.44

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

解：

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

练习6.45

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

解：

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

练习6.46

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

解：

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

调试帮助

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

开关调试状态：

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

void print(){
    #ifndef NDEBUG
        cerr << __func__ << "..." << endl;
    #endif
}

练习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;
}

练习6.48

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

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

解：

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

assert(s == sought);

函数匹配

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

练习6.49

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

解：

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

练习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);是最佳匹配。

练习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;
}

练习6.52

已知有如下声明：

void manip(int ,int);
double dobj;

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

(a) manip('a', 'z');
(b) manip(55.4, dobj);

解：

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

练习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);

解：

函数指针

函数指针：是指向函数的指针。
bool (*pf)(const string &, const string &); 注：两端的括号不可少。
函数指针形参：
- 形参中使用函数定义或者函数指针定义效果一样。
- 使用类型别名或者decltype。
返回指向函数的指针：1.类型别名；2.尾置返回类型。

练习6.54

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

解：

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

练习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);

练习6.56

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

解：

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

标签：const,函数,形参,int,练习,引用,第六章
From： https://www.cnblogs.com/Epiephany/p/17135349.html

第六章 函数

第六章 函数

函数基础

练习6.1

练习6.2

练习6.3

练习6.4

练习6.5

局部对象

练习6.6

练习6.7

函数声明

练习6.8

练习6.9 : fact.cc | factMain.cc

参数传递

传值参数

练习6.10

传引用参数

练习6.11

练习6.12

练习6.13

练习6.14

练习6.15

const形参和实参

练习6.16

练习6.17

练习6.18

练习6.19

练习6.20

数组形参

练习6.21

练习6.22

练习6.23

练习6.24

main处理命令行选项

练习6.25

练习6.26

可变形参

练习6.27

练习6.28

练习6.29

返回类型和return语句

无返回值函数

有返回值函数

练习6.30

练习6.31

练习6.32

练习6.33

练习6.34

练习6.35

返回数组指针

练习6.36

练习6.37

练习6.38

函数重载

练习6.39

特殊用途语言特性

默认实参

练习6.40

练习6.41

练习6.42

内联（inline）函数

constexpr函数

练习6.43

练习6.44

练习6.45

练习6.46

调试帮助

练习6.47

练习6.48

函数匹配

练习6.49

练习6.50

练习6.51

练习6.52

练习6.53

函数指针

练习6.54

练习6.55

练习6.56

第六章函数

第六章函数