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;
	else
		item = 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 copy
	sum.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 copy
	return *this;
}
//second version:
Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) {
	Sales_data sum = lhs;//#1 copy
	sum += 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);
}