14.3. Arithmetic and Relational Operators

#include <string>#include <iostream>using namespace std;class Sales_data {friend istream &operator>>(istream &, Sales_data &);friend ostream &operator<<(ostream &, const Sales_data &);friend Sales_data operator+(const Sales_data &, const Sales_data &);friend Sales_data operator-(const Sales_data &, const Sales_data &);public:Sales_data(const string &s, unsigned n, double p) : bookNo(s), units_sold(n), revenue(n * p) { }Sales_data() : Sales_data("", 0, 0.0) { }Sales_data(const string &s) : Sales_data(s, 0, 0.0) { }Sales_data(istream &is);Sales_data &operator+=(const Sales_data &);Sales_data &operator-=(const Sales_data &);string isbn() const { return bookNo; }private:inline double avg_price() const;string bookNo;unsigned units_sold = 0;double revenue = 0.0;};istream &operator>>(istream &, Sales_data &);ostream &operator<<(ostream &, const Sales_data &);Sales_data operator+(const Sales_data &, const Sales_data &);Sales_data operator-(const Sales_data &, const Sales_data &);inline double Sales_data::avg_price() const {return units_sold ? revenue / units_sold : 0;}#include "ChenHC.h"using namespace std;Sales_data::Sales_data(istream &is) : Sales_data() {is >> *this;}Sales_data &Sales_data::operator+=(const Sales_data &rhs) {units_sold += rhs.units_sold;revenue += rhs.revenue;return *this;}Sales_data &Sales_data::operator-=(const Sales_data &rhs) {units_sold -= rhs.units_sold;revenue -= rhs.revenue;return *this;}istream &operator>>(istream &is, Sales_data &item) {double price = 0.0;is >> item.bookNo >> item.units_sold >> price;if (is)item.revenue = price * item.units_sold;elseitem = Sales_data();return is;}ostream &operator<<(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;}Sales_data operator-(const Sales_data &lhs, const Sales_data &rhs) {Sales_data sum = lhs;sum -= rhs;return sum;}int main() {Sales_data s1("book1", 150, 10);Sales_data s2("book1", 200, 20);cout << s1 << endl;s1 = s1 + s2;cout << s1 << endl;s1 += s2;cout << s1 << endl;s1 -= s2;cout << s1 << endl;s1 = s1 - s2;cout << s1 << endl;return 0;}//Exercise 14.14: Why do you think it is more efficient to define operator+//to call operator+= rather than the other way around ?//first version:Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) {Sales_data sum = lhs;//#1 copysum.revenue += rhs.revenue;sum.units_sold += rhs.revenue;return sum;//#2 copy}Sales_data &Sales_data::operator+=(const Sales_data &rhs) {*this = *this + rhs;//#3 copyreturn *this;}//second version:Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) {Sales_data sum = lhs;//#1 copysum += rhs;return sum;//#2 copy}Sales_data &Sales_data::operator+=(const Sales_data &rhs) {units_sold += rhs.units_sold;revenue += rhs.revenue;return *this;}//So, the second version is more efficient#include <memory>#include <string>#include <initializer_list>using namespace std;class StrVec {friend bool operator==(const StrVec &, const StrVec &);friend bool operator!=(const StrVec &, const StrVec &);friend bool operator< (const StrVec &, const StrVec &);friend bool operator> (const StrVec &, const StrVec &);friend bool operator<=(const StrVec &, const StrVec &);friend bool operator>=(const StrVec &, const StrVec &);public:StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) { }StrVec(initializer_list<string>);StrVec(const StrVec &);StrVec& operator=(const StrVec &);StrVec(StrVec&&) noexcept;StrVec &operator=(StrVec&&) noexcept;~StrVec();void push_back(const string &);size_t size() const { return first_free - elements; }size_t capacity() const { return cap - elements; }string *begin() const { return elements; }string *end() const { return first_free; }string &at(size_t pos) { return *(elements + pos); }const string &at(size_t pos) const { return *(elements + pos); }void reserve(size_t new_cap);void resize(size_t count);void resize(size_t count, const string &);private:pair<string *, string *> alloc_n_copy(const string *, const string *);void free();void chk_n_alloc() { if (size() == capacity()) reallocate(); }void reallocate();void alloc_n_move(size_t new_cap);void range_initialize(const string *, const string *);private:string *elements;string *first_free;string *cap;allocator<string> alloc;};bool operator==(const StrVec &, const StrVec &);bool operator!=(const StrVec &, const StrVec &);bool operator< (const StrVec &, const StrVec &);bool operator> (const StrVec &, const StrVec &);bool operator<=(const StrVec &, const StrVec &);bool operator>=(const StrVec &, const StrVec &);#include "ChenHC.h"#include <algorithm>using namespace std;void StrVec::push_back(const string &s) {chk_n_alloc();alloc.construct(first_free++, s);}pair<string *, string *> StrVec::alloc_n_copy(const string *b, const string *e) {auto data = alloc.allocate(e - b);return { data, uninitialized_copy(b, e, data) };}void StrVec::free() {if (elements) {for_each(elements, first_free, [this](string &rhs) { alloc.destroy(&rhs); });alloc.deallocate(elements, cap - elements);}}void StrVec::range_initialize(const string *first, const string *last) {auto newdata = alloc_n_copy(first, last);elements = newdata.first;first_free = cap = newdata.second;}StrVec::StrVec(const StrVec &rhs) {range_initialize(rhs.begin(), rhs.end());}StrVec::StrVec(initializer_list<string> il) {range_initialize(il.begin(), il.end());}StrVec::~StrVec() {free();}StrVec &StrVec::operator=(const StrVec &rhs) {auto data = alloc_n_copy(rhs.begin(), rhs.end());free();elements = data.first;first_free = cap = data.second;return *this;}void StrVec::alloc_n_move(size_t new_cap) {auto newdata = alloc.allocate(new_cap);auto dest = newdata;auto elem = elements;for (size_t i = 0; i != size(); ++i)alloc.construct(dest++, std::move(*elem++));free();elements = newdata;first_free = dest;cap = elements + new_cap;}void StrVec::reallocate() {auto newcapacity = size() ? 2 * size() : 1;alloc_n_move(newcapacity);}void StrVec::reserve(size_t new_cap) {if (new_cap <= capacity()) return;alloc_n_move(new_cap);}void StrVec::resize(size_t count) {resize(count, string());}void StrVec::resize(size_t count, const string &s) {if (count > size()) {if (count > capacity()) reserve(count * 2);for (size_t i = size(); i != count; ++i)alloc.construct(first_free++, s);}else if (count < size()) {while (first_free != elements + count)alloc.destroy(--first_free);}}StrVec::StrVec(StrVec &&s) noexcept : elements(s.elements), first_free(s.first_free), cap(s.cap) {s.elements = s.first_free = s.cap = nullptr;}StrVec &StrVec::operator=(StrVec &&rhs) noexcept {if (this != &rhs) {free();elements = rhs.elements;first_free = rhs.first_free;cap = rhs.cap;rhs.elements = rhs.first_free = rhs.cap = nullptr;}return *this;}bool operator==(const StrVec &lhs, const StrVec &rhs) {return (lhs.size() == rhs.size() && equal(lhs.begin(), lhs.end(), rhs.begin()));}bool operator!=(const StrVec &lhs, const StrVec &rhs) {return !(lhs == rhs);}bool operator<(const StrVec &lhs, const StrVec &rhs) {return lexicographical_compare(lhs.begin(), rhs.end(), rhs.begin(), rhs.end());}bool operator<=(const StrVec &lhs, const StrVec &rhs) {return !(rhs < lhs);}bool operator>=(const StrVec &lhs, const StrVec &rhs) {return !(lhs < rhs);}