《C++primer》第六章课后习题

练习6.1

答：形参是指函数头内的参数，实参是传递给函数的参数

练习6.2

答：a，return与返回类型不一致，可以将int改为string；b，没有返回类型；c，少左花括号；d，少花括号

练习6.3

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

练习6.4

#include <iostream>
using namespace std;
int fact(int n)
{
	int val = 1;
	while(n>1)
	{
		val*=n;
		n--;
	}
	return val;
}
int main()
{
	int n;
	cout<<"请输入一个整数"<<endl;
	cin>>n;
	cout<<fact(n)<<endl;
}

练习6.5

double absolute(double a)
{
	if(a>=0)
		return a;
	return -a;
}

练习6.6

答：形参是指函数头的参数；局部变量指作用域为块内的变量；静态变量生命周期为第一次经过对象定义语句初始化，在程序结束时销毁。

练习6.7

int func()
{
	static int count = 0;
	return count++;
}

6.8，6.9为分文件编写题，内容较为简单，在这里就不演示了

练习6.10

void swap(int* a, int* b)
{
	int temp = *b;
	*b = *a;
	*a = temp;
}

练习6.11

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

练习6.12

void swap(int&a, int& b)
{
	int temp = b;
	b = a;
	a = temp;
}

引用更易于使用，因为它不会再申请额外的内存

练习6.13

答：函数的形参不同，需要传入的实参也不同

练习6.14

答：形参是引用时可以修改对应实参的值。

练习6.15

答：因为在使用函数的过程中，我们不希望s的值发生修改；传入的字符不需要修改；可能会导致s修改；计数器无法增长

练习6.16

答：和内置函数empty作用相同

练习6.17

bool isUpper(string s)
{
	for(auto a:s)
		if (isupper(a) == 1)
		{
			return 1;
			break;
		}
	return 0;
}
void toLower(string &s)
{
	for(auto &a:s)
		if (isupper(a) == 1)
		{
			a = tolower(a);
		}
}

答：不一样，第一个不需要改变实参，第二个需要，所以第二个形参为引用。

练习6.18

bool compare(matrix &a,matrix &b);
vector<int>::iterator change_val(int value, vector<int>::iterator iter);

练习6.19

答：a不合理，传入的实参过多

练习6.20

答：在我们不希望通过函数改变输入的实参时，应设为常量引用

练习6.21

int max(int a,int *b)
{
	if(a>*b)
		return a;
	return *b;
	//指针的类型是整形
}

练习6.22

void swap(int *a,int *b)
{
	int *temp = b;
	b = a;
	a = temp;
}

练习6.24

答：i！=10存在问题，传入的数组大小可能不是十，可以显示的传入一个数组的大小n，并改为i！=n

练习6.25

#include <iostream>
#include <string>

int main(int argc, char* argv[]) {
    if (argc != 3) {  // 检查是否有两个参数
        std::cerr << "用法: " << argv[0] << " <参数1> <参数2>" << std::endl;
        return 1;
    }

    std::string combined = std::string(argv[1]) + argv[2];
    std::cout << combined << std::endl;

    return 0;
}

练习6.26

#include <iostream>

int main(int argc, char* argv[]) {
    for (int i = 1; i < argc; ++i) {  // 从第1个参数开始输出（第0个是程序名）
        std::cout << argv[i] << std::endl;
    }

    return 0;
}

练习6.27

int sum(initializer_list<int> i1)
{
	int s = 0;
	for (auto i = i1.begin(); i != i1.end(); ++i)
	{
		s += *i;
	}
	return s;
}

练习6.28

答：常量引用

练习6.29

答：如果需要修改其中的值，可以声明为引用

练习6.30

代码如下：

bool str_subrange(const string& str1, const string& str2)
{
	if (str1.size() == str2.size())
		return str1 == str2;
	auto size = (str1.size() < str2.size()) ? str1.size() : str2.size();
	for (decltype(size) i = 0; i != size; ++i)
	{
		if (str1[i] != str2[i])
			return;//错误，没有返回值，编译器将报错
	}
}

lz的使用的是vs201，报的错误是函数str_subrange必须有返回值

练习6.31

答：返回局部变量的引用无效；当想返回的是左值时

练习6.32

答：合法，作用是将数组中的每个元素置为1

练习6.33

void print(vector<int> i,vector<int>::size_type a)
{
	cout << i[a] << " ";
	if (a != 0)
		return print(i, a - 1);
}

练习6.34

答：不管传入的实参是什么，输出的结果都为0

练习6.35

答：val–是先赋值后递减，传入的是递减前的值

练习6.36

string (*func(string s))[10];

练习6.37

using arrT = string[10];
arrT* func(string s);
auto func(string s)->string (*)[10];
string s1 = {"a","b"};
decltype(s1) *func(string s);

类型别名最好最直观

练习6.38

decltype(add) &arrPtr(int i); 

练习6.39

答：a，传入的实参是两个整形常量；b，函数的返回类型是double；c，函数返回类型是指向double的指针，传入的实参是double的地址

练习6.40

答：b错误，因为一旦某个形参被赋予默认值，后面的形参必须都赋予默认值

练习6.41

答：a是非法的，传入的实参数量不足；c合法但是可能与初衷不符，这样调用代表给前两个形参赋值，最后一个形参使用默认参数

练习6.42

string make_plural(size_t ctr,const string &word,const string &ending = "s")
{
	return (ctr>1) ? word + ending : word;
}

练习6.43

答：a的定义放在头文件中，b的声明放在头文件中。因为内联函数需要在调用点展开，所以在调用该函数时必须看到函数的定义

练习6.44

inline bool isShorter(const string &s1,const string &s2)
{
	return s1.size()<s2.size();
}

练习6.45

答：内联函数通常结构与内容较简单

练习6.46

答：不能，返回类型不是字面值类型

练习6.47

void print(vector<int> i, vector<int>::size_type a)
{
	cout << i[a] << " " ;
	cout << a + 1<<" "<<endl;
	if (a != 0)
		return print(i, a - 1);
}

练习6.48

答：这个循环读取输入的字符串，并将其与sought进行比较。如果输入的字符串不等于sought，则继续读取下一个字符串。assert使用不合理

练习6.49

答：候选函数是指与被调用函数同名且其声明在调用点可见；可行函数是指形参数量与本次调用的提供的实参数量相等且每个实参类型与对应的形参类型相等。

练习6.50

答：a不合法，具有二义性；b调用void f(int)；c调用void f(int,int)；d调用void f(pouble.double)；

练习6.51

void f()
{
	cout<<"f()"<<end;
}
void f(int)
{
	cout<<"f(int)"<<endl;
}
void f(int,int)
{
	cout<<"f(int,int)"<<endl;
}
void f(double,double = 3.14)
{
	cout<<"f(double,double)"<<endl;
}

练习6.52

答：a通过类型提升实现的匹配；b通过算数类型转换实现的匹配

练习6.53

答：a使用第二条语句时，传入的实参不可被修改；b与a相同；c不合法，调用函数时具有二义性。

练习6.54

int func(int,int);
vector<int (*) (int, int)> pt = {func};

练习6.55

int add(int a,int b)
{
	return a+b;
}
int min(int a,int b)
{
	return a-b;
}
int mul(int a,int b)
{
	return a*b;
}
int divide(int a, int b)
{
	if(b!=0)
		return a / b;
	cout << "除数不能为0";
	return 0;
}
vector<int (*) (int, int)> pt2 = { add ,min,mul,divide};

练习6.56

int main()
{
	
	vector<int (*) (int, int)> pt2 = { add ,min,mul,divide};
	cout << pt2[0](1, 2);
	cout << pt2[1](1, 2);
	cout << pt2[2](1, 2);
	cout << pt2[3](1, 2);
	return 0;
}