C++PRIMER第六章练习

6.1

形参是函数与外界接受数据的一种方式，生命周期是该函数执行完毕前。

实参是在调用函数时的参数，传递给函数用于初始化形参

6.2

a)返回类型不匹配

b)没返回类型

c)形参不能同名

d)缺少花括号

6.3,6.4

#include<iostream>
using namespace std;
int fact(int i)
{
int ret = 1;
while (i>1)
ret *= i--;
return ret;
}
int main()
{
int n;
cout << "Enter a number:";
cin >> n;
cout << n<<"!="<<fact(n);
return 0;
}

6.5

double Fabs(double d)
{
if (d < 0)
return -d;
return d;
}

6.6

在函数参数列表声明的是形参，用于实参与形参之间的数据传递;

在函数体内定义的变量为局部变量,会隐藏外层作用域的同名声明;

局部静态对象在程序的执行路径第一次经过对象定义语句时初始化,直到程序终止才被销毁,即使函数结束执行~~

int add(int n,int m)
{
static int count = 0;
++count;
cout << "add has been calld " << count << "times\n";
int sum = n + m;
return sum;
}

6.7

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

6.8

//Chapter6.h

#ifndef _HEAD_H_

#define _HEAD_H_

int fact(int);

#enddif

6.9

//fact.cc

#include"Chapter6.h"

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

//factMain.cc

#include"Chapter6.h"

#include<iostream>

using namespace std;

int main()
{
int n;
cout << "Enter a number:";
cin >> n;
cout << n<<"!="<<fact(n);
return 0;
}

6.10

#include<iostream>
using namespace std;
void swap(int*p1, int*p2)
{
int temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int i = 2, j = 5;
swap(&i, &j);
cout << "i=" << i << endl;
cout << "j=" << j << endl;
return 0;
}

6.12

#include<iostream>
using namespace std;
void swap(int&x, int&y)
{
int temp;
temp = x;
x = y;
y = x;
}
int main()
{
int i = 2, j = 5;
swap(i, j);
cout << "i=" << i << endl;
cout << "j=" << j << endl;
return 0;
}

引用更好用些,阅读起来更容易,没有引入其余类型

6.13

一个不会修改实参,一个可以修改实参

6.14

要交换2个数的值形参应该用引用类型;

当函数体内改变了形参的值,而实参不希望被改变的时候形参不能是引用类型,比如传入常量的时候

6.15

字符串s本来就不应该被修改，所以是const，再来就是定义为引用时绑定的速度比把整个实参传递过来地要快

occurs是用来记录c出现的次数了，如果不是引用，那么将无法改变实参达到记录的目的;

c不是引用是为了防止修改常量字符;如果令s是普通引用将没法传入字符串常量,如果令occurs是常量引用将无法改变occurs的值

6.16

无法使用const string&的实参;

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

6.17

//判断是否含有大写字母

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

//全部改成小写

void to_low( string&s)
{
for (char &c : s)
{
c = tolower(c);
}
}

6.18

a)bool compare(const matrix&,const maxtrix&);

比较两个matrix类,不会修改它们

b)vector<int>::iterator tchange_val(const int,vector<int>::iterator)

将迭代器指向的对象改为传入的int参数值;

6.19

a)不合法,参数数量不对

b)合法

c)合法

d)合法

6.20

在不需要修改引用参数时应该是常量引用;可能会改变实参的值;

6.21

int max(const int i,const int*p)
{
return i > *p ? i : *p;
}

6.22

void swap(int *p1, int *p2)
{
int *temp = p1;
p1 = p2;
p2 = p1;
}

6.24

不能以按值传递的方式传递数组,因为数组无法复制

void print(const int(&ia)[10])

6.25

#include <iostream>  
#include <string>  
int main(int argc, char **argv)
{
std::string str1 = argv[1], str2 = argv[2];
str1 += str2;
std::cout << str1;
return 0;
}

6.26

#include <iostream>  
int main(int argc, char **argv)
{
for (int i = 0; i < argc; ++i)
{
std::cout << argv[i];
}
return 0;
}

6.27

#include <iostream>
#include<initializer_list>
using namespace std;
int sum( initializer_list<int> l)
{
int s = 0;
for (auto beg = l.begin(); beg != l.end(); ++beg)
s += *beg;
return s;
}

6.28

string&

6.29

不建议,因为本身initializer_list对象中的元素都是常量值,不允许修改,但是可以const引用

6.31

返回局部对象的引用时无效;返回左值的时候返回常量的引用无效

6.32

合法,给数组赋值0~9

6.33

#include <iostream>
#include<vector>
#include<iterator>
using namespace std;
void show_vec(vector<int>::iterator iter1, vector<int>::iterator iter2)
{
cout << *iter1++<< ",";
if(iter1!=iter2)
show_vec(iter1,iter2);
}
int main()
{
vector<int> v{ 1,2,3,4,5 };
show_vec(v.begin(), v.end());
return 0;
}

6.34

val>0的情况下结果永远为0

6.35

未确定行为,首先表示val--的值还是val,其次同一个表达式里子表达式试图修改另一表达式的值.

6.36

string (&func())[10]

6.37

1)using str=string[10]

str&func();

2)

string[10]  str;

auto func()->string(&)[10]

3)

decltype(str) &func;

6.38

decltype(odd)&arrPtr(int i)

{

return (i%2)?odd:even;

}

6.39

a)非法,重复声明

b)非法,重复声明

c)合法

6.40

b)错误,默认实参要放最右侧,一旦某个形参有了默认值,它后面的形参都得有默认值.

6.41

a非法,ht缺少实参,c虽然合法但是初衷不符,'*'应该是想传给bckgrnd的,结果转成INT传给了 wd

6.43

a的声明定义放头文件, b声明放头文件,定义放源文件

6.44

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

6.46

不行,无法确定函数中所有的值

6.48

当输入流异常或s与sought相等时循环终止assert只检查输入流异常的时候,比如CTRL+Z终止

6.49

重载函数集里的是候选函数,首先函数要同名,其次声明在调用点可见.

可行函数是指能被这组实参调用的函数,包括数量和类型(可转化)

6.50

a)非法,二义性

b)f(int)

c)f(int,int)

d)f(double,double)

6.52

a)类型提升  b)算术转换

6.53

a)重载函数,

b)重载函数

c)非法,二义性

6.54

typedef int (*fp)(int,int);

using fp=int(*)(int,int);

vector<fp>

6.55,6.56

#include <iostream>  
#include <vector>  
using namespace std;
int add(int a, int b) { return a + b; }
int minu(int a, int b) { return a - b; }
int multiply(int a, int b) { return a*b; }
int divide(int a, int b) { return a / b; }
int main()
{
typedef int (*fp)(int, int);
vector<fp> func{ add,minu,multiply,divide };
for(auto f:func)
cout << f(5, 3)<<endl;
}