本章内容说实话比较简单,代码题大都是照着前面的代码敲一遍,没有什么难度
但部分题要去找前面章节的代码 确实比较麻烦
所有本章就不提供代码题答案了......
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的+