第十四章部分习题

**练习14.1:**在什么情况下重载的运算符与内置运算符有区别?在什么情况下重载的运算符又与内置运算符一样？

**答：**不同点：重载运算符两侧的运算对象至少有一个是类类型的对象；一些内置运算符保证了操作数的计算顺序，重载该类运算符会破坏操作数的计算顺序，不太提倡。

相同点：重载运算符与内置运算符具有相同的运算顺序（优先级和结合律）。

**练习14.3：**你觉得为什么调用operator+=定义operator+比其他方法更有效？

**答：**operator+会产生一个不必要的局部变量值。

**练习14.29：**为什么不定义const版本的递增和递减运算符？

**答：**因为++或–个改变了对象的状态。

**练习14.31:**我们的StrBlobPtr类没有定义拷贝构造函数、赋值运算符及析构函数，为什么？

**答：**由C++类的"3/5原则"，因为StrBlobPtr类中不存在动态内存，合成的析构函数足以满足要求，所有没有定义。

**练习14.33：**一个重载的函数调用运算符应该接受几个运算对象？

**答：**重载的运算符函数具有与运算符具有操作数相同数量的参数。因此最大值应该在256左右。

**练习14.34：**定义一个函数对象类来执行 if-then-else 操作：该类的调用运算符应采用三个参数。它应该测试它的第一个参数，如果测试成功，它应该返回它的第二个参数；否则，它应该返回它的第三个参数。

答：

#include<iostream>
using namespace std;

class Solution{
public:
    Solution(int a=2,int b=3,int c=4):a1(a),a2(b),a3(c){

    }
    const int& operator()(const int a,const int b,const int c) const{
        return a>0?b:c;
    }

private:
    int a1;
    int a2;
    int a3;
};


int main(){
    Solution s;
    int a=1,b=2,c=3;
    int ans=s(a,b,c);
    cout<<ans<<endl;
    return 0;
}

**练习14.35：**编写一个类似 PrintString 的类，它从 istream 读取一行输入并返回一个表示读取内容的字符串。如果读取失败，则返回空字符串。

答：

#include <iostream>
#include <string>
using namespace std;

class ReadString{
public:
    ReadString(istream &i=cin):in(i){

    }
    string operator() (){
        string str;
        getline(in,str);
        return in?str:string();
    }

private:
    istream &in;
};

int main(){
    ReadString r;
    string res=r();
    cout<<res<<endl;
    return 0;
}

**练习14.36：**使用上一个练习中的类来读取标准输入，将每一行存储为向量中的一个元素。

答：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class ReadString{
public:
    ReadString(istream &i=cin):in(i){

    }
    void operator() (){
        string str;
        while(getline(in,str)){
            vs.push_back(str); 
        }  
    }

    vector<string> vs;

private:
    istream &in;
    
};

int main(){
    ReadString r;
    r();
    for(auto s:r.vs){
        cout<<s<<endl;
    }
    return 0;
}

**练习14.37:**编写一个测试两个值是否相等的类。使用该对象和库算法编写程序以替换序列中给定值的所有实例。

答：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class IsEqual{
public:
    IsEqual(int v):value(v){}

    bool operator()(int elements){
        return value==elements;
    }
private:
    int value;
};

int main(){
    vector<int> v={1,2,3,4,5,6,7};
    replace_if(v.begin(),v.end(),IsEqual(5),10);
    for(auto i:v){
        cout<<i<<endl;
    }   
}

**练习14.38:**编写一个类来测试给定字符串的长度是否与给定界限匹配。使用该对象编写一个程序来报告输入文件中有多少字的大小为 1 到 10（含）

答:

#include<iostream>
#include<string> 
#include<vector>
#include<fstream>
#include<algorithm>

struct Comp
{
	Comp(int i = 0) : a(i) { }
	bool operator()(const std::string & s)
	{
		if(s.size() == a)
			return true;
		return false;
	}
	int a;
};

int main()
{
	std::ifstream ifs("/home/hrh/Code/C++ Primer/chapter_14/exercise/string.txt");
	std::vector<std::string> v;
	std::string s;
	while(ifs >> s)
		v.push_back(s);
    for(auto s:v){
        std::cout<<s<<std::endl;
    }
	for(int i = 1; i != 11; ++i)
		std::cout << std::count_if(v.begin(), v.end(), Comp(i)) << " ";
	std::cout << std::endl;
	return 0;
}

14.44

/* 
    编写一个简单的桌面计数器使其能处理二元运算
 */
#include <iostream>
#include <functional>
#include <string>
#include <map>
using namespace std;

int add(int a, int b){
    return a+b;
}
auto mod=[](int i, int j){return i%j;};
class Caulate{
public:
    Caulate(std::map<std::string,function<int(int,int)>> binops) :binops(binops){}
    int operator() (int a, int b){
        return a*b;
    }
    std::map<std::string,function<int(int,int)>> binops;  
};

struct divide
{
    int operator() (int denominator, int divisor){
        return denominator/divisor;
    }
};

int main(int argc, char **argv){
    map<string,function<int(int,int)>> binops = {
    {"+",add},
    {"-",minus<int>()},
    {"/",divide()},
    {"*",[](int i, int j){return i*j;}},
    {"%",mod},
    {"*",Caulate(binops)}
};
    Caulate c(binops);
    int a=4,b=2;
    int ans=c.binops["+"](a, b);
    int ans2=c.binops["*"](10,2);
    cout<< ans << ' ' <<ans2 << endl;
}