C++Prmer第五版课后习题答案(6)

6-27

#include<iostream>

void sum(std::initializer_list<int> i1){
    int sum=0;
    for(auto beg=i1.begin();beg!=i1.end();++beg){
        sum+=*beg;
    }
    std::cout<<sum<<std::endl;
}

int main(){
    sum({1,2,3,4,5,6,7});
}

6-28
const string &
6-29
应该，声明成引用类型，能够避免实参的复制，提高效率。

6-30

#include<iostream>
#include<string>

using std::string;

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

int main(){
    string str1="123",str2="34";
    std::cout<<str_subrange(str1,str2);
    return 0;
}

编译器输出如下

.\p6-30.cc: In function 'bool str_subrange(const string&, const string&)':
.\p6-30.cc:13:13: error: return-statement with no value, in function returning 'bool' [-fpermissive]
             return;
             ^~~~~~

6-31
什么情况下返回的引用是无效的：返回局部对象的引用是无效的。
什么情况下返回常量的引用是无效的：当对函数的返回对象进行赋值时，返回常量的引用是无效的
6-32
合法
6-33

#include<iostream>
#include<vector>

void output(std::vector<int> a){
    if(!a.empty()){
        std::cout<<a.back()<<std::endl;
        a.pop_back();
        output(a);
    }
}

int main(){
    output({1,2,3,4,5,6,7,8,9});
    return 0;
}

6-34
如果factorial函数的停止条件如下，将发生什么情况？
if(val!=0)
这将导致当输入的val为负数时将一直递归，会因为递归函数调用次数过多而发生程序栈溢出。使得程序无法继续执行。当val为大于0的正数时和原来的输出值一样。当val等于0时将返回1。
6-35
在factorial(val–)表示先执行factorial(val)，然后val=val-1。
6-36

string (&func(string (&arrStr)[10]))[10]

6-37

using ArrT = string[10];
ArrT& func1(ArrT& arr);

auto func2(ArrT& arr) -> string(&)[10];

string arrS[10];
decltype(arrS)& func3(ArrT& arr);

6-38

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

6-39
重载函数：同一作用域内的函数名字相同但形参列表不同。
(a)错误，因为一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开
(b)错误，形参列表相同
©正确，形参列表不同，同一作用域内的函数名字相同
6-40
(a)正确。
(b)错误。一旦函数的某个参数被赋予了默认参数值，那么后面的参数都应该赋予默认参数值。
6-41
(a)错误，ht应该提供实参。
(b)正确
©正确，但是wd会被赋予’*’。
6-42

#include<iostream>
#include<string>

using std::string;

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

int main(){
    std::cout<<make_plural(1,"success")<<std::endl;
    std::cout<<make_plural(2,"failure")<<std::endl;
    return 0;
}

6-43
(a)将其放入到头文件中，这个是内联函数。
(b)将其放入到头文件中，即使是普通函数，放入到头文件中也是好的。
6-44

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

6-45
一般来说，内联函数用于优化规模较小、流程直接、频繁调用的函数。
6-46
constexpr函数有几项规定：函数的返回类型及所有形参的类型都是字面值类型，并且函数体中必须有且只有一条return语句。其中字面值类型为算术类型，引用和指针。自定义类Sales_item,IO库，string类型都不属于字面值类型。
所以，不能。
6-47

#include<iostream>
#include<vector>

void output(std::vector<int> a){
    #ifndef NDEBUG
        std::cerr<<__func__<<a.size()<<std::endl;
    #endif
    if(!a.empty()){
        std::cout<<a.back()<<std::endl;
        a.pop_back();
        output(a);
    }
}

int main(){
    output({1,2,3,4,5,6,7,8,9});
    return 0;
}

6-48
不合理，只要有输入，则assert一直为真，无意义
6-49
候选函数：函数匹配的第一步是选定本次调用的重载函数集，集合中的函数被称为候选函数
可行函数：根据实参情况，从候选函数中挑选出能被这实参调用的函数，此次选出的函数被称为可行函数。
6-50
(a)这个调用具有二义性,不合法
(b)void f(int)
©void f(int ,int )
(d)void f(double,double)
6-51

6-52

6-53

6-54

#include<iostream>
#include<vector>

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

int f(int a,int b){
    return a+b;
}

int main(){
    std::vector<F> v;
    int (*pf)(int a,int b);
    v.push_back(pf);
    v[0]=f;
    int sum=(*v[0])(1,2);
    std::cout<<sum<<std::endl;

    return 0;
}

6-55

#include<iostream>
#include<vector>

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

int addition(int a,int b){
    return a+b;
}

int subtraction(int a,int b){
    return a-b;
}

int multiplication(int a,int b){
    return a*b;
}

int division(int a,int b) {
    if(b==0){
        return 0;
    }else{
        return a/b;
    }
}

int main(){
    std::vector<F> v;
    int (*p1)(int a,int b);p1=addition;
    int (*p2)(int a,int b);p2=subtraction;
    int (*p3)(int a,int b);p3=multiplication;
    int (*p4)(int a,int b);p4=division;
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);

    return 0;
}

6-56

#include<iostream>
#include<vector>

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

int addition(int a,int b){
    return a+b;
}

int subtraction(int a,int b){
    return a-b;
}

int multiplication(int a,int b){
    return a*b;
}

int division(int a,int b) {
    if(b==0){
        return 0;
    }else{
        return a/b;
    }
}

int main(){
    std::vector<F> v;
    int (*p1)(int a,int b);p1=addition;
    int (*p2)(int a,int b);p2=subtraction;
    int (*p3)(int a,int b);p3=multiplication;
    int (*p4)(int a,int b);p4=division;
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    int r1=p1(1,2);std::cout<<r1<<std::endl;
    int r2=p2(2,1);std::cout<<r2<<std::endl;
    int r3=p3(2,2);std::cout<<r3<<std::endl;
    int r4=p4(2,1);std::cout<<r4<<std::endl;

    return 0;
}