c++primer第五版第十六章练习

最新推荐文章于 2022-09-26 19:29:17 发布
最新推荐文章于 2022-09-26 19:29:17 发布
阅读量4.7k 收藏 2
点赞数
分类专栏： c++primer第五版练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nonororo/article/details/50536832
版权

16.1

根据模板参数的类型实例化出一个该类型的函数


16.2

#include <iostream>
#include <string>
#include <functional> //less
//#include "../../7.21/7.21/标头.h"
template<typename T>
int compare(const T &a, const T &b) {
	if (std::less<T>()(a, b))return 1;
	if (std::less<T>()(b, a))return -1;
	return 0;
}

int main()
{
	using namespace std;
	string a, b;
	//Sales_data b1("a"), b2("b");
	cin >> a >> b;
	if (compare(a, b) > 0)cout << a << "<" << b << endl;
	if (compare(a, b) < 0)cout << a << ">" << b << endl;
	if (!compare(a, b))cout << a << "=" << b << endl;
	//cout << compare(b1, b2);
	system("pause");
	return 0;
}

16.3

错误：Sales_data类型未定义运算符"<"


16.4

#include <iostream>
#include <vector>
#include <list>
#include <string>
template<typename Iterator, typename Value>
auto find(Iterator first, Iterator last, Value const& value)
{
	for (; first != last && *first != value; ++first);
	return first;
}
int main()
{
	std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	auto is_in_vector = v.cend() != ::find(v.cbegin(), v.cend(), 8);
	std::cout << (is_in_vector ? "找到\n": "没找到\n");

	std::list<std::string> l = { "aa", "bb", "cc", "dd", "ee", "ff", "gg" };
	auto is_in_list = l.cend() != ::find(l.cbegin(), l.cend(), "ab");
	std::cout << (is_in_list ? "找到\n" : "没找到\n");
	system("pause");
	return 0;
}

16.5

#include <iostream>
//template<typename T>
//void prin(const T &a)
//{
//	auto b = std::begin(a), e = std::end(a);
//	for (; b != e; ++b)
//		std::cout << *b << " ";
//}
//int main()
//{
//	using namespace std;
//	int a[] = { 1,2,3,4,5,6,9,8,7 };
//	string str = "primer 5";
//	prin(a);
//	prin(str);
//	system("pause");
//	return 0;
//}

template<class T, unsigned N>
void prin(T(&ar)[N])
{
	for (int i = 0; i < N; ++i)
		std::cout << ar[i];
}
int main()
{
	using namespace std;
	int ar[9] = { 4,0,8,6,8,6,4,7,7 };
	char str[] = "helloworld!";
	prin(ar);
	prin(str);
	prin("c++ primer");
	system("pause");
	return 0;
}

16.6 

#include <iostream>

template<typename T>
void print(const T &ar) {
	auto beg = ::begin(ar), end = ::end(ar);
	while (beg != end) {
		std::cout << *beg++ << " ";
	}
}
template<class T>
auto begin(const T &ar)
{
	return ar;
}
template<class T>
auto end(const T &ar)
{
	return ar + (sizeof ar) / sizeof(*ar);	//整个数组的大小除以单个元素的大小得到数量,指向数组之后
}
int main()
{
	using namespace std;
	int l[] = { 2,0,1,6,0,1,0,6 };
	print("c++ primer");
	print(l);
	system("pause");
	return 0;
}

16.7 

#include <iostream>
template<class T>
constexpr size_t sizear(const T &ar) {
	return sizeof ar;
}
int main()
{
	int ar[] = { 1,2,3,4,5,6,7,8 };
	int *p = ar;
	std::cout << sizear(ar) << std::endl;
	system("pause");
	return 0;
}

16.8

因为所有的标准库容器都有提供==与!=的运算符，而不一定有提供<运算符，所以使用!=能在所有的标准库容器上工作


16.9

函数模板就是一个公式，可以用来生成特定类型的函数版本。


16.10

生成一个特定类型的类，该类中特定类型被替换


16.11

//Blob.h
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
#include <memory>	//shared_ptr
template<typename T> class Blob;
template<typename T> class BlobPtr;
template<typename T> bool operator==(const Blob<T>&, const Blob<T>&);
template<typename T>
class Blob
{
public:
	friend class BlobPtr<T>;
	friend bool operator==<T>(const Blob &l, const Blob &r);
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type;	//把size_type视为类型名,忽略vector里同名的(如果有)静态变量
	Blob();
	Blob(std::initializer_list<T> il);

	size_type size()const {						//返回元素数量
		return data->size();
	}
	bool empty()const {							//是否为空
		return data->empty();
	}
	void push_back(const T &t) {				//添加元素到末尾
		data->push_back(t);
	}
	void push_back(T &&t) {
		data->push_back(std::move(t));
	}
	void pop_back();							//弹出末尾元素
	T &back();									//返回末尾元素的引用
	T &operator[](size_type i);					//返回第i个元素的引用
private:
	std::shared_ptr<std::vector<T>> data;
	void check(size_type i, const std::string &msg)const;
};

template<typename T>
void Blob<T>::check(size_type i, const std::string &msg)const {
	if (i >= data->size())
		throw std::out_of_range(msg);
}
template<typename T>
T &Blob<T>::back() {
	check(0, "back on empty Blob");
	return data->back();
}
template<typename T>
T &Blob<T>::operator[](size_type i) {
	check(i, "subscript out range");
	return (*data)[i];
}
template<typename T>
void Blob<T>::pop_back() {
	check(0, "pop_back on empty Blob");
	data->pop_back();
}
template<typename T>
Blob<T>::Blob():data(std::make_shared<std::vector<T>>()){
}
template<typename T>
Blob<T>::Blob(std::initializer_list<T> il) : data(std::make_shared<std::vector<T>> (il)) {
}

template<typename T>
bool operator==(const Blob<T> &l, const Blob<T> &r) {
	if (l.data != r.data)
		return false;
	return true;
}


//BlobPtr.h
#pragma once
#include "Blob.h"
template<typename T>
class BlobPtr {
public:
	BlobPtr();
	BlobPtr(Blob<T> &a, size_t sz = 0);
	T &operator*()const;
	BlobPtr &operator++();
	BlobPtr &operator--();
private:
	std::shared_ptr<std::vector<T>> check(std::size_t i, const std::string &s)const;
	std::weak_ptr<std::vector<T>> wptr;
	std::size_t curr;
};
template<typename T>
BlobPtr<T>::BlobPtr() :curr(0) {}

template<typename T>
BlobPtr<T>::BlobPtr(Blob<T> &a, size_t sz /* = 0 */) : wptr(a.data), curr(sz) {}

template<typename T>
T &BlobPtr<T>::operator*()const {
	auto p = check(curr, "dereference past end");
	return (*p)[curr];
}

template<typename T>
BlobPtr<T> &BlobPtr<T>::operator++() {
	++curr;
	check(curr, "++obj error");
	return *this;
}

template<typename T>
BlobPtr<T> &BlobPtr<T>::operator--() {
	--curr;
	if (curr < 0)
		throw std::out_of_range("--obj error");
	return *this;
}

template<typename T>
std::shared_ptr<std::vector<T>> BlobPtr<T>::check(std::size_t i, const std::string &s)const {
	auto ret = wptr.lock();									//确认未被释放内存
	if (!ret)
		throw std::out_of_range("unbound BlobPtr");
	if (i >= ret->size())
		throw std::out_of_range(s);
	return ret;
}

16.13

1 VS 1

让不同类型的类模板相等无意义


16.14，16.15

#pragma once
#include <string>
#include <iostream>
struct xyc {
	int x=0;
	int y=0;
	char c=' ';
};
template<unsigned N,unsigned M>
class Screen
{
	unsigned cursor = 0;
	unsigned  width = N, height = M;
	std::string contents;
public:
	Screen() = default;
	Screen(char c) :contents(N*M, c) {}
	char get()const { return contents[cursor]; }
	Screen set(xyc c) {
		cursor = --c.x*width + --c.y;
		contents[cursor] = c.c;
		return *this;
	}
	template<unsigned NN,unsigned MM>
	friend std::ostream &operator<<(std::ostream &os, const Screen<NN, MM> &s);
	template<unsigned NN, unsigned MM>
	friend std::istream &operator>>(std::istream &is, Screen<NN, MM> &s);
};

template<unsigned NN, unsigned MM>
std::ostream &operator<<(std::ostream &os, const Screen<NN, MM> &s)
{
	for (unsigned i = 0; i < s.width; ++i)
	{
		for (unsigned j = 0; j < s.height; ++j)
			putchar(s.contents[i*s.width + j]);
		putchar('\n');
	}
	return os;
}
template<unsigned NN, unsigned MM>
std::istream &operator>>(std::istream &is, Screen<NN, MM> &s)
{
	xyc c;
	is >> c;
	s.set(c);
	return is;
}
#include "标头.h"
std::istream &operator>>(std::istream &is, xyc &c) {
	is >> c.x;
	is >> c.y;
	is >> c.c;
	return is;
}
int main()
{
	using namespace std;
	Screen<6, 6> scr('-');
	cout << scr;
	cin >> scr;
	cout << scr;
	system("pause");
	return 0;
}


16.16

#pragma once
#include <iostream>
#include <string>
#include <memory>	//allocator
#include <utility>	//move
#include <initializer_list>
#include <algorithm>	//for_each
template<class T>
class StrVec
{
	std::allocator<T> alloc;//为所有StrVec对象分配内存用
	void chk_n_alloc()		//如果剩余空间为0就分配新空间
	{
		if (size() == capacity())
			reallocate();
	}
	std::pair<T *, T *> alloc_n_copy(const T *b, const T *e);//创建一个内容为b到e之间的元素的对象，并返回这个对象的一对头尾指针
	void free();//释放所有alloc分配的所有内存
	void reallocate();//移动当前对象的元素到2倍对象大小的新对象里
	T *elements;
	T *first_free;
	T *cap;
public:
	StrVec() :elements(nullptr), first_free(nullptr), cap(nullptr) {}
	StrVec(std::initializer_list<T> il);
	StrVec(const StrVec &s);
	StrVec(StrVec &&s);
	StrVec &operator=(StrVec &&s);
	StrVec &operator=(const StrVec &s);
	bool operator==(const StrVec &s)//14.16
	{
		if (size() != s.size())
			return false;
		auto it = elements, its = s.elements;
		while (it != first_free)
		{
			if (*it++ != *its++)
				return false;
		}
		return true;
	}
	bool operator!=(const StrVec &s)//14.16
	{
		return !(*this == s);
	}
	bool operator<(const StrVec &s)//14.18
	{
		if (size()>s.size())
			return false;
		else if (size() < s.size)
			return true;
		for (auto it = elements, its = s.elements; it != first_free; ++it, ++its)
		{
			if (*it == *its)
				continue;
			else if (*it > *its)
				return false;
			else
				return true;
		}
		return false;
	}
	bool operator>(const StrVec &s)//14.18
	{
		return !(*this < s) && *this != s;
	}
	bool operator<=(const StrVec &s)//14.18
	{
		return !(*this > s);
	}
	bool operator>=(const StrVec &s)//14.18
	{
		return !(*this < s);
	}
	StrVec &operator=(std::initializer_list<T> il)
	{
		auto nobj = alloc_n_copy(il.begin(), il.end());
		free();
		elements = nobj.first;
		first_free = cap = nobj.second;
		return *this;
	}
	T &operator[](std::size_t n)
	{
		return elements[n];
	}
	const T &operator[](std::size_t n)const
	{
		return elements[n];
	}
	~StrVec();
	void push_back(const T &s);//把T添加到尾后指针
	size_t size()const
	{
		return first_free - elements;
	}
	size_t capacity()const
	{
		return cap - elements;
	}
	T *begin()const
	{
		return elements;
	}
	T *end()const
	{
		return first_free;
	}
	template<class TT>
	friend std::ostream &operator<<(std::ostream &os, const StrVec<TT> &s);
};
template<class T>
void StrVec<T>::push_back(const T &s)
{
	chk_n_alloc();//确保空间剩余
	alloc.construct(first_free++, s);//在尾后构建一个s（s的拷贝构造函数构造），并把尾后指针first_free指向下一个
}
template<class T>
std::pair<T *, T *> StrVec<T>::alloc_n_copy(const T *b, const T *e)
{
	auto data = alloc.allocate(e - b);//分配并返回n个T对象的地址 T *
	return{ data, std::uninitialized_copy(b, e, data) };//uninit_copy返回尾后指针T *
														//把l~r之间的元素拷贝到data开始的地址，并返回data尾后，然后使用data(begin)和返回值(end)构建一个pair<T *,T *>
}
template<class T>
void StrVec<T>::free()
{
	if (elements)//如果不为空
	{
		for (auto p = first_free; p != elements;)
			alloc.destroy(--p);//从最后一个元素开始向前摧毁，调用p的析构函数
							   //for_each(elements, first_free, [this](T *s){alloc.destroy(s); });//13.43
		alloc.deallocate(elements, cap - first_free);//释放elements开始的n的T对象的内存
	}
}
template<class T>
StrVec<T>::StrVec(std::initializer_list<T> il)
{
	auto newdata = alloc_n_copy(il.begin(), il.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}
template<class T>
StrVec<T>::StrVec(const StrVec &s)
{
	auto newdata = alloc_n_copy(s.begin(), s.end());//创建一个s的副本 值
	elements = newdata.first;//把头指向新创建的副本的头
	first_free = cap = newdata.second;//把尾后和内存尾指向副本的尾（以后调用会调用chk_n_alloc，不用担心剩余空间大小）
}
template<class T>
StrVec<T>::StrVec(StrVec &&s) :elements(s.elements), first_free(s.first_free), cap(s.cap)
{
	s.elements = s.first_free = s.cap = nullptr;
}
template<class T>
StrVec<T> &StrVec<T>::operator=(StrVec &&s)
{
	if (this == &s)
		return *this;
	free();
	elements = s.elements;
	first_free = s.first_free;
	cap = s.cap;
	s.elements = s.first_free = s.cap = nullptr;
	return *this;
}
template<class T>
StrVec<T>::~StrVec()
{
	free();//清理当前对象alloc分配的内存
}
template<class T>
StrVec<T> &StrVec<T>::operator=(const StrVec &s)
{
	if (this == &s)
		return *this;
	auto data = alloc_n_copy(s.elements, s.first_free);
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}
template<class T>
void StrVec<T>::reallocate()
{
	auto newcapacity = size() ? 2 * size() : 1;	//当前空间的两倍大小
	auto newdata = alloc.allocate(newcapacity);	//分配并返回newcapacity个T对象大小的空间
	auto dest = newdata;
	auto elem = elements;//指向当前对象的头
	for (size_t i = 0; i != size(); ++i)
	{
		alloc.construct(dest++, std::move(*elem++));//move会让elem指向的T对象放弃自己的内存管理权并返回，然后construct使用T的移动构造函数构建dest指向的地址
	}												//接受dest会指向newdata的尾后
	free();				//移动完后释放当前对象指向的内存
	elements = newdata;	//指向新头
	first_free = dest;	//指向新尾后		
	cap = elements + newcapacity;	//指向内存尾
}
template<class TT>
std::ostream &operator<<(std::ostream &os, const StrVec<TT> &s)
{
	for (auto x : s)
		std::cout << x;
	return os;
}


#include "标头.h"

int main()
{
	using namespace std;

	StrVec<char> str{ 'c','l','a','n','n','a','d' };
	cout << str;

	system("pause");
	return 0;
}

16.17

template<class T,typename T>在声明模板时没有区别，但是在制定为类型而不是静态值时就必须用typename： typename T::size_type func(); 这里的size_type是类型而不是值。


16.18

1、错误，不能连续声明模板参数             改为：template<typename T,typename U,typename V> void f1(T,U,V);

b、错误，模板参数名不能作为变量名     改为：template<typename T> T f2(T &);

c、错误，内联声明位置错误                      改为：template<typename T> inline T foo(T,unsigned int *);

d、错误，缺少返回类型                              改为：template<typename> T f4(T,T);

e、错误，模板参数将覆盖外层的Ctype   改为：typedef char C;或者是template<typename C> C f5(C a);


16.19

#pragma once
#include <iostream>
template<typename T>
void prin(T &s, std::ostream &os)
{
	typename T::size_type n=0,size = s.size();
	auto iter = s.begin();
	for (; n < size; ++n)
	{
		os << *iter++;
	}
}

#include "标头.h"
#include <vector>
int main()
{
	using namespace std;
	vector<char> str = { '1','2','3','4','5','6','7','8','9','0' };
	prin(str, cout);
	system("pause");
	return 0;
}

16.20 

#pragma once
#include <iostream>
template<typename T>
void prin(T &s, std::ostream &os)
{
	for (auto beg = s.begin(); beg != s.end(); ++beg)
	{
		os << *beg;
	}
}
#include "标头.h"
#include <vector>
#include <list>
int main()
{
	using namespace std;
	vector<char> str = { '1','2','3','4','5','6','7','8','9','0' };
	list<int> lint = { 1,2,3,4,5,6,7,8,9 };
	prin(str, cout);
	prin(lint,cout);
	system("pause");
	return 0;
}

16.21 
#pragma once
#include <iostream>
class DebugDelete
{
	std::ostream &os;
public:
	DebugDelete(std::ostream &s = std::cerr) :os(s) {}
	template<class T>
	void operator()(T *p) {
		os << "delete obj!!!" << std::endl;
		delete p;
	}
};


16.22

#ifndef HEAD_H_
#define HEAD_H_
#include "DebugDelete.h"
#include <iostream>
#include <fstream>	//ifstream
#include <string>
#include <vector>
#include <sstream>	//istringstream
#include <map>
#include <set>
#include <memory>	//shared_ptr
class QueryResult;
using line_no = std::vector < std::string > ::size_type;
class TextQuery
{
	
	std::shared_ptr<std::vector<std::string>> file;					//保存整个文件内容，按行分
	std::map<std::string, std::shared_ptr<std::set<line_no>>> wm;	//每个单词对应行号
public:

	TextQuery(std::ifstream &is);
	QueryResult query(const std::string &s)const;					//返回QR，单词、行号set，还有关联到文件内容
};
class QueryResult
{
	friend std::ostream &print(std::ostream &os, const QueryResult &qr);
	std::string sought;
	std::shared_ptr<std::set<line_no>> lines;						//记录出现的行号
	std::shared_ptr<std::vector<std::string>> file;					//关联到文件内容
public:
	QueryResult(std::string s, std::shared_ptr<std::set<line_no>> p, std::shared_ptr<std::vector<std::string>> f) :sought(s), lines(p), file(f){}
};
TextQuery::TextQuery(std::ifstream &is) :file(new std::vector<std::string>(),DebugDelete(std::cout))	//为智能指针file分配空间    16.22
{
	std::string text;
	while (getline(is, text))
	{
		file->push_back(text);
		int n = file->size() - 1;
		std::istringstream line(text);
		std::string word;
		while (line >> word)
		{
			auto &lines = wm[word];						//如果word在wm中第一次出现，那么对应的set就未分配内存，所以为空
			if (!lines)										//如果第一次出现
				lines.reset(new std::set<line_no>());
			lines->insert(n);
		}
	}
}
QueryResult TextQuery::query(const std::string &s)const
{
	static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>());	//当没找到单词时返回	内存常驻
	auto loc = wm.find(s);
	if (loc == wm.end())
		return QueryResult(s, nodata, file);
	else
		return QueryResult(s, loc->second, file);
}
std::ostream &print(std::ostream &os, const QueryResult &qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " " << (qr.lines->size() > 1 ? "times" : "time") << std::endl;
	for (auto x : *qr.lines)			//*(qr.file->begin()+x)
		os << "\t(line " << x + 1 << ") " << (*qr.file)[x] << std::endl;	//file返回一个指向vec的智能指针，解引用后得到vector 然后使用下标运算符
	return os;
}
#endif

16.23

在对象介绍声明周期时掉用


16.24 

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
#include <memory>	//shared_ptr
template<typename T> class Blob;
template<typename T> class BlobPtr;
template<typename T> bool operator==(const Blob<T>&, const Blob<T>&);
template<typename T>
class Blob
{
public:
	friend class BlobPtr<T>;
	friend bool operator==<T>(const Blob &l, const Blob &r);
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type;	//把size_type视为类型名,忽略vector里同名的(如果有)静态变量
	Blob();
	Blob(std::initializer_list<T> il);
	template<class U>
	Blob(U b, U e);
	size_type size()const {						//返回元素数量
		return data->size();
	}
	bool empty()const {							//是否为空
		return data->empty();
	}
	void push_back(const T &t) {				//添加元素到末尾
		data->push_back(t);
	}
	void push_back(T &&t) {
		data->push_back(std::move(t));
	}
	void pop_back();							//弹出末尾元素
	T &back();									//返回末尾元素的引用
	T &operator[](size_type i);					//返回第i个元素的引用
private:
	std::shared_ptr<std::vector<T>> data;
	void check(size_type i, const std::string &msg)const;
};

template<typename T>
void Blob<T>::check(size_type i, const std::string &msg)const {
	if (i >= data->size())
		throw std::out_of_range(msg);
}
template<typename T>
T &Blob<T>::back() {
	check(0, "back on empty Blob");
	return data->back();
}
template<typename T>
T &Blob<T>::operator[](size_type i) {
	check(i, "subscript out range");
	return (*data)[i];
}
template<typename T>
void Blob<T>::pop_back() {
	check(0, "pop_back on empty Blob");
	data->pop_back();
}
template<typename T>
Blob<T>::Blob():data(std::make_shared<std::vector<T>>()){
}
template<typename T>
Blob<T>::Blob(std::initializer_list<T> il) : data(std::make_shared<std::vector<T>>(il)) {
}

template<typename T>
bool operator==(const Blob<T> &l, const Blob<T> &r) {
	if (l.data != r.data)
		return false;
	return true;
}

template<class T>
template<class U>
Blob<T>::Blob(U b, U e) :data(std::make_shared < std::vector<T>>(b, e)) {}
#include "Blob.h"
int main()
{
	using namespace std;
	int vi[] = { 1,2,3,4,5,6 };
	Blob<int> b(begin(vi), end(vi));
	for (typename Blob<int>::size_type i = 0; i != b.size(); ++i)
	{
		cout << b[i];
	}
	system("pause");
	return 0;
}

16.25

extern template class vector<string>;//声明一个实例化，但是该实例化的定义不一定在本模块，提示编译器可以在其他模块查找

template clss vector<Sales_data>;//定义一个实例化，让编译器生成一个实例


16.26

不可以，因为下面的就会报错：

vector<NoDefault> vN(10);//error，没有NoDefault类没有默认构造函数


16.27

a:没有实例化，只有在有数据时才会实例化

b:没有实例化，引用并不会实例化，因为没有数值存在

c:实例化出一个Stack<int>的实例

d:没有实例化，指针不会实例化，他包含的是地址

e:实例化出一个Stack<char>的实例，因为函数接收到数据，而且是按值传递

f:实例化出一个Stack<string>的实例，


16.28

//DebugDelete.h
#pragma once
#include <iostream>
class DebugDelete
{
public:
	DebugDelete(std::ostream& s = std::cerr) : os(s) { }
	template<typename T>
	void operator() (T* p) const
	{
		os << "deleting ptr" << std::endl;
		delete p;
	}

private:
	std::ostream& os;
};


#pragma once	//shared_p.h
#include <functional>
#include "DebugDelete.h"
#include <memory>
template<typename T>class shared_p;

class SharedPtrControlBlock								//保存引用数所使用
{
	template<typename T>friend class shared_p;
	int _count;
	SharedPtrControlBlock() :_count(1){}
};

template<typename T>
class shared_p
{
	T *_ptr;
	SharedPtrControlBlock *control_block;
	std::function<void(T*)> deleter{ DebugDelete() };
	template<typename U>
	void Initialize(const shared_p<U> &r)
	{
		if (r.control_block != nullptr)
		{
			AtomicIncrement(&r.control_block->_count);
			_ptr = r._ptr;
			control_block = r.control_block;
			deleter = r.deleter;
		}
	}
public:
	explicit shared_p(T *ptr = nullptr, std::function<void(T*)> f = DebugDelete())
		:_ptr(ptr),
		control_block(_ptr != nullptr ? new SharedPtrControlBlock : nullptr),
		deleter(f) {}

	shared_p(const shared_p &p)
	{
		Initialize(p);
	}

	shared_p &operator=(shared_p &p)
	{
		if (_ptr != p._ptr)
		{
			shared_p temp(p);
			swap(temp);
		}
		return *this;
	}

	shared_p(std::shared_ptr<T> &&sp)
	{
		if (sp.unique())
		{
			/*shared_p<T> temp =shared_p(new T(*sp));
			_ptr = temp._ptr;
			control_block = temp.control_block;*/
			*this = shared_p(new T(*sp));

		}
		else
			throw std::runtime_error("unique error!!");
	}

	template<typename U>
	friend std::ostream &operator<<(std::ostream &os, const shared_p<U> &s);

	~shared_p()
	{
		if (_ptr != nullptr)
		{
			if (AtomicDecrement(&control_block->_count) == 0)
			{
				deleter(_ptr);
				delete control_block;
			}
		}
	}

	int AtomicDecrement(int *count)
	{
		return --*count;
	}

	int AtomicIncrement(int *count)
	{
		return ++*count;
	}

	void reset(T *p = nullptr,std::function<void(T*)> del=DebugDelete())
	{
		if (p != _ptr)
		{
			shared_p temp(p);
			temp->swap(*this);
			deleter = del;
		}
	}

	void swap(shared_p &r)
	{
		std::swap(_ptr, r._ptr);
		std::swap(control_block, r.control_block);
		std::swap(deleter, r.deleter);
	}

	T *get()const
	{
		return _ptr;
	}

	T &operator*()const 
	{
		return *_ptr;
	}

	auto &operator[](int n)
	{
		return (*_ptr)[n];
	}

	T *operator->()const 
	{
		return _ptr;
	}

	int use_count()const	//返回引用数
	{
		return control_block ? control_block->_count : 1;
	}

	bool unique()const		//是否单一占用 引用==1
	{
		return use_count() == 1;
	}
};

template<class T>
std::ostream &operator<<(std::ostream &os, const shared_p<T> &s)
{
	os << *s._ptr;
	return os;
}
#pragma once	//unique_p.h
#include <functional>
#include "DebugDelete.h"
template<typename T>
class unique_p
{
	T *_ptr;
	std::function<void(T*)> deleter{ DebugDelete() };
public:
	explicit unique_p(T *ptr = nullptr, std::function<void(T*)> del = DebugDelete()) :_ptr(ptr), deleter(del) {}

	unique_p(unique_p &u) :_ptr(u._ptr), deleter(u.deleter)
	{
		u._ptr = nullptr;
		u.deleter = nullptr;
	}

	unique_p(unique_p &&u) :_ptr(u._ptr), deleter(u.deleter)
	{
		u._ptr = nullptr;
		u.deleter = nullptr;
	}

	unique_p &operator=(unique_p &u)
	{
		_ptr = (u._ptr);
		deleter = u.deleter;
		u.deleter = nullptr;
		u._ptr = nullptr;
	}

	unique_p &operator=(unique_p &&u)
	{
		_ptr = (u._ptr);
		deleter = u.deleter;
		u.deleter = nullptr;
		u._ptr = nullptr;
	}

	template<typename U>
	friend std::ostream &operator<<(std::ostream &os, const unique_p &u);

	~unique_p()
	{
		delete _ptr;
	}

	void swap(unique_p &u)
	{
		std::swap(_ptr, u._ptr);
		std::swap(deleter, u.deleter);
	}

	void reset(T *p = nullptr, std::function<void(T*)> del = DebugDelete())
	{
		if (p != _ptr)
		{
			unique_p<T> temp(p);
			temp.swap(*this);
		}
	}

	T *get()const
	{
		return _ptr;
	}

	T &operator*()const
	{
		return *_ptr;
	}

	auto &operator[](int n)
	{
		return (*_ptr)[n];
	}

	T *operator->()const
	{
		return _ptr;
	}
};

template<typename T>
std::ostream &operator<<(std::ostream &os, const unique_p<T> &u)
{
	os << *_ptr;
	return os;
}
#include <iostream>
#include "shared_p.h"
#include "unique_p.h"
#include <vector>
#include <string>
#include <memory>

int main()
{
	using namespace std;
	shared_p<vector<char>> sv(new vector<char>);
	char a;
	while ((a = getchar()) != 'q')
		sv->push_back(a);
	for (auto &x : *sv)
		cout << x;
	unique_p<int> ui(new int(4096));
	cout << *ui;
	unique_p<int> uii(ui);
	cout << *uii;
	system("pause");
	cout << *ui;	//出错，空指针
	system("pause");
	return 0;
}

16.29、16.30 

#pragma once	//shared_p.h
#include "shared_p.h"
#include <functional>
#include <memory>
#include "DebugDelete.h"
template<typename T>
class shared_p
{
	T *_ptr=nullptr;
	std::size_t *_count=nullptr;
	std::function<void(T*)> deleter{ DebugDelete() };
	void free()
	{
		if (_ptr)
		{
			if (--*_count == 0)
			{
				delete _count;
				deleter(_ptr);
			}
			_ptr = nullptr;
			_count = nullptr;
		}
	}
public:
	shared_p() = default;
	shared_p(T *ptr, std::function<void(T*)> del = DebugDelete()) :
		_ptr(ptr), deleter(del),_count(new std::size_t(1)) {}
	shared_p(std::shared_ptr<T> &&sp, std::function<void(T*)> del = DebugDelete())	//16.29
	{
		if (sp.unique())
		{
			*this = shared_p(new T(*sp), del);
		}
		else
			throw std::runtime_error("unique error!!");
	}
	shared_p(shared_p &&s)noexcept:_ptr(std::move(s._ptr)),_count(std::move(s._count)),deleter(std::move(s.deleter))
	{
		s._ptr = nullptr;
		s._count = nullptr;
		s.deleter = nullptr;
	}

	shared_p &operator=(shared_p &s)
	{
		if(_ptr!=nullptr)
			free();
		_ptr = s._ptr;
		_count = s._count;
		deleter = s.deleter;
		++*_count;
		return *this;
	}
	shared_p &operator=(shared_p &&s)
	{
		if (_ptr != nullptr)
			free();
		_ptr = s._ptr;
		_count = s._count;
		deleter = s.deleter;
		s._count = nullptr;
		s._ptr = nullptr;
		s.deleter = nullptr;
		return *this;
	}

	operator bool()const
	{
		return _ptr ? true : false;
	}

	T &operator*()const
	{
		return *_ptr;
	}

	T *operator->()const
	{
		return _ptr;
	}

	std::size_t use_count()const
	{
		return *_count;
	}

	T *get()const noexcept
	{
		return _ptr;
	}

	bool unique()const noexcept
	{
		return *_count == 1;
	}

	void swap(shared_p &s)
	{
		::__ExceptionPtrSwap(*this, s);
	}

	void reset()noexcept
	{
		free();
	}
	void reset(T *s, std::function<void(T*)> &del=DebugDelete())
	{
		if (_ptr != p)
		{
			free();
			_ptr = s;
			_count = new std::size_t(1);
			deleter = del;
		}
	}
	void reset(std::function<void(T*)> &del = DebugDelete())
	{
		deleter = del;
	}

	~shared_p()
	{
		free();
	}
};
#pragma once	//Bolb.h
#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
#include <memory>	//make_shared
#include "shared_p.h"
template<typename T> class Blob;

template<typename T> bool operator==(const Blob<T>&, const Blob<T>&);
template<typename T>
class Blob
{
public:

	friend bool operator==<T>(const Blob &l, const Blob &r);
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type;	//把size_type视为类型名,忽略vector里同名的(如果有)静态变量
	Blob();
	Blob(std::initializer_list<T> il);
	template<class U>
	Blob(U b, U e);
	size_type size()const {						//返回元素数量
		return data->size();
	}
	bool empty()const {							//是否为空
		return data->empty();
	}
	void push_back(const T &t) {				//添加元素到末尾
		data->push_back(t);
	}
	void push_back(T &&t) {
		data->push_back(std::move(t));
	}
	void pop_back();							//弹出末尾元素
	T &back();									//返回末尾元素的引用
	T &operator[](size_type i);					//返回第i个元素的引用
private:
	shared_p<std::vector<T>> data;
	void check(size_type i, const std::string &msg)const;
};

template<typename T>
void Blob<T>::check(size_type i, const std::string &msg)const {
	if (i >= data->size())
		throw std::out_of_range(msg);
}
template<typename T>
T &Blob<T>::back() {
	check(0, "back on empty Blob");
	return data->back();
}
template<typename T>
T &Blob<T>::operator[](size_type i) {
	check(i, "subscript out range");
	return (*data)[i];
}
template<typename T>
void Blob<T>::pop_back() {
	check(0, "pop_back on empty Blob");
	data->pop_back();
}
template<typename T>
Blob<T>::Blob() :data(std::make_shared<std::vector<T>>()) {
}
template<typename T>
Blob<T>::Blob(std::initializer_list<T> il) : data(std::make_shared<std::vector<T>>(il)) {
}

template<typename T>
bool operator==(const Blob<T> &l, const Blob<T> &r) {
	if (l.data != r.data)
		return false;
	return true;
}

template<class T>
template<class U>
Blob<T>::Blob(U b, U e) :data(std::make_shared<std::vector<T>>(b, e)) 
{
}
#include "Blob.h"
int main()
{
	using namespace std;
	int vi[] = { 1,2,3,4,5,6 };
	vector<int> vint(begin(vi), end(vi));
	Blob<int> b(vint.begin(),vint.end());
	for (typename Blob<int>::size_type i = 0; i != b.size(); ++i)
	{
		cout << b[i];
	}
	system("pause");
	return 0;
}


16.31

在类内部定义的方法默认内联，unique_ptr内保存删除器的是一歌函数指针，所以并不会内联而是跳转


16.32

编译器通过实参的类型类推断模板的参数


16.33

一种是非const到const的转换

另外一种是数组或函数到指针的转换


16.34

 a、非法，实参是两个不同的类型，前者为 char [3]，后者为 char [6]

 b、合法，T为const char [4]


16.35

 a、合法，T为char，const char被转换为int

 b、合法，T为double，float被转换为int

 c、合法，T为char

 d、非法，实参类型不统一，前者是double，后者是float


16.36

 a、T为int*

 b、T1和T2都是int*

 c、T为const int*

 d、都是const int*

 e、非法，实参类型不相同，int*与const int*

 f、T1为int*，T2为const int*


16.37

不能，该函数只能接受一个模板参数类型


16.38

该函数接收的实参是迭代器或指针，如果不给出实参类型，那么就不知道分配内存的大小

make_shared根据指定的实参类型分配合适的空间，并发返回一个指向这块空间的shared_ptr


16.39

compare<string>


16.40

合法、因为decltype会推导表达式的内容

所以需要改类型支持该表达式的操作：decltype(*beg+0);需要类型支持operator+操作

返回类型取决于该操作符operator的返回值


16.41

template<typename T>

auto sum(T &a,T &b)->decltype(a+b)        //制定返回值的类型

{

    return a+b;

}


16.42

 a、i为左值，T为int&，val：int& &&折叠为int&

 b、ci为左值，T为const int&，val：const int & &&折叠为const int&

 c、i*ci为右值，T为int&&，val：T&& &&折叠为int&&


16.43

表达式i=ci最终留下的是左值，所以T为T&，val为int&


16.44

 1、template<typename T> void g(T);

  a、T为int，val为int

  b、T为int，val为int，const被忽略，因为是按值传递

  c、T为int，val为int，实参是右值，但是按值传递给形参

 2、template<typename T> void g(const T&);

  a、T为int，val为const int&

  b、T为int，val为const int&

  c、T为int&&，val为const int& &&，折叠为const int&


16.45

当实参为42时，编译器解析T为一个右值：int&&，所以val为：int&& &&，折叠后为int&&

当实参为int类型变量时，编译器解析T为一个左值:int&，所以val为：int& &&，折叠后为int&

在第一次传递时，T为int&&，这对于vector没有错误。

但是第二次传递时，T为int&，这样会出现一个错误：未初始化的左值


16.46

	auto newcapacity = size() ? 2 * size() : 1;	//当前空间的两倍大小
	auto newdata = alloc.allocate(newcapacity);	//分配并返回newcapacity个string对象大小的空间
	auto dest = newdata;
	auto elem = elements;//指向当前对象的头
	for (size_t i = 0; i != size(); ++i)
	{
		alloc.construct(dest++, std::move(*elem++));//move会让elem指向的string对象放弃自己的内存管理权并返回，然后construct使用string的移动构造函数构建dest指向的地址
	}
作用：把elem的所有元素移动到dest的空间里


16.47

#include <vector>
#include <iostream>
template <typename F,typename T1,typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
	f(std::forward<T2>(t2), std::forward<T1>(t1));
}
void pp(int a, int &b)
{
	std::cout << a << " " << ++b << std::endl;
}
void gv(int &a, int &b)
{
	a += b;
	b = a - b;
	a = a - b;
}
int main()
{
	using namespace std;
	int a = 40, b = 86;
	flip(pp,a, b);
	flip(gv, a, b);
	cout << a << " " << b << endl;
	system("pause");
	return 0;
}

16.49、16.50

#include <iostream>

template<typename T> void f(T t) {
	std::cout << "f(T):" << t << std::endl;
}
template<typename T> void f(const T *t) {
	std::cout << "f(const T *):" << t << " " << *t << std::endl;
}
template<typename T> void g(T t) {
	std::cout << "g(T):" << t << std::endl;
}
template<typename T> void g(T *t) {
	std::cout << "f(T *):" << t << " " << *t << std::endl;
}
int main()
{
	using namespace std;
	int i = 42, *p = &i;
	const int ci = 0, *p2 = &ci;
	g(42);			//g(T)<span style="white-space:pre">		</span>const int更匹配T
	g(p);			//g(T*)   <span style="white-space:pre">	</span>p是指针更匹配T*
	g(ci);			//g(T)
	g(p2);			//g(T*)
	f(42);			//f(T)
	f(p);			//f(T)
	f(ci);			//f(T)
	f(p2);			//f(const T*)<span style="white-space:pre">		</span>更加特例化

	system("pause");
	return 0;
}

16.51、16.52 

#include <iostream>
#include <string>
template<typename T,typename... Args>
void foo(const T &t, Args... args)
{
	std::cout << "Args:" << sizeof...(Args) << "\targs:" << sizeof...(args) << std::endl;
}

int main()
{
	using namespace std;
	int i = 0;
	double d = 3.14;
	string s = "c++ primer";
	foo(i, s, 42, d);					//Args:3	args:3
	foo(i, 42, "hello");				//Args:2	args:2
	foo(d, s);							//Args:1	args:1
	foo("hi");							//Args:0	args:0
	foo("c++", '5', 2016, 4.2, i, s);	//Agrs:5	args:5
	system("pause");
	return 0;
}



16.53

#include <iostream>
#include <string>
template<typename T>
std::ostream &print(std::ostream &os, const T &t)
{
	return os << t;
}
template<typename T,typename... Args>
std::ostream &print(std::ostream &os,const T &t,const Args&... args)
{
	os << t << ", ";
	return print(os, args...);
}

int main()
{
	using namespace std;
	int a = 1;
	double d = 2.2;
	string s = "c++ primer";

	print(cout, 42) << endl;
	print(cout, 42, d) << endl;
	print(cout, 42, d, s, "hello", 'w') << endl;
	system("pause");
	return 0;
}

16.54

缺少“<<”操作符的定义：

class Test
{};
...
Test t;
print(cout,t);//二进制“<<”: 没有找到接受“const aaa”类型的右操作数的运算符(或没有可接受的转换)

16.55

题目无法理解，会的同学请@我


16.56

#include <iostream>
#include <string>
#include <sstream>

template <typename T> std::string debug_rep(const T& t);
template <typename T> std::string debug_rep(T* p);

std::string debug_rep(const std::string &s);
std::string debug_rep(char* p);
std::string debug_rep(const char *p);

template<typename T>
std::string debug_rep(const T &s)
{
	std::ostringstream ret;
	ret << s;
	return ret.str();
}
template<typename T>
std::string debug_rep(T *p)
{
	std::ostringstream ret;
	std::cout << "point:" << s;
	if (p)
		ret << " " << debug_rep(*p);
	else
		ret << "point is NULL!";
	return ret.str();
}
template<typename T>
std::ostream &print(std::ostream &os, const T &t)
{
	return os << t;
}
template<typename T,typename... Args>
std::ostream &print(std::ostream &os, const T &t, const Args&... args)
{
	os << t << ", ";
	return print(os, args...);
}
std::string debug_rep(const std::string &s)
{
	return '"' + s + '"';
}
std::string debug_rep(char *p)
{
	return debug_rep(std::string(p));
}

std::string debug_rep(const char *p)
{
	return debug_rep(std::string(p));
}
template<typename... Args>
std::ostream &errorMsg(std::ostream &os, const Args... args)
{
	return print(os, debug_rep(args)...);
}

int main()
{
	using namespace std;
	string str = "c++";
	errorMsg(cout, str, "primer", 4, 8.6, '5');

	system("pause");
	return 0;
}

16.57

前者使用的是initialize_list，只能传递相同类型的实参，相比之下可变参数更灵活


16.58

#pragma once
#include <iostream>
#include <string>
#include <memory>	//allocator
#include <utility>	//move
#include <initializer_list>
#include <algorithm>	//for_each
class StrVec
{
	std::allocator<std::string> alloc;//为所有StrVec对象分配内存用
	void chk_n_alloc()		//如果剩余空间为0就分配新空间
	{
		if (size() == capacity())
			reallocate();
	}
	std::pair<std::string *, std::string *> alloc_n_copy(const std::string *b, const std::string *e);//创建一个内容为b到e之间的元素的对象，并返回这个对象的一对头尾指针
	void free();//释放所有alloc分配的所有内存
	void reallocate();//移动当前对象的元素到2倍对象大小的新对象里
	std::string *elements;
	std::string *first_free;
	std::string *cap;
public:
	StrVec() :elements(nullptr), first_free(nullptr), cap(nullptr){}
	StrVec(std::initializer_list<std::string> il);
	StrVec(const StrVec &s);
	StrVec(StrVec &&s);
	StrVec &operator=(StrVec &&s);
	StrVec &operator=(const StrVec &s);

	template<typename... Args>				//16.58
	void emplace_back(Args&&... args)
	{
		chk_n_alloc();
		alloc.construct(first_free++, std::forward<Args>(args)...);
	}

	bool operator==(const StrVec &s)//14.16
	{
		if (size() != s.size())
			return false;
		auto it = elements, its = s.elements;
		while (it != first_free)
		{
			if (*it++ != *its++)
				return false;
		}
		return true;
	}
	bool operator!=(const StrVec &s)//14.16
	{
		return !(*this == s);
	}
	bool operator<(const StrVec &s)//14.18
	{
		if (size()>s.size())
			return false;
		else if (size() < s.size())
			return true;
		for (auto it = elements, its = s.elements; it != first_free; ++it, ++its)
		{
			if (*it == *its)
				continue;
			else if (*it > *its)
				return false;
			else
				return true;
		}
		return false;
	}
	bool operator>(const StrVec &s)//14.18
	{
		return !(*this < s) && *this != s;
	}
	bool operator<=(const StrVec &s)//14.18
	{
		return !(*this > s);
	}
	bool operator>=(const StrVec &s)//14.18
	{
		return !(*this < s);
	}
	StrVec &operator=(std::initializer_list<std::string> il)
	{
		auto nobj = alloc_n_copy(il.begin(), il.end());
		free();
		elements = nobj.first;
		first_free = cap = nobj.second;
		return *this;
	}
	std::string &operator[](std::size_t n)
	{
		return elements[n];
	}
	const std::string &operator[](std::size_t n)const
	{
		return elements[n];
	}
	~StrVec();
	void push_back(const std::string &s);//把string添加到尾后指针
	size_t size()const
	{
		return first_free - elements;
	}
	size_t capacity()const
	{
		return cap - elements;
	}
	std::string *begin()const
	{
		return elements;
	}
	std::string *end()const
	{
		return first_free;
	}
};
void StrVec::push_back(const std::string &s)
{
	chk_n_alloc();//确保空间剩余
	alloc.construct(first_free++, s);//在尾后构建一个s（s的拷贝构造函数构造），并把尾后指针first_free指向下一个
}
std::pair<std::string *, std::string *> StrVec::alloc_n_copy(const std::string *b, const std::string *e)
{
	auto data = alloc.allocate(e-b);//分配并返回n个string对象的地址 string *
	return{ data, std::uninitialized_copy(b, e, data) };//uninit_copy返回尾后指针string *
	//把l~r之间的元素拷贝到data开始的地址，并返回data尾后，然后使用data(begin)和返回值(end)构建一个pair<string *,string *>
}
void StrVec::free()
{
	if (elements)//如果不为空
	{
		for (auto p = first_free; p != elements;)
			alloc.destroy(--p);//从最后一个元素开始向前摧毁，调用p的析构函数
		//for_each(elements, first_free, [this](std::string *s){alloc.destroy(s); });//13.43
		alloc.deallocate(elements, cap - first_free);//释放elements开始的n的string对象的内存
	}
}
StrVec::StrVec(std::initializer_list<std::string> il)
{
	auto newdata = alloc_n_copy(il.begin(), il.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}
StrVec::StrVec(const StrVec &s)
{
	auto newdata = alloc_n_copy(s.begin(), s.end());//创建一个s的副本 值
	elements = newdata.first;//把头指向新创建的副本的头
	first_free = cap = newdata.second;//把尾后和内存尾指向副本的尾（以后调用会调用chk_n_alloc，不用担心剩余空间大小）
}
StrVec::StrVec(StrVec &&s) :elements(s.elements), first_free(s.first_free), cap(s.cap)
{
	s.elements = s.first_free = s.cap = nullptr;
}
StrVec &StrVec::operator=(StrVec &&s)
{
	if (this == &s)
		return *this;
	free();
	elements = s.elements;
	first_free = s.first_free;
	cap = s.cap;
	s.elements = s.first_free = s.cap = nullptr;
	return *this;
}
StrVec::~StrVec()
{
	free();//清理当前对象alloc分配的内存
}
StrVec &StrVec::operator=(const StrVec &s)
{
	if (this == &s)
		return *this;
	auto data = alloc_n_copy(s.elements, s.first_free);
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}
void StrVec::reallocate()
{
	auto newcapacity = size() ? 2 * size() : 1;	//当前空间的两倍大小
	auto newdata = alloc.allocate(newcapacity);	//分配并返回newcapacity个string对象大小的空间
	auto dest = newdata;
	auto elem = elements;//指向当前对象的头
	for (size_t i = 0; i != size(); ++i)
	{
		alloc.construct(dest++, std::move(*elem++));//move会让elem指向的string对象放弃自己的内存管理权并返回，然后construct使用string的移动构造函数构建dest指向的地址
	}												//接受dest会指向newdata的尾后
	free();				//移动完后释放当前对象指向的内存
	elements = newdata;	//指向新头
	first_free = dest;	//指向新尾后		
	cap = elements + newcapacity;	//指向内存尾
}

16.59


16.60

可接受可变参数模板，转发其参数把初始化一个内存与没陪空间，返回一个shared_ptr


16.61

#include <memory>
#include <iostream>
#include <string>
template<typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args)
{
	return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
}

int main()
{
	auto p = make_shared<int>(40);
	std::cout << *p << std::endl;
	auto cp = make_shared<std::string>(10, 'a');
	std::cout << *cp << std::endl;
	system("pause");
	return 0;
}

16.62 

#pragma once
#include <iostream>
#include <string>
class Sales_data
{
	std::string bookNo;
	unsigned units_sold;
	double revenue;
	double avg_price()const { return units_sold ? revenue / units_sold : 0; }
public:
	Sales_data(const std::string &s=std::string(), unsigned n = 0, double p = 0) :bookNo(s), units_sold(n), revenue(p) {}
	Sales_data(std::istream &is);
	std::string isbn()const { return bookNo; }
	Sales_data &operator+=(const Sales_data &s);
	friend std::hash<Sales_data>;
	friend std::ostream &operator<<(std::ostream &os, const Sales_data &s);
	friend std::istream &operator>>(std::istream &is, Sales_data &s);
	friend bool operator==(const Sales_data &ls, const Sales_data &rs);
	friend Sales_data operator+(const Sales_data &ls, const Sales_data &rs);
	friend std::ostream &print(std::ostream &os, const Sales_data &s);
	friend std::istream &read(std::istream &is, Sales_data &s);
};
bool operator!=(const Sales_data &ls, const Sales_data &rs);
Sales_data add(const Sales_data &ls, const Sales_data &rs);

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 {
			return hash<string>()(s.bookNo) ^ hash<unsigned>()(s.units_sold) ^ hash<double>()(s.revenue);
		}
	};
}
#include "Sales_data.h"

Sales_data::Sales_data(std::istream &is)
{
	is >> *this;
}

Sales_data &Sales_data::operator+=(const Sales_data &s)
{
	units_sold += s.units_sold;
	revenue += s.revenue;
	return *this;
}

std::ostream &operator<<(std::ostream &os, const Sales_data &s)
{
	os << s.isbn() << " " << s.units_sold << " " << s.revenue << " " << s.avg_price();
	return os;
}

std::istream &operator>>(std::istream &is, Sales_data &s)
{
	double price;
	is >> s.bookNo >> s.units_sold >> price;
	if (is)
		s.revenue = s.units_sold*price;
	else
		s = Sales_data();
	return is;
}

bool operator==(const Sales_data &ls, const Sales_data &rs)
{
	return ls.bookNo == rs.bookNo&&ls.units_sold == rs.units_sold&&ls.revenue == rs.revenue;
}
bool operator!=(const Sales_data &ls, const Sales_data &rs)
{
	return !(ls == rs);
}

Sales_data operator+(const Sales_data &ls, const Sales_data &rs)
{
	Sales_data temp = ls;
	temp += rs;
	return temp;
}

Sales_data add(const Sales_data &ls, const Sales_data &rs)
{
	Sales_data temp = ls;
	temp += rs;
	return temp;
}

std::ostream &print(std::ostream &os, const Sales_data &s)
{
	os << s.isbn() << " " << s.units_sold << " " << s.revenue << " " << s.avg_price();
	return os;
}

std::istream &read(std::istream &is, Sales_data &s)
{
	double price;
	is >> s.bookNo >> s.units_sold >> price;
	s.revenue = s.units_sold*price;
	return is;
}
#include <memory>
#include <unordered_set>
#include "Sales_data.h"

int main()
{
	//! test for ex16.62
	std::unordered_multiset<Sales_data> mset;
	Sales_data sd("Bible", 10, 0.98);

	mset.emplace(sd);
	mset.emplace("C++ Primer", 5, 9.99);

	for (const auto &item : mset)
		std::cout << "the hash code of " << item.isbn()
		<< ":\n0x" << std::hex << std::hash<Sales_data>()(item)
		<< "\n";
	system("pause");
	return 0;
}

16.63、16.64 

#pragma once
#include <vector>
#include <string>
#include <cstring>

template<typename T>
std::size_t count(const std::vector<T> &vec, T value)
{
	std::size_t count = 0;
	for (auto &x : vec)
		count += (x == value) ? 1 : 0;
	return count;
}

template<>
std::size_t count(const std::vector<char *> &vec, char *value)
{
	std::size_t count = 0;
	for (auto &x : vec)
		count += (strcmp(x, value) == 0) ? 1 : 0;
	return count;
}

#include <iostream>
#include "标头.h"

int main()
{
	using namespace std;

	//16.63
	vector<double> dv = { 5,6,8,3,5,5,6,3,4 };
	vector<int> iv = { 2,3,5,6,3,3,4,8,3,5,1 };
	vector<string> sv = { "q","w","q","q","a","d","f","q" };
	cout << count(dv, 5.0) << " " << count(iv, 3) << " " << count<string>(sv, "q");

	//16.64
	vector<char *> cpv = { "c++","primer","4th","hello","world","c++" };
	cout << count<char *>(cpv, "c++");

	system("pause");
	return 0;
}

16.65 
#pragma once
#include <sstream>
#include <string>

template<typename T>
std::string debug_rep(T *t)
{
	std::ostringstream ret;
	ret << t;
	return ret.str();
}
template<>
std::string debug_rep(char *t)
{
	return std::string(t);
}
template<>
std::string debug_rep(const char *t)
{
	return std::string(t);
}

#include "标头.h"
#include <iostream>

int main()
{
	using namespace std;
	char c[] = "c++ primer 5";
	const char *p = c;
	cout << debug_rep(c) << endl;
	cout << debug_rep(p) << endl;
	system("pause");
	return 0;
}

16.66

重载会改变匹配优先度


16.67

不会影响，

特化的模板匹配优先度和模板级别一致，还是非模板优先度最高















2016年4月9日23:34:23

过了那么久...连我自己都怀疑自己的耐心了



nonororo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++Primer第五版 第十六章习题答案（41~50）
MISAYAONE的博客
03-17 3632
41： 头文件 #ifndef REU_TYPE_H #define REU_TYPE_H template auto sum(const T&a,const T&b) ->decltype(a+b)//将函数的返回类型指定为a+b的类型 { return a+b; } #endif REU_TYPE_H main.cpp #include #include #include
C++Primer第五版 第十六章习题答案（31~40）
MISAYAONE的博客
03-17 4255
31：unique_p是保存删除器函数的指针，所以需要一次跳转操作，并不会内联而是跳转 32：知识点1：从函数实参到模版实参的过程被称为模版实参推断，在这个过程中，可能会发生类型转换 知识点2：只有很有限的几种方式会发生类型转换 1：非const对象的引用或者指针到const对象的引用或者指针（const到非const是不合法的）（顶层const会被忽略） 2：若函数参数不是引用的
《C++ Primer》第16章 16.1节习题答案2
chenyijun的专栏
10-29 373
《C++ Primer》第16章 模板与泛型编程 16.1节定义模板 习题答案 练习16.17：声明为typename的类型参数和声明为class的类型参数有什么不同（如果有的话）？什么时候必须使用typename？ 【出题思路】 理解typename和class。 【解答】 当用来声明模板类型参数时，typename和class是完全等价的，都表明模板参数是一个类型。在C++最初引入模板时，是使用class的。但为了避免与类（或类模板）定义中的class相混淆，引入了typename关键字。.
【c++ primer】第五版第十六章习题答案
qq_51931826的博客
09-26 861
【c++ primer】第五版第十六章习题答案
C++ Primer Plus第十六章练习
16的博客
06-10 157
不得不说16章的STL初学者噩梦 看到算法那直接省略跳过了 16.10.1 #include <iostream> #include <string> using namespace std; bool Petest(const string &); int main(void) { cout << "otto是否是回文: " << (Petest("otto") ? "是" : "不是") << endl; return
C++Primer第五版 习题答案 第十六章 模板与泛型编程（Templates and Generic Programming）
shamozhizhoutx的博客
05-24 2772
练习16.1 给出实例化的定义。 实例化：编译器处理过程，用实际的模板实参来生成模板的一个特殊实例，其中参数被替换为对应的实参。当函数模板被调用时，会自动根据传递给它的实参来实例化。而使用类模板时，则需要我们提供显式模板实参。 练习16.2 编写并测试你自己版本的 compare 函数。 #include <iostream> template<typename T&g...
C++ primer 第五版 第十六章练习答案
Leslie5205912的博客
05-26 839
16.62 #include &lt;iostream&gt; #include &lt;unordered_set&gt; #include"Sales_data.h" using namespace std; namespace std { template&lt;&gt; struct hash&lt;Sales_data&gt; { typedef s...
C++ primer第五版，英文版
03-17
锻炼自己的全英文C++ primer第五版电子版，更加适合于有一定代码功底人士阅读，初学者（你要读也很棒棒）阅读难度较大。
c++primer 第五版 Lippman 第12章 课后习题答案 上
09-19
c++primer 第五版，是Lippman写的书 不是那个plus的书，第12章 课后习题答案 需要的参考，以前看书的时候做的 好久了 发现还在就上传上来 有需要的就下吧 应该所有题目都做的除了有的题目连续的就写到一起
C++ primer 第五版习题答案(完整版)
09-28
C++Primer第五版习题答案+详解(完整版) C++Primer第五版习题答案+详解(完整版)
C++ primer(第五版）第16章习题答案
INFINITE POSSIBILITIES
04-21 670
第十六章　模板与泛型编程 16.1 由编译器从模板生成的类或函数。 16.2 #ifndef CP5_EX16_02_COMPARE_H_ #define CP5_EX16_02_COMPARE_H_ #include <cstring> template <typename T> int compare(const T& v1, const T...
c++ primer 第五版 笔记 第十六章
安仔的博客
02-12 462
第十六章 模板与泛型编程 模板是泛型编程的基础。一个模板就是一个创建类或者函数的公式。使用这个公式创建不同的类或不同的函数 16.1 定义模板 考虑一下下面的情况，如果我们要比较两个值，最常见的办法就是根据需要比较的值的类型，进行函数重载。一旦类型多了之后，需要重载的函数就变多了。 现在可以使用函数模板来达到这种跟重载一样的效果 16.1.1 函数模板 一个函数模板就是一个公式，这个公式用来生成...
c++ primer 第十六章模板与泛型编程
无所知的博客
10-21 379
c++ primer 第十六章模板与泛型编程16.1 定义模板16.1.1 函数模板16.1.2 类模板16.1.3 模板参数16.1.4 成员模板16.1.5 控制实例化16.1.6 效率与灵活性16.2 模板实参推断16.2.1 类型转换与模板类型参数16.2.2 函数模板显示实参16.2.3 尾置返回类型与类型转换16.2.4 函数指针与实参推断16.2.5 模板实参推断和引用 16.1 定...
c++ primer第16章课后习题答案
weixin_43430640的博客
03-17 759
16.1.1节练习 练习16.1 当我们调用template时，编译器会根据函数实参的类型推断模板实参，从而确定最匹配的绑定到模板参数T的 类型，之后编译器用推断出得模板参数来实例化一个特定函数的版本，这个过程就叫做实例化。 练习16.2 模板函数在.h文件中定义 #ifndef TEMPLATE_COMPARE_H #define TEMPLATE_COMPARE_H templ...
c++ primer 第十六章习题
无所知的博客
10-21 452
c++ primer 第十六章习题 练习16.2 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;string&amp;amp;gt; #include &amp;amp;lt;vector&amp;amp;gt; #include &amp;quot;Sales_data.cc&amp;quot; using namespace std;
boost的operator操作符
davidsu33的专栏
06-09 819
// operators.cpp : 定义控制台应用程序的入口点。 //made by davidsu33 //2014-6-8 18:40 #include "stdafx.h" #include #include #include using namespace std; //utility中提供的rel_ops，操作符之间的转换 //通过实现 ! >=
c++Primer——第十六章：模板与泛型编程
judith的博客
08-20 123
1、在模板的类型参数前必须使用关键字class或typename，在模板参数列表中这两个关键字的含义相同，可以互换使用。 2、默认情况下，对于一个实例化了的类模板，其成员只有在使用时才会被实例化 3、在一个类模板的作用域内，我么可以直接使用模板名而不必指定模板实参 4、在普通代码中，由于编译器掌握类的定义，因此它知道通过作用域运算符访问的名字是类型还是static成员，但对于模板代码就存在困难。如：T::mem，编译器并不知道mem是类型还是static成员。c++默认通过作用域运算符访问的不是类型，
C++ Primer第五版之第16章 模板与泛型编程
HakunaMatata的博客
05-04 236
第16章 模板与泛型编程 定义模板 函数模板 模板定义以关键字template开始，后跟一个模板参数列表（是一个逗号分隔的一个或多个模板参数的列表），用<>包围起来。 在模板定义中，模板参数列表不能为空。 template <typename T> int compare(const T &v1, const T &v2) { if (v1...
C++ Primer(第五版) 16.5节练习
wlli1985的博客
08-08 222
16.62 Sales_data类要包含==运算符，主程序代码如下： #include "Sales_data.h" #include <unordered_set> using namespace std; namespace std { template <> struct hash<Sales_data> { typedef siz...
c++ primer 第五版 第六章
最新发布
09-20
《C Primer》是一本针对C语言初学者的经典教材，第五版的第六章主要介绍了函数的基本概念和用法。 在第六章中，教材首先介绍了函数的定义和调用。函数是具有独立功能的代码块，可以通过函数名来调用。函数由函数头...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值