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

最新推荐文章于 2024-08-09 13:38:55 发布

sstateo

最新推荐文章于 2024-08-09 13:38:55 发布

阅读量864

点赞数

文章标签： c++ 蓝桥杯开发语言

本文链接：https://blog.csdn.net/sstateo/article/details/123852836

版权

17.1：

#include<iostream>
using namespace std;
#include<tuple>
int main()
{
	tuple<int, int, int> t(10,20,30);
	cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
	return 0;
}

17.2：

#include<iostream>
using namespace std;
#include<tuple>
#include<vector>
int main()
{
	tuple<string, vector<string>, pair<string, int>> t{ "asd",{"asd","asdd","asdad"},{"asdds",10} };
	cout << get<0>(t) << " " << get<1>(t).at(0) << " " << get<2>(t).first << endl;
	return 0;
}

17.4：

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
#include<vector>
#include<algorithm>
#include<tuple>
#include<numeric>
template<class T>class std::hash;
class Sales_data
{
	friend class std::hash<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);
	friend bool operator==(const Sales_data& lhs, const Sales_data& rhs);
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;
}
bool operator==(const Sales_data& lhs, const Sales_data& rhs)
{
	return lhs.isbn() == rhs.isbn() && lhs.revenue == rhs.revenue && lhs.unit_sold == rhs.unit_sold;
}
bool operator!=(const Sales_data& lhs, const Sales_data& rhs)
{
	return !(lhs == rhs);
}
namespace std
{
	template<>
	struct hash<Sales_data>
	{
		typedef size_t result_type;
		typedef Sales_data argument_type;
		size_t operator() (const Sales_data& s)const;
	};
	size_t hash<Sales_data>::operator() (const Sales_data& s)const
	{
		return hash<string>()(s.bookNo) ^
			hash<unsigned>()(s.unit_sold) ^
			hash<double>()(s.revenue);
	}
}
bool compareIsbn(const Sales_data& lhs, const Sales_data& rhs)
{
	return lhs.isbn() < rhs.isbn();
}

typedef tuple<vector<Sales_data>::size_type,
	vector<Sales_data>::const_iterator,
	vector<Sales_data>::const_iterator> matches;

vector<matches> findBook(const vector<vector<Sales_data>>& files, const string& s)
{
	vector<matches> ret;
	for (auto it = files.cbegin(); it != files.cend(); ++it)
	{
		auto found = equal_range(it->cbegin(), it->cend(), s, compareIsbn);
		if (found.first != found.second)
		{
			ret.push_back(make_tuple(it - files.cbegin(), found.first, found.second));
		}
	}
	return ret;
}
void reportResults(istream& in, ostream& os,
	const vector<vector<Sales_data>>& files)
{
	string s;
	while (cin >> s)
	{
		auto trans = findBook(files, s);
		if (trans.empty())
		{
			os << s << " not found" << endl;
			continue;
		}
		for (const auto& store : trans)
		{
			os << "store " << get<0>(store) << " sales: "
				<< accumulate(get<1>(store), get<2>(store),
					Sales_data(s))
				<< endl;
		}
	}
}

17.5：

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<fstream>
#include<vector>
#include<algorithm>
#include<tuple>
#include<numeric>
template<class T>class std::hash;
class Sales_data
{
	friend class std::hash<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);
	friend bool operator==(const Sales_data& lhs, const Sales_data& rhs);
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;
}
bool operator==(const Sales_data& lhs, const Sales_data& rhs)
{
	return lhs.isbn() == rhs.isbn() && lhs.revenue == rhs.revenue && lhs.unit_sold == rhs.unit_sold;
}
bool operator!=(const Sales_data& lhs, const Sales_data& rhs)
{
	return !(lhs == rhs);
}
namespace std
{
	template<>
	struct hash<Sales_data>
	{
		typedef size_t result_type;
		typedef Sales_data argument_type;
		size_t operator() (const Sales_data& s)const;
	};
	size_t hash<Sales_data>::operator() (const Sales_data& s)const
	{
		return hash<string>()(s.bookNo) ^
			hash<unsigned>()(s.unit_sold) ^
			hash<double>()(s.revenue);
	}
}
bool compareIsbn(const Sales_data& lhs, const Sales_data& rhs)
{
	return lhs.isbn() < rhs.isbn();
}

typedef pair<vector<Sales_data>::size_type,
	pair<vector<Sales_data>::const_iterator,
	vector<Sales_data>::const_iterator>> matches;

vector<matches> findBook(const vector<vector<Sales_data>>& files, const string& s)
{
	vector<matches> ret;
	for (auto it = files.cbegin(); it != files.cend(); ++it)
	{
		auto found = equal_range(it->cbegin(), it->cend(), s, compareIsbn);
		if (found.first != found.second)
		{
			ret.push_back(make_pair(it - files.cbegin(), make_pair(found.first, found.second)));
		}
	}
	return ret;
}
void reportResults(istream& in, ostream& os,
	const vector<vector<Sales_data>>& files)
{
	string s;
	while (cin >> s)
	{
		auto trans = findBook(files, s);
		if (trans.empty())
		{
			os << s << " not found" << endl;
			continue;
		}
		for (const auto& store : trans)
		{
			os << "store " << store.first << " sales: "
				<< accumulate(store.second.first, store.second.second,
					Sales_data(s))
				<< endl;
		}
	}
}

17.10：

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

int main()
{
	vector<int>vec{ 1,2,3,5,8,13,21 };
	bitset<32> bits;
	for (auto v : vec)
	{
		bits.set(v, 1);
	}
	cout << bits << endl;
	return 0;
}

7.11：

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

void changeValue(bitset<10>& b, size_t i, bool value)
{
	b.set(i, value);
}

int main()
{
	bitset<10> bits;
	changeValue(bits, 1, true);
	changeValue(bits, 2, true);
	cout << bits << endl;
	return 0;
}

17.15：

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

int main()
{
	string pattern("[^c]ei");
	pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*";
	regex r(pattern);
	string test;
	while (cin >> test)
	{
		if (regex_search(test, r))
		{
			cout << "符合要求" << endl;
		}
		else
		{
			cout << "不符合" << endl;
		}
	}
	return 0;
}

17.24：

#include<iostream>
using namespace std;
#include<regex>
using std::regex_constants::format_no_copy;
int main()
{

	string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
	regex r(phone);
	smatch m;
	string number = "(908) 555-1800";
	string fmt("$2.$5.$7");
	
	
	cout << regex_replace(number, r, fmt,format_no_copy) << endl;
	return 0;
}

17.28：

#include<iostream>
using namespace std;
#include<random>
int main()
{
	uniform_int_distribution<unsigned> u(0, 9);
	default_random_engine e;
	for (size_t i = 0; i < 10; ++i)
	{
		cout << u(e) << " ";
	}cout << endl;
	return 0;
}

sstateo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ primer习题记录——第十七章

17.1：#include<iostream>using namespace std;#include<tuple>int main(){ tuple<int, int, int> t(10,20,30); cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl; r..
复制链接

扫一扫