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

12.1

b1=b2，所以都有4个元素，赋值后b1原先指向的内存被释放，因为计数为0

b2离开作用域后被摧毁，但计数器不为0，内存不用释放

12.2

#ifndef HEAD_H_
#define HEAD_H_
#include <memory>
#include <initializer_list>
#include <string>
#include <vector>
class StrBlob
{
	std::shared_ptr<std::vector<std::string>> data;
	void check(std::vector<std::string>::size_type i, const std::string &msg)const;
public:
	using size_type = std::vector<std::string>::size_type;
	StrBlob();
	StrBlob(std::initializer_list<std::string> il);
	size_type size()const;//返回vector元素数量
	bool empty()const;//是否为空
	void push_back(const std::string &t);//添加新元素到尾
	void pop_back();//弹出最后一个
	std::string front()const;
	std::string back()const;
	std::string &front();//返回第一个
	std::string &back();//返回最后一个
};
void StrBlob::check(std::vector<std::string>::size_type i, const std::string &msg)const
{
	if (i >= data->size())
		throw std::out_of_range(msg);
}
StrBlob::StrBlob() :data(std::make_shared<std::vector<std::string>>())
{

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

}
StrBlob::size_type StrBlob::size()const
{
	return data->size();
}
bool StrBlob::empty()const
{
	return data->empty();
}
void StrBlob::push_back(const std::string &t)
{
	data->push_back(t);
}
void StrBlob::pop_back()
{
	check(0, "pop_push on empty StrBlob");
	data->pop_back();
}
std::string &StrBlob::front()
{
	check(0, "front on empty StrBlob");
	return data->front();
}
std::string &StrBlob::back()
{
	check(0, "back on empty StrBlob");
	return data->back();
}
std::string StrBlob::front()const
{
	return data->front();
}
std::string StrBlob::back()const
{
	return data->back();
}
#endif

#include <iostream>
#include "标头.h"
int main()
{
	using namespace std;
	StrBlob strb{ "dsdsdsd", "dsdsdsdsd" ,"dasdafwafwadwa","fwqdswqdeqdwqed"};
	cout << strb.front();
	strb.pop_back();
	cout << endl << strb.front();
	strb.pop_back();
	cout << strb.front();
	system("puse");
	return 0;
}

12.3

可以这样做，但是然并卵

在方法形参为const时才会使用const版本

12.4

因为size_type是无符号类型，如果小于0将会自动转换为大于0的数

所以当参数为负数时，i肯定会比size()大

12.5

使用容易，因为可以自动转换参数类型

调试难，出问题时就悲剧

12.6

#include <iostream>
#include <vector>
void input(std::vector<int> &vec)
{
	int i;
	while (std::cin >> i)
		vec.push_back(i);
}
void print(const std::vector<int> &vec)
{
	for (auto a : vec)
		std::cout << a << "\t";
}
std::vector<int> *func()
{
	return new std::vector<int>;
}
int main()
{
	using namespace std;
	auto p = func();
	input(*p);
	print(*p);
	delete p;
	system("pause");
	return 0;
}

12.7

#include <iostream>
#include <memory> //shared_ptr....智能指针
#include <vector>
void input(std::shared_ptr<std::vector<int>> vec)
{
	int i;
	while (std::cin >> i)
		vec->push_back(i);
}
void print(const std::shared_ptr<std::vector<int>> vec)
{
	for (auto a : *vec)
		std::cout << a << "\t";
}
std::shared_ptr<std::vector<int>> func()
{
	//return std::make_shared<std::vector<int>>();	//创建一个智能指针分配内存，返回地址
	return std::shared_ptr<std::vector<int>>(new std::vector<int>);//new创建一个vector并隐式转换为智能指针，返回给智能指针初始化
}
int main()
{
	using namespace std;
	auto p = func();
	input(p);
	print(p);
	system("pause");
	return 0;
}

12.8

内存地址丢失

12.9

r=q后r原先指向的内存丢失

r2=q2后r2原先保存的计数器变为0，释放内存

12.10

可以这样，没有错误，然并卵

12.11

发生错误，当函数结束时会把get()返回的地址调用delete释放，使得p变成悬空指针

12.12

a：ok

b：error，new分配内存后返回的是一个普通指针，无法赋值到shared_ptr对象

c：error，p是一个普通指针，同上

d：ok，但容易发生错误，比较糟的做法

12.13

运行时错误，在delete后sp智能指针所管理的内存已经被释放，而当智能指针作用域过后会再释放一次

12.14

#include <iostream>
#include <memory>		//shared_ptr
#include <string>
struct destination
{
	std::string ip;
	int port;
	destination(std::string _ip, int _port) :ip(_ip), port(_port){}
};
struct connection
{
	std::string ip;
	int port;
	connection(std::string _ip, int _port) :ip(_ip), port(_port){}
};
connection connect(destination *p)
{
	std::shared_ptr<connection> ptr(new connection(p->ip, p->port));
	std::cout << "use_count:" << ptr.use_count() << std::endl;
	return *ptr;
}
void disconnect(connection p)
{
	std::cout << "close " << p.ip << std::endl;
	//delete ....
	//...
}
void end_connection(connection *p)
{
	disconnect(*p);
}
void f(destination &d)
{
	connection c = connect(&d);
	std::shared_ptr<connection> p(&c, end_connection);

}
int main()
{
	using namespace std;
	destination d("192.168.1.233", 2333);
	f(d);
	system("pause");
	return 0;
}

12.15

#include <iostream>
#include <memory>		//shared_ptr
#include <string>
struct destination
{
	std::string ip;
	int port;
	destination(std::string _ip, int _port) :ip(_ip), port(_port){}
};
struct connection
{
	std::string ip;
	int port;
	connection(std::string _ip, int _port) :ip(_ip), port(_port){}
};
connection connect(destination *p)
{
	std::shared_ptr<connection> ptr(new connection(p->ip, p->port));
	std::cout << "use_count:" << ptr.use_count() << std::endl;
	return *ptr;
}
void disconnect(connection p)
{
	std::cout << "close " << p.ip << std::endl;
	//delete ....
	//...
}
//void end_connection(connection *p)
//{
//	disconnect(*p);
//}
void f(destination &d)
{
	connection c = connect(&d);
	std::shared_ptr<connection> p(&c, [](connection *p){disconnect(*p); });

}
int main()
{
	using namespace std;
	destination d("192.168.1.233", 2333);
	f(d);
	system("pause");
	return 0;
}

12.16

#include <iostream>
#include <memory>		//shared_ptr
int main()
{
	using namespace std;
	unique_ptr<int> p(new int(0));
	unique_ptr<int> p1(p);	//它是已删除的函数
	unique_ptr<int> p2;
	p2 = p;			//它是已删除的函数
	system("pause");
	return 0;
}

12.17

a： 错误，ix是局部变量b：错误，同a

c：√ d：错误，同a

e：√ f：错误，多次释放同一位置内存

12.18

release会释放内存，无法保证计数为0

12.19

#ifndef HEAD_H_
#define HEAD_H_
#include <memory>
#include <initializer_list>
#include <string>
#include <vector>
class StrBlobPtr;
class StrBlob
{
	friend class StrBlobPtr;
	std::shared_ptr<std::vector<std::string>> data;
	void check(std::vector<std::string>::size_type i, const std::string &msg)const;
public:
	using size_type = std::vector<std::string>::size_type;
	

	StrBlob();
	StrBlob(std::initializer_list<std::string> il);
	size_type size()const;//返回vector元素数量
	bool empty()const;//是否为空
	void push_back(const std::string &t);//添加新元素到尾
	void pop_back();//弹出最后一个
	std::string front()const;
	std::string back()const;
	std::string &front();//返回第一个
	std::string &back();//返回最后一个

	StrBlobPtr begin();
	StrBlobPtr end();
};
class StrBlobPtr
{
	std::shared_ptr<std::vector<std::string>> check(std::size_t, const std::string &)const;
	std::weak_ptr<std::vector<std::string>> wptr;
	std::size_t curr;
public:
	StrBlobPtr() :curr(0){}
	StrBlobPtr(StrBlob &a, std::size_t sz = 0) :wptr(a.data), curr(sz){}
	std::string &deref()const;	//解引用
	StrBlobPtr &incr();	//++n;运算符
};

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

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

}
StrBlob::size_type StrBlob::size()const
{
	return data->size();
}
bool StrBlob::empty()const
{
	return data->empty();
}
void StrBlob::push_back(const std::string &t)
{
	data->push_back(t);
}
void StrBlob::pop_back()
{
	check(0, "pop_push on empty StrBlob");
	data->pop_back();
}
std::string &StrBlob::front()
{
	check(0, "front on empty StrBlob");
	return data->front();
}
std::string &StrBlob::back()
{
	check(0, "back on empty StrBlob");
	return data->back();
}
std::string StrBlob::front()const
{
	return data->front();
}
std::string StrBlob::back()const
{
	return data->back();
}
StrBlobPtr StrBlob::begin()
{ 
	return StrBlobPtr(*this); 
}
StrBlobPtr StrBlob::end()
{
	return StrBlobPtr(*this, data->size());
}
std::shared_ptr<std::vector<std::string>> StrBlobPtr::check(std::size_t i, const std::string &msg)const
{
	auto ret = wptr.lock();	//返回shared_ptr
	if (!ret)
		throw std::runtime_error("unbound StrBlobPtr");
	if (i >= ret->size())
		throw std::out_of_range(msg);
	return ret;
}
std::string &StrBlobPtr::deref()const
{
	auto ret = check(curr, "dereference past end");
	return (*ret)[curr];
}
StrBlobPtr &StrBlobPtr::incr()
{
	check(curr, "increment past end of StrBlobPtr");
	++curr;
	return *this;
}
#endif

12.20

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

bool iseq(const StrBlobPtr &s1, const StrBlobPtr &s2)	//StrBlobPtr的友元函数：当两个引用 不相等 时返回真
{
	if (s1.wptr.lock() == s2.wptr.lock())
		return !(s1.curr == s2.curr);
	return true;
}
int main(int argc, char **argv)
{
	using namespace std;
	ifstream ifile("F:\\11.txt");
	if (!ifile)
	{
		cerr << "open file error!";
		exit(1);
	}
	StrBlob str;
	string temp;
	while (getline(ifile, temp))
	{
		str.push_back(temp);
	}
	for (auto beg = str.begin(), end = str.end(); iseq(beg, end); beg.incr())
	{
		cout << beg.deref() << endl;
	}
	return 0;
}

12.21

一样，但前一个版本好理解

12.22

#ifndef HEAD_H_
#define HEAD_H_
#include <memory>
#include <initializer_list>
#include <string>
#include <vector>
class ConstStrBlobPtr;
class StrBlob
{
	friend class ConstStrBlobPtr;
	std::shared_ptr<std::vector<std::string>> data;
	void check(std::vector<std::string>::size_type i, const std::string &msg)const;
public:
	using size_type = std::vector<std::string>::size_type;


	StrBlob();
	StrBlob(std::initializer_list<std::string> il);
	size_type size()const;//返回vector元素数量
	bool empty()const;//是否为空
	void push_back(const std::string &t);//添加新元素到尾
	void pop_back();//弹出最后一个
	std::string front()const;
	std::string back()const;
	const std::string &front();//返回第一个	const
	const std::string &back();//返回最后一个 const

	ConstStrBlobPtr begin();	//curr=0
	ConstStrBlobPtr end();	//curr=data->size();
};
class ConstStrBlobPtr
{
	std::shared_ptr<std::vector<std::string>> check(std::size_t, const std::string &)const;
	std::weak_ptr<std::vector<std::string>> wptr;
	std::size_t curr;
public:
	ConstStrBlobPtr() :curr(0){}
	ConstStrBlobPtr(const StrBlob &a, std::size_t sz = 0) :wptr(a.data), curr(sz){}		//const
	const std::string &deref()const;	//解引用	const
	ConstStrBlobPtr &incr();	//++n;运算符

	friend bool iseq(const ConstStrBlobPtr &, const ConstStrBlobPtr &);
};

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

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

}
StrBlob::size_type StrBlob::size()const
{
	return data->size();
}
bool StrBlob::empty()const
{
	return data->empty();
}
void StrBlob::push_back(const std::string &t)
{
	data->push_back(t);
}
void StrBlob::pop_back()
{
	check(0, "pop_push on empty StrBlob");
	data->pop_back();
}
const std::string &StrBlob::front()
{
	check(0, "front on empty StrBlob");
	return data->front();
}
const std::string &StrBlob::back()
{
	check(0, "back on empty StrBlob");
	return data->back();
}
std::string StrBlob::front()const
{
	return data->front();
}
std::string StrBlob::back()const
{
	return data->back();
}
ConstStrBlobPtr StrBlob::begin()
{
	return ConstStrBlobPtr(*this);
}
ConstStrBlobPtr StrBlob::end()
{
	return ConstStrBlobPtr(*this, data->size());
}
std::shared_ptr<std::vector<std::string>> ConstStrBlobPtr::check(std::size_t i, const std::string &msg)const
{
	auto ret = wptr.lock();	//返回shared_ptr
	if (!ret)
		throw std::runtime_error("unbound StrBlobPtr");
	if (i >= ret->size())
		throw std::out_of_range(msg);
	return ret;
}
const std::string &ConstStrBlobPtr::deref()const
{
	auto ret = check(curr, "dereference past end");
	return (*ret)[curr];
}
ConstStrBlobPtr &ConstStrBlobPtr::incr()
{
	check(curr, "increment past end of StrBlobPtr");
	++curr;
	return *this;
}
#endif

12.23

#include <iostream>
#include <string>
int main()
{
	using namespace std;
	char s1[] = "c++ ";
	char s2[] = "primer";
	char *p = new char[strlen(s1) + strlen(s2)+1]();	//要注意初始化
	strcat(p, s1);
	strcat(p, s2);
	cout << p << endl;
	delete[] p;

	string str1{ "c++" }, str2{ "primer" };
	auto str = str1 + str2;
	cout << str;
	system("pause");
	return 0;
}

12.24

#include <iostream>

int main()
{
	using namespace std;
	char *str = new char[10];
	cin.get(str, 10);//只读取10个字符
	cout << str << endl;
	delete[]str;
	system("pause");
	return 0;
}

12.25

deete [] pa;

12.26

#include <iostream>
#include <string>
#include <memory>	//allcator
//#include <vector>
int main()
{
	using namespace std;
	allocator<string> alloc;
	auto const p = alloc.allocate(10);
	auto q = p;
	string temp;

	//vector<string> vec;
	//while (vec.size() < 10)
	//{
	//	cin >> temp;
	//	++q;
	//	vec.push_back(temp);
	//}
	把vec中的元素拷贝到p指向的内地址中
	//uninitialized_copy(vec.begin(), vec.end(), p);
	while (q - p < 10)
	{
		cout << q - p + 1 << ":";
		cin >> temp;
		alloc.construct(q++, temp);		//把temp传递给string的构造函数构造一个对象存放到q指向的位置	然后++把q指向下一个
	}

	const size_t size = q - p;
	q = p;
	while (q != p + size)
		cout << *q++ << endl;
	while (q != p)
		alloc.destroy(--q);			//删除q指向的地址的对象数据
	alloc.deallocate(p,10);				//释放p开始的10个string的地址的内存
	system("pause");
	return 0;
}

12.27

#ifndef HEAD_H_
#define HEAD_H_
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>	//istringstream
//#include <iterator>	//find
#include <vector>
#include <map>
#include <set>
#include <memory>	//shared_ptr
#include <cctype>
class QueryResult;
class TextQuery
{
	std::vector<std::string> str;	//把文件每一行都保存到string中
	std::map<std::string, std::set<std::vector<std::string>::size_type>> line;	//保存单词对应的行号	相当于map<string,set<unsigned>> line;
	std::string isword(std::string s)
	{
		s[0] = tolower(s[0]);
		if (!isalnum(s[s.size() - 1]))
			s = std::string(s.begin(), s.end() - 1);
		return s;
	}
public:
	TextQuery(std::ifstream &in)
	{
		if (!in)
		{
			std::cerr << "open file error in class";
			exit(1);
		}
		std::string temp;
		while (std::getline(in, temp))
		{
			str.push_back(temp);
			std::istringstream instr(temp);
			std::string t;
			while (instr >> t)
				line[isword(t)].insert(str.size()-1);
		}
	}
	QueryResult query(const std::string &s);
};
class QueryResult
{
public:
	std::string word;
	std::map<std::vector<std::string>::size_type, std::string> mw;
	friend std::ostream &print(std::ostream &os, const QueryResult &qr);
	QueryResult(){}
};

QueryResult TextQuery::query(const std::string &s)
{
	QueryResult qr;
	if (line.find(s) == line.cend())
	{
		std::cout << "not word\n";
		return qr;
	}
	qr.word = s;
	for (auto &x : line[s])
		qr.mw[x] = str[x];
	return qr;
}
#endif

#include "标头.h"
std::ostream &print(std::ostream &os, const QueryResult &qr)
{
	os << qr.word << " occurs " << qr.mw.size() << " times" << std::endl;
	for (auto &x : qr.mw)
		os << "(line " << x.first +1<< ") " << x.second << std::endl;
	return os;
}

void runQuerues(std::ifstream &in)
{
	TextQuery tq(in);
	while (1)
	{
		std::cout << "enter word to look for,or q to quit: ";
		std::string s;
		if (!(std::cin >> s) || s == "q")
			break;
		print(std::cout, tq.query(s)) << std::endl;
	}
}
int main(int argc, char **argv)
{
	using namespace std;
	ifstream infile(argv[1]);
	runQuerues(infile);
	return 0;
}

12.28

#include <iostream>
#include <fstream>
#include <sstream>	//istringstream
#include <vector>
#include <string>
#include <map>
#include <set>
#include <cctype>

int main(int argc, char **argv)
{
	using namespace std;
	ifstream infile(argv[1]);
	if (!infile)
	{
		cerr << "open file error";
		exit(1);
	}
	vector<string> vec;
	map<string, set<vector<string>::size_type>> mw;
	string temp,word;
	while (getline(infile, temp))
	{
		vec.push_back(temp);
		istringstream ist(temp);
		while (ist >> word)
		{
			if (!isalpha(word[0]))
				continue;
			word[0] = tolower(word[0]);
			if (!isalnum(word[word.size() - 1]))
				word.erase(word.size() - 1, 1);
			mw[word].insert(vec.size()-1);
		}
	}
	cout << "enter find word:";
	while (cin >> word)
	{
		if (mw.find(word) == mw.cend())
		{
			cout << "not word!" << endl;
			continue;
		}
		cout << word << " occurs " << mw.size()<< " times" << endl;
		for (auto x : mw[word])
			cout << "(line " << x +1 << ") " << vec[x] << endl;
	}


	//system("pause");
	return 0;
}

12.29

#ifndef HEAD_H_
#define HEAD_H_
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>	//istringstream
//#include <iterator>	//find
#include <vector>
#include <map>
#include <set>
#include <memory>	//shared_ptr
#include <cctype>
class QueryResult;
class TextQuery
{
	std::vector<std::string> str;	//把文件每一行都保存到string中
	std::map<std::string, std::set<std::vector<std::string>::size_type>> line;	//保存单词对应的行号	相当于map<string,set<unsigned>> line;
	std::string isword(std::string s)
	{
		s[0] = tolower(s[0]);
		if (!isalnum(s[s.size() - 1]))
			s = std::string(s.begin(), s.end() - 1);
		return s;
	}
public:
	TextQuery(std::ifstream &in)
	{
		if (!in)
		{
			std::cerr << "open file error in class";
			exit(1);
		}
		std::string temp;
		do 
		{
			if (!std::getline(in, temp))<span style="white-space:pre">			</span>//.................do while
				break;
			str.push_back(temp);
			std::istringstream instr(temp);
			std::string t;
			while (instr >> t)
				line[isword(t)].insert(str.size() - 1);
		} while (1);
	}
	QueryResult query(const std::string &s);
};
class QueryResult
{
public:
	std::string word;
	std::map<std::vector<std::string>::size_type, std::string> mw;
	friend std::ostream &print(std::ostream &os, const QueryResult &qr);
	QueryResult(){}
};

QueryResult TextQuery::query(const std::string &s)
{
	QueryResult qr;
	if (line.find(s) == line.cend())
	{
		std::cout << "not word\n";
		return qr;
	}
	qr.word = s;
	for (auto &x : line[s])
		qr.mw[x] = str[x];
	return qr;
}
#endif

#include "标头.h"
std::ostream &print(std::ostream &os, const QueryResult &qr)
{
	os << qr.word << " occurs " << qr.mw.size() << " times" << std::endl;
	for (auto &x : qr.mw)
		os << "(line " << x.first + 1 << ") " << x.second << std::endl;
	return os;
}

void runQuerues(std::ifstream &in)
{
	TextQuery tq(in);
	do
	{
		std::cout << "enter word to look for,or q to quit: ";
		std::string s;
		if (!(std::cin >> s) || s == "q")
			break;
		print(std::cout, tq.query(s)) << std::endl;
	} while (1);
}
int main(int argc, char **argv)
{
	using namespace std;
	ifstream infile(argv[1]);
	runQuerues(infile);
	return 0;
}

比较倾向以前一个版本，易理解，好判断

12.30

#ifndef HEAD_H_
#define HEAD_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>())	//为智能指针file分配空间
{
	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

#include "标头.h"

void runQueries(std::ifstream &infile)
{
	TextQuery tq(infile);
	while (1)
	{
		std::cout << "enter word to look for, or q to quit:";
		std::string s;
		if (!(std::cin >> s) || s == "q")break;
		print(std::cout, tq.query(s));
	}
}

int main(int argc, char **argv)
{
	using namespace std;
	ifstream infile(argv[1]);
	if (!infile)
	{
		cerr << "open file error!";
		exit(1);
	}
	runQueries(infile);
	return 0;
}

12.31

使用insert时将出现重复行号，必须花费额外的代码处理

12.32

#ifndef HEAD1_H_
#define HEAD1_H_
#include <memory>
#include <initializer_list>
#include <string>
#include <vector>
class StrBlob
{
	std::shared_ptr<std::vector<std::string>> data;
	void check(std::vector<std::string>::size_type i, const std::string &msg)const;
public:
	using size_type = std::vector<std::string>::size_type;
	StrBlob();
	StrBlob(std::initializer_list<std::string> il);
	size_type size()const;//返回vector元素数量
	bool empty()const;//是否为空
	void push_back(const std::string &t);//添加新元素到尾
	void pop_back();//弹出最后一个
	std::string front()const;
	std::string back()const;
	std::string &front();//返回第一个
	std::string &back();//返回最后一个
	const std::shared_ptr<std::vector<std::string>> &shared_ptr()const	//返回data的const引用
	{
		return data;
	}
};
void StrBlob::check(std::vector<std::string>::size_type i, const std::string &msg)const
{
	if (i >= data->size())
		throw std::out_of_range(msg);
}
StrBlob::StrBlob() :data(std::make_shared<std::vector<std::string>>())
{

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

}
StrBlob::size_type StrBlob::size()const
{
	return data->size();
}
bool StrBlob::empty()const
{
	return data->empty();
}
void StrBlob::push_back(const std::string &t)
{
	data->push_back(t);
}
void StrBlob::pop_back()
{
	check(0, "pop_push on empty StrBlob");
	data->pop_back();
}
std::string &StrBlob::front()
{
	check(0, "front on empty StrBlob");
	return data->front();
}
std::string &StrBlob::back()
{
	check(0, "back on empty StrBlob");
	return data->back();
}
std::string StrBlob::front()const
{
	return data->front();
}
std::string StrBlob::back()const
{
	return data->back();
}
#endif

#ifndef HEAD_H_
#define HEAD_H_
#include "标头1.h"
#include <iostream>
#include <fstream>	//ifstream
#include <string>
#include <vector>
#include <sstream>	//istringstream
#include <map>
#include <set>
#include <memory>	//shared_ptr
class QueryResult;
class TextQuery
{

	std::shared_ptr<StrBlob> file;							//保存整个文件内容，按行分
	std::map<std::string, std::shared_ptr<std::set<StrBlob::size_type>>> 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<StrBlob::size_type>> lines;						//记录出现的行号
	std::shared_ptr<StrBlob> file;									//关联到文件内容
public:
	QueryResult(std::string s,const std::shared_ptr<std::set<StrBlob::size_type>> &p, std::shared_ptr<StrBlob> f) :sought(s), lines(p), file(f){}
};

TextQuery::TextQuery(std::ifstream &is) :file(new StrBlob())	//为智能指针file分配空间
{
	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<StrBlob::size_type>);
			lines->insert(n);
		}
	}
}

QueryResult TextQuery::query(const std::string &s)const
{
	static std::shared_ptr<std::set<StrBlob::size_type>> nodata(new std::set<StrBlob::size_type>);	//当没找到单词时返回	内存常驻
	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)
		os << "\t(line " << x + 1 << ") " << qr.file->shared_ptr()->at(x) << std::endl;		//StrBlob需要添加返回data const引用的方法
	return os;
}
#endif

#include "标头.h"


void runQueries(std::ifstream &infile)
{
	TextQuery tq(infile);
	while (1)
	{
		std::cout << "enter word to look for, or q to quit:";
		std::string s;
		if (!(std::cin >> s) || s == "q")break;
		print(std::cout, tq.query(s));
	}
}

int main(int argc, char **argv)
{
	using namespace std;
	ifstream infile(argv[1]);
	if (!infile)
	{
		cerr << "open file error!";
		exit(1);
	}
	runQueries(infile);
	return 0;
}

12.33

class QueryResult
{
	friend std::ostream &print(std::ostream &os, const QueryResult &qr);
	std::string sought;
	std::shared_ptr<std::set<StrBlob::size_type>> lines;						//记录出现的行号
	std::shared_ptr<StrBlob> file;									//关联到文件内容
public:
	QueryResult(std::string s,const std::shared_ptr<std::set<StrBlob::size_type>> &p, std::shared_ptr<StrBlob> f) :sought(s), lines(p), file(f){}
	std::set<StrBlob::size_type>::iterator begin()const{ return lines->begin(); }
	std::set<StrBlob::size_type>::iterator end()const{ return lines->end(); }
	std::shared_ptr<StrBlob> get_file()const{ return file; }
};

2015年12月3日12:15:51