C++ primer习题记录——第十四章

最新推荐文章于 2024-10-08 12:54:42 发布
最新推荐文章于 2024-10-08 12:54:42 发布
阅读量1.1k 收藏
点赞数
文章标签： c++ 蓝桥杯 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sstateo/article/details/123720208
版权

14.2：

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
class Sales_data
{
	friend istream& read(istream& is, Sales_data& item);
	friend ostream& print(ostream& os, const Sales_data& item);
	friend Sales_data add(const Sales_data& s1, const Sales_data& s2);
	friend istream& operator>>(istream& , Sales_data&);
	friend ostream& operator<<(ostream& , const Sales_data&);
	friend Sales_data operator+(const Sales_data& s1, const Sales_data& s2);
public:
	Sales_data() = default;
	Sales_data(const string& s) :bookNo(s) {};
	Sales_data(const string& s, unsigned n, double p) :bookNo(s), unit_sold(n), revenue(n* p) {};
	Sales_data(istream& is) { read(cin, *this); }
	Sales_data& operator+=(const Sales_data& s);

	Sales_data& combine(const Sales_data& rhs);
	string isbn()const
	{
		return this->bookNo;
	}
private:
	inline double avg_price()const;
	string bookNo;
	unsigned unit_sold = 0;
	double revenue = 0.0;
};
Sales_data& Sales_data::combine(const Sales_data& rhs)
{
	this->unit_sold += rhs.unit_sold;
	this->revenue += rhs.revenue;
	return *this;
}
Sales_data add(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp.combine(s2);
	return temp;
}
istream& read(istream& is, Sales_data& item)
{
	double price = 0;
	is >> item.bookNo >> item.unit_sold >> price;
	item.revenue = item.unit_sold * price;
	return is;
}
ostream& print(ostream& os, const Sales_data& item)
{
	os << item.bookNo << " " << item.unit_sold << " " << item.revenue;
	return os;
}
inline double Sales_data::avg_price()const
{
	return unit_sold ? revenue / unit_sold : 0;
}
istream& operator>>(istream& in, Sales_data& sd)
{
	double price = 0;
	in >> sd.bookNo >> sd.unit_sold >> price;
	if (in)
	{
		sd.revenue = sd.unit_sold * price;
	}
	else
	{
		sd = Sales_data();
	}
	return in;
}
ostream& operator<<(ostream& out, const Sales_data& item)
{
	out << item.bookNo << " " << item.unit_sold << " " << item.revenue << " " << item.avg_price();
	return out;
}
Sales_data operator+(const Sales_data& s1, const Sales_data & s2)
{
	Sales_data temp = s1;
	temp.unit_sold += s2.unit_sold;
	temp.revenue += s2.revenue;
	return temp;
}
Sales_data& Sales_data::operator+=(const Sales_data& s)
{
	this->unit_sold += s.unit_sold;
	this->revenue += s.revenue;
	return *this;
}

14.7：

String.h:

#pragma once
#include<iostream>
using namespace std;
#include<algorithm>

class String
{
	friend ostream& operator<< (ostream& os, const String& s);
public:
	String():String("") {}
	String(const String&);
	String(const char*);
	String& operator=(const String&);
	String(String&&)noexcept;
	String& operator=(String&&)noexcept;
	~String();
	const char* c_str() const { return elements; }
	size_t size() const { return end - elements; }
	size_t length() const { return end - elements - 1; }

private:
	pair<char*, char*>alloc_n_copy(const char*, const char*);
	void range_initializer(const char*, const char*);
	void free();
	char* elements;
	char* end;
	allocator<char>alloc;
};
ostream& operator<< (ostream& os, const String& s);

String.cpp:

#include"string.h"

pair<char*, char*>String::alloc_n_copy(const char*b, const char*e)
{
	auto str = alloc.allocate(e - b);
	return { str,uninitialized_copy(b,e,str) };
}
void String::range_initializer(const char*b, const char*e)
{
	auto newstr = alloc_n_copy(b, e);
	elements = newstr.first;
	end = newstr.second;
}
String::String(const char*s)
{
	char* s1 = const_cast<char*>(s);
	while (*s1)
	{
		++s1;
	}
	range_initializer(s, ++s1);
}
String::String(const String&rhs)
{
	range_initializer(rhs.elements, rhs.end);
	cout << "copy constructor" << endl;
}
void String::free()
{
	if (elements)
	{
		for_each(elements, end, [this](char& c) {alloc.destroy(&c); });
		alloc.deallocate(elements, end - elements);
	}
}
String::~String()
{
	free();
}
String& String::operator=(const String&rhs)
{
	auto newstr = alloc_n_copy(rhs.elements, rhs.end);
	free();
	elements = newstr.first;
	end = newstr.second;
	cout << "copy assignment" << endl;
	return *this;
}
String::String(String&&s)noexcept:elements(s.elements),end(s.end)
{
	s.elements = s.end = nullptr;
}
String& String::operator=(String&&s)noexcept
{
	if (this != &s)
	{
		free();
		elements = s.elements;
		end = s.end;
		s.elements = s.end = nullptr;
	}
	return *this;
}
ostream& operator<< (ostream& os, const String& s)
{
	char* c = const_cast<char*>(s.c_str());
	while (*c)
	{
		os << *c++;
	}
	return os;
}

14.13：

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
class Sales_data
{
	friend istream& read(istream& is, Sales_data& item);
	friend ostream& print(ostream& os, const Sales_data& item);
	friend Sales_data add(const Sales_data& s1, const Sales_data& s2);
	friend istream& operator>>(istream& , Sales_data&);
	friend ostream& operator<<(ostream& , const Sales_data&);
	friend Sales_data operator+(const Sales_data& s1, const Sales_data& s2);
	friend Sales_data operator-(const Sales_data& s1, const Sales_data& s2);
public:
	Sales_data() = default;
	Sales_data(const string& s) :bookNo(s) {};
	Sales_data(const string& s, unsigned n, double p) :bookNo(s), unit_sold(n), revenue(n* p) {};
	Sales_data(istream& is) { read(cin, *this); }
	Sales_data& operator+=(const Sales_data& s);
	Sales_data& operator-=(const Sales_data& s);

	Sales_data& combine(const Sales_data& rhs);
	string isbn()const
	{
		return this->bookNo;
	}
private:
	inline double avg_price()const;
	string bookNo;
	unsigned unit_sold = 0;
	double revenue = 0.0;
};
Sales_data& Sales_data::combine(const Sales_data& rhs)
{
	this->unit_sold += rhs.unit_sold;
	this->revenue += rhs.revenue;
	return *this;
}
Sales_data add(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp.combine(s2);
	return temp;
}
istream& read(istream& is, Sales_data& item)
{
	double price = 0;
	is >> item.bookNo >> item.unit_sold >> price;
	item.revenue = item.unit_sold * price;
	return is;
}
ostream& print(ostream& os, const Sales_data& item)
{
	os << item.bookNo << " " << item.unit_sold << " " << item.revenue;
	return os;
}
inline double Sales_data::avg_price()const
{
	return unit_sold ? revenue / unit_sold : 0;
}
istream& operator>>(istream& in, Sales_data& sd)
{
	double price = 0;
	in >> sd.bookNo >> sd.unit_sold >> price;
	if (in)
	{
		sd.revenue = sd.unit_sold * price;
	}
	else
	{
		sd = Sales_data();
	}
	return in;
}

ostream& operator<<(ostream& out, const Sales_data& item)
{
	out << item.bookNo << " " << item.unit_sold << " " << item.revenue << " " << item.avg_price();
	return out;
}
Sales_data operator+(const Sales_data& s1, const Sales_data & s2)
{
	Sales_data temp = s1;
	temp.unit_sold += s2.unit_sold;
	temp.revenue += s2.revenue;
	return temp;
}
Sales_data& Sales_data::operator+=(const Sales_data& s)
{
	this->unit_sold += s.unit_sold;
	this->revenue += s.revenue;
	return *this;
}
Sales_data operator-(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp -= s2;
	return temp;
}
Sales_data& Sales_data::operator-=(const Sales_data& s)
{
	this->unit_sold -= s.unit_sold;
	this->revenue -= s.revenue;
	return *this;
}

14.16：

string.h:

#pragma once
#include<iostream>
using namespace std;
#include<algorithm>

class String
{
	friend ostream& operator<< (ostream& os, const String& s);
	friend bool operator==(const String& s1, const String& s2);
	friend bool operator!=(const String& s1, const String& s2);
public:
	String():String("") {}
	String(const String&);
	String(const char*);
	String& operator=(const String&);
	String(String&&)noexcept;
	String& operator=(String&&)noexcept;
	~String();
	const char* c_str() const { return elements; }
	size_t size() const { return end - elements; }
	size_t length() const { return end - elements - 1; }

private:
	pair<char*, char*>alloc_n_copy(const char*, const char*);
	void range_initializer(const char*, const char*);
	void free();
	char* elements;
	char* end;
	allocator<char>alloc;
};
ostream& operator<< (ostream& os, const String& s);
bool operator==(const String& s1, const String& s2);
bool operator!=(const String& s1, const String& s2);

string.cpp:

#include"string.h"

pair<char*, char*>String::alloc_n_copy(const char*b, const char*e)
{
	auto str = alloc.allocate(e - b);
	return { str,uninitialized_copy(b,e,str) };
}
void String::range_initializer(const char*b, const char*e)
{
	auto newstr = alloc_n_copy(b, e);
	elements = newstr.first;
	end = newstr.second;
}
String::String(const char*s)
{
	char* s1 = const_cast<char*>(s);
	while (*s1)
	{
		++s1;
	}
	range_initializer(s, ++s1);
}
String::String(const String&rhs)
{
	range_initializer(rhs.elements, rhs.end);
	cout << "copy constructor" << endl;
}
void String::free()
{
	if (elements)
	{
		for_each(elements, end, [this](char& c) {alloc.destroy(&c); });
		alloc.deallocate(elements, end - elements);
	}
}
String::~String()
{
	free();
}
String& String::operator=(const String&rhs)
{
	auto newstr = alloc_n_copy(rhs.elements, rhs.end);
	free();
	elements = newstr.first;
	end = newstr.second;
	cout << "copy assignment" << endl;
	return *this;
}
String::String(String&&s)noexcept:elements(s.elements),end(s.end)
{
	s.elements = s.end = nullptr;
}
String& String::operator=(String&&s)noexcept
{
	if (this != &s)
	{
		free();
		elements = s.elements;
		end = s.end;
		s.elements = s.end = nullptr;
	}
	return *this;
}
ostream& operator<< (ostream& os, const String& s)
{
	char* c = const_cast<char*>(s.c_str());
	while (*c)
	{
		os << *c++;
	}
	return os;
}
bool operator==(const String& s1, const String& s2)
{
	return s1.size() == s2.size() && equal(s1.elements, s1.end, s2.elements);
}
bool operator!=(const String& s1, const String& s2)
{
	return !(s1 == s2);
}

14.18:

string.h:

#pragma once
#include<iostream>
using namespace std;
#include<algorithm>

class String
{
	friend ostream& operator<< (ostream& os, const String& s);
	friend bool operator==(const String& s1, const String& s2);
	friend bool operator!=(const String& s1, const String& s2);
	friend bool operator< (const String& s1, const String& s2);
	friend bool operator<= (const String& s1, const String& s2);
	friend bool operator> (const String& s1, const String& s2);
	friend bool operator>= (const String& s1, const String& s2);
public:
	String():String("") {}
	String(const String&);
	String(const char*);
	String& operator=(const String&);
	String(String&&)noexcept;
	String& operator=(String&&)noexcept;
	~String();
	const char* c_str() const { return elements; }
	size_t size() const { return end - elements; }
	size_t length() const { return end - elements - 1; }

private:
	pair<char*, char*>alloc_n_copy(const char*, const char*);
	void range_initializer(const char*, const char*);
	void free();
	char* elements;
	char* end;
	allocator<char>alloc;
};
ostream& operator<< (ostream& os, const String& s);
bool operator==(const String& s1, const String& s2);
bool operator!=(const String& s1, const String& s2);
bool operator< (const String& s1, const String& s2);
bool operator<= (const String& s1, const String& s2);
bool operator> (const String& s1, const String& s2);
bool operator>= (const String& s1, const String& s2);

string.cpp:

#include"string.h"

pair<char*, char*>String::alloc_n_copy(const char*b, const char*e)
{
	auto str = alloc.allocate(e - b);
	return { str,uninitialized_copy(b,e,str) };
}
void String::range_initializer(const char*b, const char*e)
{
	auto newstr = alloc_n_copy(b, e);
	elements = newstr.first;
	end = newstr.second;
}
String::String(const char*s)
{
	char* s1 = const_cast<char*>(s);
	while (*s1)
	{
		++s1;
	}
	range_initializer(s, ++s1);
}
String::String(const String&rhs)
{
	range_initializer(rhs.elements, rhs.end);
	cout << "copy constructor" << endl;
}
void String::free()
{
	if (elements)
	{
		for_each(elements, end, [this](char& c) {alloc.destroy(&c); });
		alloc.deallocate(elements, end - elements);
	}
}
String::~String()
{
	free();
}
String& String::operator=(const String&rhs)
{
	auto newstr = alloc_n_copy(rhs.elements, rhs.end);
	free();
	elements = newstr.first;
	end = newstr.second;
	cout << "copy assignment" << endl;
	return *this;
}
String::String(String&&s)noexcept:elements(s.elements),end(s.end)
{
	s.elements = s.end = nullptr;
}
String& String::operator=(String&&s)noexcept
{
	if (this != &s)
	{
		free();
		elements = s.elements;
		end = s.end;
		s.elements = s.end = nullptr;
	}
	return *this;
}
ostream& operator<< (ostream& os, const String& s)
{
	char* c = const_cast<char*>(s.c_str());
	while (*c)
	{
		os << *c++;
	}
	return os;
}
bool operator==(const String& s1, const String& s2)
{
	return s1.size() == s2.size() && equal(s1.elements, s1.end, s2.elements);
}
bool operator!=(const String& s1, const String& s2)
{
	return !(s1 == s2);
}
bool operator< (const String& s1, const String& s2)
{
	return lexicographical_compare(s1.elements, s1.end, s2.elements, s2.end);
}
bool operator<= (const String& s1, const String& s2)
{
	return !(s2 < s1);
}
bool operator> (const String& s1, const String& s2)
{
	return s2 < s1;
}
bool operator>= (const String& s1, const String& s2)
{
	return !(s1 < s2);
}

14.22:

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
class Sales_data
{
	friend istream& read(istream& is, Sales_data& item);
	friend ostream& print(ostream& os, const Sales_data& item);
	friend Sales_data add(const Sales_data& s1, const Sales_data& s2);
	friend istream& operator>>(istream& , Sales_data&);
	friend ostream& operator<<(ostream& , const Sales_data&);
	friend Sales_data operator+(const Sales_data& s1, const Sales_data& s2);
	friend Sales_data operator-(const Sales_data& s1, const Sales_data& s2);
public:
	Sales_data() = default;
	Sales_data(const string& s) :bookNo(s) {};
	Sales_data(const string& s, unsigned n, double p) :bookNo(s), unit_sold(n), revenue(n* p) {};
	Sales_data(istream& is) { read(cin, *this); }
	Sales_data& operator+=(const Sales_data& s);
	Sales_data& operator-=(const Sales_data& s);
	Sales_data& operator=(const string& s);

	Sales_data& combine(const Sales_data& rhs);
	string isbn()const
	{
		return this->bookNo;
	}
private:
	inline double avg_price()const;
	string bookNo;
	unsigned unit_sold = 0;
	double revenue = 0.0;
};
Sales_data& Sales_data::combine(const Sales_data& rhs)
{
	this->unit_sold += rhs.unit_sold;
	this->revenue += rhs.revenue;
	return *this;
}
Sales_data add(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp.combine(s2);
	return temp;
}
istream& read(istream& is, Sales_data& item)
{
	double price = 0;
	is >> item.bookNo >> item.unit_sold >> price;
	item.revenue = item.unit_sold * price;
	return is;
}
ostream& print(ostream& os, const Sales_data& item)
{
	os << item.bookNo << " " << item.unit_sold << " " << item.revenue;
	return os;
}
inline double Sales_data::avg_price()const
{
	return unit_sold ? revenue / unit_sold : 0;
}
istream& operator>>(istream& in, Sales_data& sd)
{
	double price = 0;
	in >> sd.bookNo >> sd.unit_sold >> price;
	if (in)
	{
		sd.revenue = sd.unit_sold * price;
	}
	else
	{
		sd = Sales_data();
	}
	return in;
}

ostream& operator<<(ostream& out, const Sales_data& item)
{
	out << item.bookNo << " " << item.unit_sold << " " << item.revenue << " " << item.avg_price();
	return out;
}
Sales_data operator+(const Sales_data& s1, const Sales_data & s2)
{
	Sales_data temp = s1;
	temp.unit_sold += s2.unit_sold;
	temp.revenue += s2.revenue;
	return temp;
}
Sales_data& Sales_data::operator+=(const Sales_data& s)
{
	this->unit_sold += s.unit_sold;
	this->revenue += s.revenue;
	return *this;
}
Sales_data operator-(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp -= s2;
	return temp;
}
Sales_data& Sales_data::operator-=(const Sales_data& s)
{
	this->unit_sold -= s.unit_sold;
	this->revenue -= s.revenue;
	return *this;
}
Sales_data& Sales_data::operator=(const string& s)
{
	*this = Sales_data(s);
	return *this;
}

14.27:

.h

#include "ex14_27_28_StrBlob.h"
#include <algorithm>

//==================================================================
//
//		StrBlob - operators
//
//==================================================================

bool operator==(const StrBlob &lhs, const StrBlob &rhs)
{
    return *lhs.data == *rhs.data;
}

bool operator!=(const StrBlob &lhs, const StrBlob &rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlob &lhs, const StrBlob &rhs)
{
    return std::lexicographical_compare(lhs.data->begin(), lhs.data->end(), rhs.data->begin(), rhs.data->end());
}

bool operator> (const StrBlob &lhs, const StrBlob &rhs)
{
    return rhs < lhs;
}

bool operator<=(const StrBlob &lhs, const StrBlob &rhs)
{
    return !(rhs < lhs);
}

bool operator>=(const StrBlob &lhs, const StrBlob &rhs)
{
    return !(lhs < rhs);
}

//================================================================
//
//		StrBlobPtr - operators
//
//================================================================

bool operator==(const StrBlobPtr &lhs, const StrBlobPtr &rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const StrBlobPtr &lhs, const StrBlobPtr &rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlobPtr &x, const StrBlobPtr &y)
{
    return x.curr < y.curr;
}

bool operator>(const StrBlobPtr &x, const StrBlobPtr &y)
{
    return x.curr > y.curr;
}

bool operator<=(const StrBlobPtr &x, const StrBlobPtr &y)
{
    return x.curr <= y.curr;
}

bool operator>=(const StrBlobPtr &x, const StrBlobPtr &y)
{
    return x.curr >= y.curr;
}

//================================================================
//
//		ConstStrBlobPtr - operators
//
//================================================================

bool operator==(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return !(lhs == rhs);
}

bool operator< (const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return lhs.curr < rhs.curr;
}

bool operator>(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return lhs.curr > rhs.curr;
}

bool operator<=(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return lhs.curr <= rhs.curr;
}

bool operator>=(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{
    return lhs.curr >= rhs.curr;
}

//==================================================================
//
//		copy assignment operator and move assignment operator.
//
//==================================================================

StrBlob& StrBlob::operator=(const StrBlob &lhs)
{
    data = make_shared<vector<string>>(*lhs.data);
    return *this;
}

StrBlob& StrBlob::operator=(StrBlob &&rhs) NOEXCEPT
{
    if (this != &rhs) {
        data = std::move(rhs.data);
        rhs.data = nullptr;
    }

    return *this;
}

//==================================================================
//
//		members
//
//==================================================================

StrBlobPtr StrBlob::begin()
{
    return StrBlobPtr(*this);
}

StrBlobPtr StrBlob::end()
{
    return StrBlobPtr(*this, data->size());
}

ConstStrBlobPtr StrBlob::cbegin() const
{
    return ConstStrBlobPtr(*this);
}

ConstStrBlobPtr StrBlob::cend() const
{
    return ConstStrBlobPtr(*this, data->size());
}

.cpp

#include "StrBlob.h"
#include <algorithm>

//==================================================================
//
//		StrBlob - operators
//
//==================================================================

bool operator==(const StrBlob& lhs, const StrBlob& rhs)
{
    return *lhs.data == *rhs.data;
}

bool operator!=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlob& lhs, const StrBlob& rhs)
{
    return std::lexicographical_compare(lhs.data->begin(), lhs.data->end(), rhs.data->begin(), rhs.data->end());
}

bool operator> (const StrBlob& lhs, const StrBlob& rhs)
{
    return rhs < lhs;
}

bool operator<=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(rhs < lhs);
}

bool operator>=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(lhs < rhs);
}

//================================================================
//
//		StrBlobPtr - operators
//
//================================================================

bool operator==(const StrBlobPtr& lhs, const StrBlobPtr& rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const StrBlobPtr& lhs, const StrBlobPtr& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr < y.curr;
}

bool operator>(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr > y.curr;
}

bool operator<=(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr <= y.curr;
}

bool operator>=(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr >= y.curr;
}

//================================================================
//
//		ConstStrBlobPtr - operators
//
//================================================================

bool operator==(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr < rhs.curr;
}

bool operator>(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr > rhs.curr;
}

bool operator<=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr <= rhs.curr;
}

bool operator>=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr >= rhs.curr;
}

//==================================================================
//
//		copy assignment operator and move assignment operator.
//
//==================================================================

StrBlob& StrBlob::operator=(const StrBlob& lhs)
{
    data = make_shared<vector<string>>(*lhs.data);
    return *this;
}

StrBlob& StrBlob::operator=(StrBlob&& rhs) NOEXCEPT
{
    if (this != &rhs) {
        data = std::move(rhs.data);
        rhs.data = nullptr;
    }

    return *this;
}

//==================================================================
//
//		members
//
//==================================================================

StrBlobPtr StrBlob::begin()
{
    return StrBlobPtr(*this);
}

StrBlobPtr StrBlob::end()
{
    return StrBlobPtr(*this, data->size());
}

ConstStrBlobPtr StrBlob::cbegin() const
{
    return ConstStrBlobPtr(*this);
}

ConstStrBlobPtr StrBlob::cend() const
{
    return ConstStrBlobPtr(*this, data->size());
}

14.30:

.h:

#ifndef CP5_STRBLOB_H_
#define CP5_STRBLOB_H_
using namespace std;
#include<iostream>
#include <vector>
#include <string>
#include <initializer_list>
#include <memory>
#include <exception>

#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endif

class StrBlobPtr;
class ConstStrBlobPtr;

//=================================================================================
//
//		StrBlob - custom vector<string>
//
//=================================================================================

class StrBlob {
    using size_type = vector<string>::size_type;
    friend class ConstStrBlobPtr;
    friend class StrBlobPtr;
    friend bool operator==(const StrBlob&, const StrBlob&);
    friend bool operator!=(const StrBlob&, const StrBlob&);
    friend bool operator< (const StrBlob&, const StrBlob&);
    friend bool operator> (const StrBlob&, const StrBlob&);
    friend bool operator<=(const StrBlob&, const StrBlob&);
    friend bool operator>=(const StrBlob&, const StrBlob&);

public:
    StrBlob() : data(make_shared<vector<string>>()) { }
    StrBlob(initializer_list<string> il) : data(make_shared<vector<string>>(il)) { }

    StrBlob(const StrBlob& sb) : data(make_shared<vector<string>>(*sb.data)) { }
    StrBlob& operator=(const StrBlob&);

    StrBlob(StrBlob&& rhs) NOEXCEPT : data(std::move(rhs.data)) { }
    StrBlob& operator=(StrBlob&&)NOEXCEPT;

    StrBlobPtr begin();
    StrBlobPtr end();

    ConstStrBlobPtr cbegin() const;
    ConstStrBlobPtr cend() const;

    string& operator[](size_t n);
    const string& operator[](size_t n) const;

    size_type size() const { return data->size(); }
    bool empty() const { return data->empty(); }

    void push_back(const string& t) { data->push_back(t); }
    void push_back(string&& s) { data->push_back(std::move(s)); }

    void pop_back();
    string& front();
    string& back();
    const string& front() const;
    const string& back() const;

private:
    void check(size_type, const string&) const;

    shared_ptr<vector<string>> data;
};

bool operator==(const StrBlob&, const StrBlob&);
bool operator!=(const StrBlob&, const StrBlob&);
bool operator< (const StrBlob&, const StrBlob&);
bool operator> (const StrBlob&, const StrBlob&);
bool operator<=(const StrBlob&, const StrBlob&);
bool operator>=(const StrBlob&, const StrBlob&);

inline void StrBlob::pop_back()
{
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}

inline string& StrBlob::front()
{
    check(0, "front on empty StrBlob");
    return data->front();
}

inline string& StrBlob::back()
{
    check(0, "back on empty StrBlob");
    return data->back();
}

inline const string& StrBlob::front() const
{
    check(0, "front on empty StrBlob");
    return data->front();
}

inline const string& StrBlob::back() const
{
    check(0, "back on empty StrBlob");
    return data->back();
}

inline void StrBlob::check(size_type i, const string& msg) const
{
    if (i >= data->size()) throw out_of_range(msg);
}

inline string& StrBlob::operator[](size_t n)
{
    check(n, "out of range");
    return data->at(n);
}

inline const string& StrBlob::operator[](size_t n) const
{
    check(n, "out of range");
    return data->at(n);
}

//=================================================================================
//
//		StrBlobPtr - custom iterator of StrBlob
//
//=================================================================================

class StrBlobPtr {
    friend bool operator==(const StrBlobPtr&, const StrBlobPtr&);
    friend bool operator!=(const StrBlobPtr&, const StrBlobPtr&);
    friend bool operator< (const StrBlobPtr&, const StrBlobPtr&);
    friend bool operator> (const StrBlobPtr&, const StrBlobPtr&);
    friend bool operator<=(const StrBlobPtr&, const StrBlobPtr&);
    friend bool operator>=(const StrBlobPtr&, const StrBlobPtr&);

public:
    StrBlobPtr() : curr(0) { }
    StrBlobPtr(StrBlob& s, size_t sz = 0) : wptr(s.data), curr(sz) { }

    string& deref() const;
    StrBlobPtr& operator++();
    StrBlobPtr& operator--();
    StrBlobPtr operator++(int);
    StrBlobPtr operator--(int);
    StrBlobPtr& operator+=(size_t);
    StrBlobPtr& operator-=(size_t);
    StrBlobPtr operator+(size_t) const;
    StrBlobPtr operator-(size_t) const;
    string& operator*() const;
    string* operator->() const;

    string& operator[](size_t n);
    const string& operator[](size_t n) const;

private:
    shared_ptr<vector<string>> check(size_t, const string&) const;

    std::weak_ptr<vector<string>> wptr;
    size_t curr;
};

bool operator==(const StrBlobPtr&, const StrBlobPtr&);
bool operator!=(const StrBlobPtr&, const StrBlobPtr&);
bool operator< (const StrBlobPtr&, const StrBlobPtr&);
bool operator> (const StrBlobPtr&, const StrBlobPtr&);
bool operator<=(const StrBlobPtr&, const StrBlobPtr&);
bool operator>=(const StrBlobPtr&, const StrBlobPtr&);

inline string& StrBlobPtr::deref() const
{
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
}

inline StrBlobPtr& StrBlobPtr::operator++()
{
    check(curr, "increment past end of StrBlobPtr");
    ++curr;
    return *this;
}

inline StrBlobPtr& StrBlobPtr::operator--()
{
    check(--curr, "decrement past begin of StrBlobPtr");
    return *this;
}

inline StrBlobPtr StrBlobPtr::operator++(int)
{
    StrBlobPtr ret = *this;
    ++* this;
    return ret;
}

inline StrBlobPtr StrBlobPtr::operator--(int)
{
    StrBlobPtr ret = *this;
    --* this;
    return ret;
}

inline StrBlobPtr& StrBlobPtr::operator+=(size_t n)
{
    curr += n;
    check(curr, "increment past end of StrBlobPtr");
    return *this;
}

inline StrBlobPtr& StrBlobPtr::operator-=(size_t n)
{
    curr -= n;
    check(curr, "increment past end of StrBlobPtr");
    return *this;
}

inline StrBlobPtr StrBlobPtr::operator+(size_t n) const
{
    StrBlobPtr ret = *this;
    ret += n;
    return ret;
}

inline StrBlobPtr StrBlobPtr::operator-(size_t n) const
{
    StrBlobPtr ret = *this;
    ret -= n;
    return ret;
}

inline shared_ptr<vector<string>> StrBlobPtr::check(size_t i, const string& msg) const
{
    auto ret = wptr.lock();
    if (!ret) throw std::runtime_error("unbound StrBlobPtr");
    if (i >= ret->size()) throw std::out_of_range(msg);
    return ret;
}

inline string& StrBlobPtr::operator[](size_t n)
{
    auto p = check(n, "dereference out of range.");
    return (*p)[n];
}

inline const string& StrBlobPtr::operator[](size_t n) const
{
    auto p = check(n, "dereference out of range.");
    return (*p)[n];
}
inline string& StrBlobPtr::operator*() const
{
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
}
inline string* StrBlobPtr::operator->() const
{
    return &this->operator*();
}

//=================================================================================
//
//		ConstStrBlobPtr - custom const_iterator of StrBlob
//
//=================================================================================

class ConstStrBlobPtr {
    friend bool operator==(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
    friend bool operator!=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
    friend bool operator< (const ConstStrBlobPtr&, const ConstStrBlobPtr&);
    friend bool operator> (const ConstStrBlobPtr&, const ConstStrBlobPtr&);
    friend bool operator<=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
    friend bool operator>=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);

public:
    ConstStrBlobPtr() : curr(0) { }
    ConstStrBlobPtr(const StrBlob& s, size_t sz = 0) : wptr(s.data), curr(sz) { }

    const string& deref() const;
    ConstStrBlobPtr& operator++();
    ConstStrBlobPtr& operator--();
    ConstStrBlobPtr operator++(int);
    ConstStrBlobPtr operator--(int);
    ConstStrBlobPtr& operator+=(size_t);
    ConstStrBlobPtr& operator-=(size_t);
    ConstStrBlobPtr operator+(size_t) const;
    ConstStrBlobPtr operator-(size_t) const;
    const string& operator*() const;
    const string* operator->() const;

    const string& operator[](size_t n) const;

private:
    std::shared_ptr<vector<string>> check(size_t, const string&) const;

    std::weak_ptr<vector<string>> wptr;
    size_t curr;
};

bool operator==(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator!=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator< (const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator> (const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator<=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator>=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);

inline const string& ConstStrBlobPtr::deref() const
{
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
}

inline ConstStrBlobPtr& ConstStrBlobPtr::operator++()
{
    check(curr, "increment past end of ConstStrBlobPtr");
    ++curr;
    return *this;
}

inline ConstStrBlobPtr& ConstStrBlobPtr::operator--()
{
    --curr;
    check(-1, "decrement past begin of ConstStrBlobPtr");
    return *this;
}

inline ConstStrBlobPtr ConstStrBlobPtr::operator++(int)
{
    ConstStrBlobPtr ret = *this;
    ++* this;
    return ret;
}

inline ConstStrBlobPtr ConstStrBlobPtr::operator--(int)
{
    ConstStrBlobPtr ret = *this;
    --* this;
    return ret;
}

inline ConstStrBlobPtr& ConstStrBlobPtr::operator+=(size_t n)
{
    curr += n;
    check(curr, "increment past end of ConstStrBlobPtr");
    return *this;
}

inline ConstStrBlobPtr& ConstStrBlobPtr::operator-=(size_t n)
{
    curr -= n;
    check(curr, "increment past end of ConstStrBlobPtr");
    return *this;
}

inline ConstStrBlobPtr ConstStrBlobPtr::operator+(size_t n) const
{
    ConstStrBlobPtr ret = *this;
    ret += n;
    return ret;
}

inline ConstStrBlobPtr ConstStrBlobPtr::operator-(size_t n) const
{
    ConstStrBlobPtr ret = *this;
    ret -= n;
    return ret;
}

inline std::shared_ptr<vector<string>> ConstStrBlobPtr::check(size_t i, const string& msg) const
{
    auto ret = wptr.lock();
    if (!ret) throw std::runtime_error("unbound StrBlobPtr");
    if (i >= ret->size()) throw std::out_of_range(msg);
    return ret;
}

inline const string& ConstStrBlobPtr::operator[](size_t n) const
{
    auto p = check(n, "dereference out of range.");
    return (*p)[n];
}
inline const string& ConstStrBlobPtr::operator*() const
{
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
}
inline const string* ConstStrBlobPtr::operator->() const
{
    return &this->operator*();
}

#endif

.cpp:

#include "StrBlob.h"
#include <algorithm>

//==================================================================
//
//		StrBlob - operators
//
//==================================================================

bool operator==(const StrBlob& lhs, const StrBlob& rhs)
{
    return *lhs.data == *rhs.data;
}

bool operator!=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlob& lhs, const StrBlob& rhs)
{
    return std::lexicographical_compare(lhs.data->begin(), lhs.data->end(), rhs.data->begin(), rhs.data->end());
}

bool operator> (const StrBlob& lhs, const StrBlob& rhs)
{
    return rhs < lhs;
}

bool operator<=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(rhs < lhs);
}

bool operator>=(const StrBlob& lhs, const StrBlob& rhs)
{
    return !(lhs < rhs);
}

//================================================================
//
//		StrBlobPtr - operators
//
//================================================================

bool operator==(const StrBlobPtr& lhs, const StrBlobPtr& rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const StrBlobPtr& lhs, const StrBlobPtr& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr < y.curr;
}

bool operator>(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr > y.curr;
}

bool operator<=(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr <= y.curr;
}

bool operator>=(const StrBlobPtr& x, const StrBlobPtr& y)
{
    return x.curr >= y.curr;
}

//================================================================
//
//		ConstStrBlobPtr - operators
//
//================================================================

bool operator==(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr == rhs.curr;
}

bool operator!=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return !(lhs == rhs);
}

bool operator< (const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr < rhs.curr;
}

bool operator>(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr > rhs.curr;
}

bool operator<=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr <= rhs.curr;
}

bool operator>=(const ConstStrBlobPtr& lhs, const ConstStrBlobPtr& rhs)
{
    return lhs.curr >= rhs.curr;
}

//==================================================================
//
//		copy assignment operator and move assignment operator.
//
//==================================================================

StrBlob& StrBlob::operator=(const StrBlob& lhs)
{
    data = make_shared<vector<string>>(*lhs.data);
    return *this;
}

StrBlob& StrBlob::operator=(StrBlob&& rhs) NOEXCEPT
{
    if (this != &rhs) {
        data = std::move(rhs.data);
        rhs.data = nullptr;
    }

    return *this;
}

//==================================================================
//
//		members
//
//==================================================================

StrBlobPtr StrBlob::begin()
{
    return StrBlobPtr(*this);
}

StrBlobPtr StrBlob::end()
{
    return StrBlobPtr(*this, data->size());
}

ConstStrBlobPtr StrBlob::cbegin() const
{
    return ConstStrBlobPtr(*this);
}

ConstStrBlobPtr StrBlob::cend() const
{
    return ConstStrBlobPtr(*this, data->size());
}

14.32:

.h

#ifndef STRBLOBPTR_POINTER_H
#define STRBLOBPTR_POINTER_H

class StrBlobPtr;

/**
 * @brief a class that holds a pointer to a StrBlobPtr.
 */
class StrBlobPtr_pointer
{
public:
    StrBlobPtr_pointer() = default;
    StrBlobPtr_pointer(StrBlobPtr* p) : pointer(p) { }

    StrBlobPtr& operator *() const;
    StrBlobPtr* operator->() const;

private:
    StrBlobPtr* pointer = nullptr;
};

#endif // STRBLOBPTR_POINTER_H

.cpp:

#include "ex14_32.h"
#include "ex14_30_StrBlob.h"
#include <iostream>

StrBlobPtr&
StrBlobPtr_pointer::operator *() const
{
    return *pointer;
}

StrBlobPtr*
StrBlobPtr_pointer::operator ->() const
{
    return pointer;
}

int main()
{
    StrBlob sb{ "hello", "world" };
    StrBlobPtr iter = sb.begin();
    StrBlobPtr_pointer p(&iter);
    std::cout << p->deref() << std::endl;
}

14.34:

#include<iostream>
using namespace std;

class if_then_else
{
public:
	int operator()(int a, int b, int c)
	{
		return (a ? b : c);
	}
};

int main()
{
	int a = 0, b = 1, c = 2;
	if_then_else f;
	cout << f(a, b, c) << endl;
}

14.35:

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

class PrintString
{
public:
	PrintString(istream&i =cin):is(i){}
	string operator()()
	{
		string str;
		getline(is, str);
		return is ? str : string();
	}

private:
	istream& is;
};

int main()
{
	PrintString getinput;
	cout << getinput() << endl;
}

14.36:

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

class PrintString
{
public:
	PrintString(istream&i =cin):is(i){}
	string operator()()
	{
		string str;
		getline(is, str);
		return is ? str : string();
	}

private:
	istream& is;
};

int main()
{
	PrintString getinput;
	vector<string>ves;
	for (string temp; !((temp = getinput()).empty()); ves.push_back(temp));
	for (auto m : ves) { cout << m << " "; }cout << endl;
	return 0;
}

14.37:

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
class test
{
public:
	test(int a):i(a){}
	bool operator()(const int& b)
	{
		return i == b;
	}

private:
	int i;
};

int main()
{
	test t(1);
	vector<int>vec = { 1,2,3,4,5,6,7,9 };
	replace_if(vec.begin(), vec.end(), t, 2);
	for (int i : vec) cout << i << " ";
	cout << endl;
	return 0;
}

10.39：

哈哈哈

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
class SizeComp
{
public:
	SizeComp(size_t i):sz(i),lower(0),upper(0) {}
	SizeComp(size_t a,size_t b) :sz(0), lower(a), upper(b) {}
	SizeComp(size_t a, size_t b,size_t c) :sz(c), lower(a), upper(b) {}
	bool operator()(const string& s)const
	{
		if (sz==0)
		{
            return s.size() >= lower && s.size() <= upper;
		}
		else if(lower ==0)
		{
			return 	s.size() == sz;
		}
		else
		{
			return s.size() >= upper;
		}
	}

private:
	size_t sz;
	size_t lower;
	size_t upper;
};

int main()
{
	vector<string>ves = { "sdafsdf","asdfasdf","as","wre","qwer","a","sdfsdfsdfasdfsdf"};
	auto num = count_if(ves.begin(), ves.end(), SizeComp(2));
	cout << num << endl;
	num = count_if(ves.begin(), ves.end(), SizeComp(1,9));
	cout << num << endl;
	num = count_if(ves.begin(), ves.end(), SizeComp(10,10,10));
	cout << num << endl;
	return 0;
}

14.40：

class ShorterString {
public:
    bool operator()(string const& s1, string const& s2) const { return s1.size() < s2.size(); }
};

class BiggerEqual {
    size_t sz_;
public:
    BiggerEqual(size_t sz) : sz_(sz) { }
    bool operator()(string const& s) { return s.size() >= sz_; }
};

class Print {
public:
    void operator()(string const& s) { cout << s << " "; }
};

14.42：

	count_if(vec.begin(), vec.end(), bind(greater<int>(), _1, 1024));
	find_if(vec.begin(), vec.end(), bind(not_equal_to<string>(), _1, "ppoh"));
	transform(vec.begin(), vec.end(), vec.begin(), bind(multiplies<int>(), _1, 2));

14.43：

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
using placeholders::_1;
int main()
{
	vector<int>vec = { 2,4,8 };
	int i = 0;
	int input;
	cin >> input;
	bool b = any_of(vec.begin(), vec.end(), bind(modulus<int>(), input, _1));
	if (b)
		cout << "not!" << endl;
	else
		cout << "yes!" << endl;
	return 0;
}

14.44:

#include<iostream>
using namespace std;
#include<functional>
#include<map>
//普通函数
int add(int a, int b)
{
	return a + b;
}
//lambda
auto mod = [](int a, int b) {return a % b; };
//函数对象类
class divide
{
public:
	int operator()(int a, int b)
	{
		return a / b;
	}
};

int main()
{
	int(*p1)(int, int) = add;
	map<string, function<int(int, int)>>binops = {
		{"+",p1},
		{"-",minus<int>()},
		{"/",divide()},
		{"*",[](int i,int j) {return i * j; }},
		{"%",mod}
	};
	while (cout << "Pls enter as: num operator num :\n", true)
	{
		int lhs, rhs;string op;
		cin >> lhs >> op >> rhs;
		cout << binops[op](lhs, rhs) << endl;
	}
	return 0;
}

14.45:

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
class Sales_data
{
	friend istream& read(istream& is, Sales_data& item);
	friend ostream& print(ostream& os, const Sales_data& item);
	friend Sales_data add(const Sales_data& s1, const Sales_data& s2);
	friend istream& operator>>(istream& , Sales_data&);
	friend ostream& operator<<(ostream& , const Sales_data&);
	friend Sales_data operator+(const Sales_data& s1, const Sales_data& s2);
	friend Sales_data operator-(const Sales_data& s1, const Sales_data& s2);
public:
	Sales_data() = default;
	Sales_data(const string& s) :bookNo(s) {};
	Sales_data(const string& s, unsigned n, double p) :bookNo(s), unit_sold(n), revenue(n* p) {};
	Sales_data(istream& is) { read(cin, *this); }
	Sales_data& operator+=(const Sales_data& s);
	Sales_data& operator-=(const Sales_data& s);
	Sales_data& operator=(const string& s);
	explicit operator string() const { return this->bookNo; }
	explicit operator double() const { return this->avg_price(); }

	Sales_data& combine(const Sales_data& rhs);
	string isbn()const
	{
		return this->bookNo;
	}
private:
	inline double avg_price()const;
	string bookNo;
	unsigned unit_sold = 0;
	double revenue = 0.0;
};
Sales_data& Sales_data::combine(const Sales_data& rhs)
{
	this->unit_sold += rhs.unit_sold;
	this->revenue += rhs.revenue;
	return *this;
}
Sales_data add(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp.combine(s2);
	return temp;
}
istream& read(istream& is, Sales_data& item)
{
	double price = 0;
	is >> item.bookNo >> item.unit_sold >> price;
	item.revenue = item.unit_sold * price;
	return is;
}
ostream& print(ostream& os, const Sales_data& item)
{
	os << item.bookNo << " " << item.unit_sold << " " << item.revenue;
	return os;
}
inline double Sales_data::avg_price()const
{
	return unit_sold ? revenue / unit_sold : 0;
}
istream& operator>>(istream& in, Sales_data& sd)
{
	double price = 0;
	in >> sd.bookNo >> sd.unit_sold >> price;
	if (in)
	{
		sd.revenue = sd.unit_sold * price;
	}
	else
	{
		sd = Sales_data();
	}
	return in;
}

ostream& operator<<(ostream& out, const Sales_data& item)
{
	out << item.bookNo << " " << item.unit_sold << " " << item.revenue << " " << item.avg_price();
	return out;
}
Sales_data operator+(const Sales_data& s1, const Sales_data & s2)
{
	Sales_data temp = s1;
	temp.unit_sold += s2.unit_sold;
	temp.revenue += s2.revenue;
	return temp;
}
Sales_data& Sales_data::operator+=(const Sales_data& s)
{
	this->unit_sold += s.unit_sold;
	this->revenue += s.revenue;
	return *this;
}
Sales_data operator-(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data temp = s1;
	temp -= s2;
	return temp;
}
Sales_data& Sales_data::operator-=(const Sales_data& s)
{
	this->unit_sold -= s.unit_sold;
	this->revenue -= s.revenue;
	return *this;
}
Sales_data& Sales_data::operator=(const string& s)
{
	*this = Sales_data(s);
	return *this;
}

sstateo
关注
c++ primer 第14章 习题解答
digitalkee的博客
11-27 1373
14.1节 14.1答 不同点： 重载操作符必须具有至少一个class或枚举类型的操作数。 重载操作符不保证操作数的求值顺序，例如对&&和| | 的重载版本不再具有“短路求值”的特征，两个操作数，两个操作数都要进行求值，而且不规定操作数的求值顺序。 相同点： 对于优先级和结合性及操作数的数目都不变。 14.2 答： 文件sales_data.cc #include <iostream> #include <string> #i...
C++Primer第五版——习题答案+详解(完整版)
热门推荐
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++ Primer(第五版) 14.1--14.2.2节练习
wlli1985的博客
06-07 342
14.l 不同点：重载操作符必须至少有一个class或枚举类型的操作数；重载操作符不保证操作数的求值顺序； 相同点：优先级和结合性及操作数的数目不变。 14.2 Sales_data的输入，输出，加法和复合运算符： std::ostream &operator<<(s...
C++ Primer(第五版) 14.6--14.7节练习
wlli1985的博客
06-10 279
14.27 /* 前置递增 */ StrBlobPtr& StrBlobPtr::operator++() { check(curr, "increment past end of StrBlobPtr"); ++curr; return *this; } /* 前置递减 */ StrBlobPtr& StrBlobPtr::operator--() { --c...
C++primer第14章习题解答
宝剑锋从磨砺出 梅花香自苦寒来
04-19 5890
练习14.1：在什么情况下重载的运算符与内置运算符有所区别？在什么情况下重载的运算符又与内置运算符一样？ 不同点： 重载运算符必须具有至少一个class或枚举类型的操作数。 重载运算符不保证操作数的求值顺序，例如对&&和||的重载版本不再具有“短路求值”的特性，两个操作数都要求值，而且不规定操作数的求值顺序。 相同点： 对于优先级和结合性级操作数的数目都不变。 练习14.2：为
C++ 拷贝构造函数与赋值函数
weixin_34163553的博客
08-26 92
C++的拷贝函数和赋值函数既有联系又有区别，不细究的话很容易搞混，遂以小例示之如下，权作解惑之用// test.cpp#include <iostream>#include <stdlib.h>#include <algorithm>using namespace std; class Book{public: Book(const char *name, ...
C++Primer第五版——习题答案详解
Z's Palace
11-17 9795
C++Primer第五版——习题答案+详解(完整版) 原创 2016年12月21日 16:11:30 标签： C++ / 习题答案 / 大全 / 第五版 / primer / 30065 C++Primer 第五版习题答案详解 发表评论 HTML/XML objective-c Delp
C++ Primer 第五版 ——《第十五章 》面向对象程序设计 （多态与继承）学习笔记
TAOTAO
02-16 1593
目录 OPP：概述 定义基类 定义派生类 派生类中的虚函数 、override 关键字（530P） 派生类到基类的类型转换 （530P） 派生类的构造函数 （531P） 在派生类中使用继承其基类的成员 （531P） 继承与静态成员 （ 532P ） 派生类的声明需要注意的地方 （532P） 被用作基类的类需要注意的地方 （533P） 通过 final 来 禁止类被继承 类型...
C++Primer 第五版 ——《第六章》 函数
TAOTAO
10-30 1189
目录 实参是形参的初始值，但是并没有规定实参对形参的求值顺序 （183P） 函数的形参列表 函数的返回类型不能是数组或函数类型， 但可以是指向数组或函数的指针 （184P） 局部以及全局变量的 作用域 （184P） 函数只能定义一次，但可以声明多次 ( 186P) 含有函数声明的头文件应该被包含到定义函数的源文件中( 186P) 分离式编译 （186P） 指针作为形参（187P...
C++ Primer Plus学习（十四）——友元、异常和其他
weixin_41480034的博客
04-23 459
友元、异常和其他友元友元类友元成员函数其他友元关系共同的友元嵌套类异常RTTI类型转换运算符 友元 友元类 友元成员函数 其他友元关系 共同的友元 嵌套类 异常 RTTI 类型转换运算符
《C++ Primer》第14章 14.3节习题答案
chenyijun的专栏
10-17 417
《C++ Primer》第14章 操作重载与类型转换 14.3节 算术和关系运算符 习题答案 练习14.13：你认为Sales_data类还应该支持哪些其他算术运算符（参见表4.1,第124页）？如果有的话，请给出它们的定义。 ...
c++ primer 第十四章习题
无所知的博客
10-04 1500
c++ primer 第十三章习题 练习14.2 ostream&amp;amp;amp; operator&amp;amp;lt;&amp;amp;lt;(std::ostream&amp;amp;amp; os, const Sales_data&amp;amp;amp; item){ os &amp;amp;lt;&amp;amp;lt; item.isbn() &amp;amp;lt;&amp;amp;lt; &
C++ primer 14章习题答案
digitalkee的博客
10-01 408
14.1节 练习14.1 相同点：对于优先级和结合型以及操作数的数目都不变。 不同点：重载操作符必须具有至少一个class或枚举类型的操作数。 14.2
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1714
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
数组综合应用（下标计数）C++
最新发布
hjxxlsx的博客
10-08 755
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 251
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1494
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
C++：图的最短路径问题
han2205277149的博客
10-04 1087
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值