C++ Primer (第五版）第六章习题部分答案

2024-04-19 08:03:31

在我自学C++过程中，我选择了C++Primer这本书，并对部分代码习题进行了求解以及运行结果。接下来几个月我将为大家定时按章节更新习题答案与运行结果，运行环境（Visual Studio Code，windows 11）：

C++ Primer (第五版）习题答案总目录：

https://blog.****.net/weixin_48467622/article/details/136418131?spm=1001.2014.3001.5501

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)函数声明返回类型为int，实际返回类型为string：

string f() {  // return should be string, not int
          string s;
          // ...
          return s;
}

(b)需要加上函数类型声明：

void f2(int i) { /* ... */ }  // function needs return type

(c)形参的名字不能相同：

int calc(int v1, int v2) { /* ... */ }  // parameter list cannot use same name twice

(d)需要有大括号（函数块）：

double square (double x) { return x * x; }  // function body needs braces

6.3 编写你自己的fact函数，上机检查是否正确。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

int fact(int val)
{
	int ret = 1;
	while (val > 1)
	{
		ret *= val;
		val--;
	}
	return ret;
}
int main()
{
	int j = fact(5);
	cout << j << endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

int fact(int val)
{
	int ret = 1;
	while (val > 1)
	{
		ret *= val;
		val--;
	}
	return ret;
}
int main()
{
	int n;
	cin >> n;
	int j = fact(n);
	cout << j << endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

int abs(int val)
{
	int ret;
	if (val >= 0)
	{
		ret = val;
	}
	else
	{
		ret = -val;
	}
	return ret;
}
int main()
{
	int n;
	cin >> n;
	int j = abs(n);
	cout << j << endl;
	return 0;
}

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

形参：定义在函数形参列表里面；

局部变量：定义在代码块里面；

局部静态变量：在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止时才被销毁。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

size_t cadd(int val)//val是一个形参和局部变量
{
	static size_t ctr = 0;//ctr是一个局部静态变量
	ctr += val;
	return ctr;
}
int main()
{
	for (int i = 0; i < 10; i++)//i是一个局部变量
	{
		cout << cadd(i) << endl;
	}
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

size_t count_calls()
{
	static size_t ctr = 0;
	return ctr++;
}
int main()
{
	for (int i = 0; i < 10; i++)//i是一个局部变量
	{
		cout << count_calls() << endl;
	}
	return 0;
}

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

#pragma once
#ifndef CHAPTER6_H
#define CHAPTER6_H

int fact(int val);
int abs(int val);

#endif

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

Chapter.h

#pragma once
#ifndef CHAPTER6_H
#define CHAPTER6_H

int fact(int val);
int abs1(int val);

#endif

fact.cpp

#include "Chapter.h"

int fact(int val)
{
	int ret = 1;
	while (val > 1)
	{
		ret *= val;
		val--;
	}
	return ret;
}

int abs1(int val)
{
	int ret;
	if (val >= 0)
	{
		ret = val;
	}
	else
	{
		ret = -val;
	}
	return ret;
}

factMain.cpp

#include "Chapter.h"
#include<iostream>
using namespace std;

int main()
{
	cout << fact(6) << endl;
	cout << abs1(-6) << endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void swap(int* a, int* b)
{
	int t = *a;
	*a = *b;
	*b = t;
}
int main()
{
	int x = 6, y = 66;
	cout << x << " " << y << endl;
	swap(&x, &y);
	cout << x << " " << y << endl;
	return 0;
}

6.11 编写并验证你自己的reset函数，使其作用于引用类型的参数。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void reset(int& i)
{
	i = 66;
}
int main()
{
	int val = 60;
	cout << val << endl;
	reset(val);
	cout << val << endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void swap(int& a, int& b)
{
	int t = a;
	a = b;
	b = t;
}
int main()
{
	int x = 6, y = 66;
	cout << x << " " << y << endl;
	swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

引用更易于使用，不用考虑传递的是指针，避免语法错误；
使用引用避免拷贝。

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

void f(T)
将实参的值拷贝后赋给形参，不能通过改变形参的值来改变实参；
void f(&T)
使用引用将形参绑定到实参上，可以通过改变形参来改变实参。

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

应该是引用：

void reset(int &i)
{
        i = 0;
}

不能是引用：

void print(std::vector<int>::iterator begin, std::vector<int>::iterator end)
{
        for (std::vector<int>::iterator iter = begin; iter != end; ++iter)
                std::cout << *iter << std::endl;
}

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

s不需要改变实参，occurs需要改变实参；s可能会很大，occurs需要改变实参，c没有上述两个需求；如果s是普通的引用可能改变实参；occurs是常量引用则不能改变实参，++occurs会报错。

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

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

该函数无需改变实参，故将其设置为const比较好，这样也可以传入const类型的字符串，或字符串字面值。

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

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

bool isupper(const string& s)
{
	for (auto c : s)
	{
		if (isupper(c))
		{
			return true;
		}
	}
	return false;
}

void toupper(string& s)
{
	for (auto& c : s)
	{
		c = tolower(c);
	}
}
int main()
{
	string s1 = "Hello The USA!";
	cout << isupper(s1) << endl;
	cout << s1 << endl;
	toupper(s1);
	cout << s1 << endl;
	return 0;
}

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 i,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）不合法，只能一个形参；
（b）合法；
（c）合法；
（d）合法。

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

无需改变实参的时候应该用常量引用；可能会改变常亮实参，从而导致出错。

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void comp(int a, int* b)
{
	cout << ((a > *b) ? a : *b )<< endl;
}
int main()
{
	int x = 1, i = 3;
	int* y = &i;
	comp(x, y);
	return 0;
}

int型

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void swap(int* &a, int* &b)
{
	int* t;
	t = a;
	a = b;
	b = t;
}
int main()
{
	int a = 6, b = 66;
	int* i = &a, * j = &b;
	cout << *i << " " << *j << endl;
	swap(i, j);
	cout << *i << " " << *j << endl;
	return 0;
}

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

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

void print1(const int a, const int *b)
{
	cout << "print1:" << endl;
	cout << "i:" << a << endl;
	cout << "j:" << endl;
	for(int i=0;i<2;i++)
	{
		cout << *b++ << " ";
	}
	cout << endl;
}
void print2(const int a, const int b[])
{
	cout << "print2:" << endl;
	cout << "i:" << a << endl;
	cout << "j:" << endl;
	for (int i = 0; i < 2; i++)
	{
		cout << *b++ << " ";
	}
	cout << endl;
}
void print3(const int a, const int b[2])
{
	cout << "print3:" << endl;
	cout << "i:" << a << endl;
	cout << "j:" << endl;
	for (int i = 0; i < 2; i++)
	{
		cout << *b++ << " ";
	}
	cout << endl;
}
int main()
{
	int i = 0, j[2] = { 0,1 };
	print1(i, j);
	print2(i, j);
	print3(i, j);
	return 0;
}

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

void print(const int ia[10])
{
	for (size_t i = 0; i != 10; ++i)
		cout << ia[i] << endl;
}

该函数传递的不是数组是const int*，如果实参不是含10个元素的int数组，可能导致for循环数组越界。修改为：

void print(const int （&ia）[10])
{
	for (size_t i = 0; i != 10; ++i)
		cout << ia[i] << endl;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

int main(int argc,char const *argv[])
{
	cout << "argc:" << argc << endl;
	string a1 = argv[1], a2 = argv[2], a3 = argv[3];
	cout << a1 + a2 + a3<< endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>

#include <iterator>
using namespace std;

int main(int argc,char const *argv[])
{
	cout << "argc:" << argc << endl;
	for (int i = 0; i < argc; i++)
	{
		cout << argv[i] << " ";
	}
	cout << endl;
	return 0;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
int count_int(initializer_list<int> i1)
{
	int cnti = 0;
	for (auto i : i1)
	{
		cnti += i;
	}
	return cnti;
}
int main()
{
	cout << count_int({ 1,2,3,4,5,6,7 }) << endl;
	return 0;
}

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

如果拷贝代价小，则无需设置成引用类型；如果拷贝代价大，可以设置成引用类型。

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

错误#1：error: return-statement with no value, in function returning ‘bool’ [-fpermissive]
错误#2：检查不出，返回true

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

返回的引用时局部对象的引用，返回的常量引用是局部常量对象的引用时。

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
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;
    for (auto j : ia)
        cout << j << " ";
    cout << endl;
}

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void CoutVector(vector<int>::const_iterator iter_begin, vector<int>::const_iterator iter_end)
{
    if (iter_begin != iter_end)
    {
        cout << *iter_begin << " ";
        CoutVector(++iter_begin, iter_end);
    }
    else
    {
        cout << endl;
        return;
    }
}
int main()
{
    vector<int> v{ 1,2,3,4,5,6,7,8,9 };
    CoutVector(v.begin(), v.end());
    return 0;
}

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

if (val != 0)

如果实参为大于等于0，函数将会多乘以一个1，比如factorial(5)，等价于5 * 4 * 3 * 2 * 1 * 1;
如果实参小于0，函数将会不断地调用它自身直到程序栈空间耗尽为止。

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

val--会返回未修改的val内容，使程序陷入无限循环；val--会修改val的内容，使程序运行结果不符合预期。

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

string (&func(string (&arr)[10]))[10];

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

using arrt = string[10];
arrt &func(arrt &arrs);
auto func(atring a)->string(&)[10];
string a[10];
decltype(a) &func(string qq);

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

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

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）非法，重复声明可以，重复定义不行，第二个非引用非指针；

（b）非法，仅返回值不同；
（c）合法，重载关系。

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）合法，但与初衷不符，char '*'转换成整形了。

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;

string make_plural(size_t ctr, const string& word, const string& ending = "s")
{
    return (ctr > 1) ? word + ending : word;
}
int main()
{
    cout << make_plural(2, "success", "es") << endl;
    cout << make_plural(2, "failture") << endl;
    return 0;
}

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函数改写成内联函数。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;

inline bool inShorter(const string& s1, const string& s2)
{
    return s1.size() < s2.size();
}
int main()
{
    string s1("aaadd"), s2("dadaddf");
    cout << inShorter(s1, s2);
    return 0;
}

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

6.38和6.42应该是内联函数；6.4不应该是，规模不小，调用不频繁。

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

不能，因为std::string::size()；不是一个constexpr函数，s1.size() == s2.size()；不是一个常量表达式。

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void CoutVector(vector<int>::const_iterator iter_begin, vector<int>::const_iterator iter_end)
{
    #ifndef NDEBUG
        cerr << iter_end - iter_begin << __func__ << " " << __FILE__ << " "
        << __LINE__ << " " << __TIME__ << " " << __DATE__ << endl;
    #endif
    if (iter_begin != iter_end)
    {
        cout << *iter_begin << " ";
        CoutVector(++iter_begin, iter_end);
    }
    else
    {
        cout << endl;
        return;
    }
}
int main()
{
    vector<int> v{ 1,2,3,4,5,6,7,8,9 };
    CoutVector(v.begin(), v.end());
    return 0;
}

打开调试器：

关闭调试器：

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

候选函数具备两个特征：一是与被调用的函数同名，二是其声明在调用点可见。
可行函数是从候选函数中选出的，有两个特征：一是其形参数量与本次调用提供的实参数量相等，二是每个实参的类型与对应的形参类型相同，或者能转换成形参的类型。

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void f()
{
    cout << "Function is f()" << endl;
}

void f(int)
{
    cout << "Function is f(int)" << endl;
}

void f(int , int)
{
    cout << "Function is f(int ,int)" << endl;
}

void f(double,double = 3.14)
{
    cout << "Function is f(double,double = 3.14)" << endl;
}
int main()
{
    f();
    f(1);
    f(1, 2);
    f(1.1);
    return 0;
}

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

vector<int (*)(int, int)> vf;

//others:
int func(int a, int b);

using pFunc1 = decltype(func) *;
typedef decltype(func) *pFunc2;
using pFunc3 = int (*)(int a, int b);
using pFunc4 = int(int a, int b);
typedef int(*pFunc5)(int a, int b);
using pFunc6 = decltype(func);

vector<pFunc1> vec1;
vector<pFunc2> vec2;
vector<pFunc3> vec3;
vector<pFunc4*> vec4;
vector<pFunc5> vec5;
vector<pFunc6*> vec6;

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

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

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
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; 
}

int main()
{
    vector<int(*)(int, int)> vf;
    vf = { add,subtract,multiply,divide };
    for (auto& c : vf)
    {
        cout << c(6, 3) << endl;
    }
    return 0;
}

码农公寓