c++primer（第五版） 第十四章 重载运算与类型转换习题答案

本章内容说实话比较简单,代码题大都是照着前面的代码敲一遍,没有什么难度 

但部分题要去找前面章节的代码 确实比较麻烦 

所有本章就不提供代码题答案了......

14.1---14.4

#include<iostream>
#include<string>
#include<vector>
#include"Sales_data.h"
using namespace std;

int main(){
//    14.1
//    重载版本与内置版本拥有相同的运算符优先级和结合律的时候 --相同
//    某些运算符的重载版本不会维持内置版本的运算优先级    ---不相同

//    14.3
//    "cobble"=="stone"     const char*
//    svec1[0]==svec2[0]    string版本
//    svec1==svec2          vector版本
//    svec1[0]=="stone"     string版本


//    14.4
//    其中(),[],->必须是类的成员
//    改变对象状态的运算符通常是类的成员: %=,++



    return 0;
}


//    14.2
istream& operator>>(std::istream &is, Sales_data &item)
{
    double price = 0.0;
    is >> item.bookNo >> item.units_sold >> price;
    if (is)
        item.revenue = price * item.units_sold;
    else
        item = Sales_data();
    return is;
}

ostream& operator<<(std::ostream &os, const Sales_data &item)
{
    os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();
    return os;
}

Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{
    Sales_data sum = lhs;
    sum += rhs;
    return sum;
}

14.7

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
class String{
    friend ostream& operator<<(ostream& os,const String& Str){     //14.7
        for(char* i=Str.elements;i<Str.cap;i++)
            os<<*i;
        return os;
    }
public:
    String():elements(nullptr),cap(nullptr){}
    String(const char* ch,size_t len);
    String(const String&);
    String& operator=(const String&);
    ~String(){free();}

    size_t capacity(){return cap-elements;}

private:
    allocator<char>alloc;
    char* elements;
    char* cap;
    void free(){
        if(elements){
            size_t len=cap-elements;
            while(cap!=elements)
                alloc.destroy(--cap);
            alloc.deallocate(elements,len);
        }
    }
    pair<char*,char*> alloc_n_copy(const char* st,const char* ed){
        char* data=alloc.allocate(ed-st);
        return {data,uninitialized_copy(st,ed,data)};
    }
};

String::String(const char* ch,size_t len){
    auto newdata=alloc_n_copy(ch,ch+len);
    elements=newdata.first;
    cap=newdata.second;
}

String::String(const String& cv){
    auto newdata=alloc_n_copy(cv.elements,cv.cap);
    elements=newdata.first;
    cap=newdata.second;
}

String& String::operator=(const String& cv){
    auto newdata=alloc_n_copy(cv.elements,cv.cap);
    free();
    elements=newdata.first;
    cap=newdata.second;
    return *this;
}

int main(){
    char* str="aaaaaaaaaaaaaassdd";
    String cv(str,strlen(str));
    cout<<cv<<endl;
    return 0;
}

14.10   14.11  

14.10
//(a)正确输入
//(b)后两项类型不符合  但会被强制转换


14.11
//没有判断输入是否合法
//price处于未初始化的状态

14.14

14.14
//代码变得简洁 不需要一一判断进行相加
//同时不会改变+运算符两边的对象的值

14.42

std::count_if(ivec.cbegin(), ivec.cend(), std::bind(std::greater<int>(), _1, 1024));
std::find_if(svec.cbegin(), svec.cend(), std::bind(std::not_equal_to<std::string>(), _1, "pooh"));
std::transform(ivec.begin(), ivec.end(), ivec.begin(), std::bind(std::multiplies<int>(), _1, 2));

14.47

struct Integral {
    operator const int();   // 没有任何意义 被编译器忽视
    operator int() const;   // 不会修改调用此方法的对象的状态
};

14.50  14.51

struct LongDouble {
    LongDouble(double = 0.0);
    operator double();
    operator float();
};
LongDouble ldObj;
int ex1 = ldObj;    // operator double();  ||  operator float();
float ex2 = ldObj;  // 正确


void calc(int);
void calc(LongDouble);
double dval;
calc(dval); // which calc?
//14.51
转换匹配顺序:
1 精确匹配
2 常量版本
3 类型提升
4 算数转换或指针转换           //所以调用calc(int)最佳
5 类类型转换

14.52   14.53

struct LongDouble {
   LongDouble operator+(const SmallInt&); // 1
};
LongDouble operator+(LongDouble&, double); // 2
SmallInt si;
LongDouble ld;
ld = si + ld;      //不合法  无论哪种版本,+号两边值都要转换
ld = ld + si;      //1精确匹配

14.53
SmallInt s1;
double d = s1 + 3.14;
不合法 可以是重载+也可以s1转换为int再转换为double的+