C++Primer第五版 习题答案 第九章 顺序容器（Sequential Containers）

练习9.1

对于下面的程序任务，vector、deque和list哪种容器最为适合？解释你的选择的理由。如果没有哪一种容器优于其他容器，也请解释理由。

• (a) 读取固定数量的单词，将它们按字典序插入到容器中。我们将在下一章中看到，关联容器更适合这个问题。
• (b) 读取未知数量的单词，总是将单词插入到末尾。删除操作在头部进行。
• © 从一个文件读取未知数量的整数。将这些数排序，然后将它们打印到标准输出。

（a）list，需要在中间插入数据，list最好；
（b）deque，需要在头部和尾部插入或删除元素，选deque；
（c）vector，没有特别的需求选vector。

练习9.2

定义一个list对象，其元素类型是int的deque。

list<deque<int>> l;

练习9.3

构成迭代器范围的迭代器有何限制？

两个迭代器begin和end满足如下条件：
它们指向同一个容器中的元素，或者是容器中的最后一个元素之后的位置，且我们可以通过反复递增begin来到达end。换句话说，end不在begin之前。

练习9.4

编写函数，接受一对指向vector的迭代器和一个int值。在两个迭代器指定的范围中查找给定的值，返回一个布尔值来指出是否找到。

#include 
#include 

using namespace std;

bool find_int(vector<int>::const_iterator begin_, vector<int>::const_iterator end_, int n)
{
	// for(vector::const_iterator begin = begin_;begin != end_;++begin)
	while(begin_ != end_)
	{
		if( *begin_ == n) return true;
		++begin_;
	}

	return false;
}

int main()
{
	vector<int> vi{1,2,3,4,5,6};

	cout << boolalpha << find_int(vi.begin(), vi.end(), 0) << endl;

	return 0;
}

练习9.5

重写上一题的函数，返回一个迭代器指向找到的元素。注意，程序必须处理未找到给定值的情况。

#include 
#include 

using namespace std;

vector<int>::const_iterator find_int(vector<int>::const_iterator begin_, vector<int>::const_iterator end_, int n)
{
	while(begin_ != end_)
	{
		if( *begin_ == n) return begin_;
		++begin_;
	}

	return begin_;
}

int main()
{
	vector<int> vi{1,2,3,4,5,6};

	find_int(vi.begin(), vi.end(), 0);

	return 0;
}

练习9.6

下面的程序有何错误？你应该如何修改它？

list<int> lst1;
list<int>::iterator iter1 = lst1.begin(),
					iter2 = lst1.end();
while (iter1 < iter2) /* ... */

while(iter1 != iter2)

练习9.7

为了索引 int 的 vector 中的元素，应该使用什么类型？

vector<int>::size_type

练习9.8

为了读取string 的list 中的元素，应该使用什么类型？如果写入list，又应该使用什么类型？

list<string>::const_iterator		//read
list<string>::iterator				//write

练习9.9

begin 和 cbegin 两个函数有什么不同？

begin返回容器的iterator类型，当我们需要写访问时使用；
cbegin返回容器的const_iterator类型，当我们不需要写访问时使用。

练习9.10

下面4个对象分别是什么类型？

vector<int> v1;
const vector<int> v2;
auto it1 = v1.begin(), it2 = v2.begin();
auto it3 = v1.cbegin(), it4 = v2.cbegin();

it1：vector<int>::iterator，it2：vector<int>::const_iterator；
it3：vector<int>::const_iterator，it4：vector<int>::const_iterator。

练习9.11

对6种创建和初始化 vector 对象的方法，每一种都给出一个实例。解释每个vector包含什么值。

vector<int> v1;  //v1为空
vector<int> v2 = v1;  //v2为空
vector<int> v3(v2);  //v3为空
vector<int> v4(10);  //10个0
vector<int> v5(10,1);  //10个1
vector<int> v6{1,2,3};  //1 2 3
vector<int> v7 = {1,2,3};  //1 2 3
vector<int> v8(v7.begin(),v7.end());  //1 2 3

练习9.12

对于接受一个容器创建其拷贝的构造函数，和接受两个迭代器创建拷贝的构造函数，解释它们的不同。

两个容器的类型及其元素必须匹配；
传递迭代器参数来拷贝一个范围时，就不要求容器类型相同了，只要能将要拷贝的元素转换。

练习9.13

如何从一个list初始化一个vector？从一个vector又该如何创建？编写代码验证你的答案。

#include 
#include 
#include 
#include 

using std::list; using std::vector; using std::cout; using std::endl;

int main()
{
    list<int> ilst(5, 4);
    vector<int> ivc(5, 5);

    // from list to vector
    vector<double> dvc(ilst.begin(), ilst.end());
    for (auto i : ilst) cout << i << " ";
    cout << endl;
    for (auto d : dvc) cout << d << " ";
    cout << endl;

    // from vector to vector
    vector<double> dvc2(ivc.begin(), ivc.end());
    for (auto i : ivc) cout << i << " ";
    cout << endl;
    for (auto d : dvc2) cout << d << " ";
    cout << endl;
    
    return 0;
}

练习9.14

编写程序，将一个list中的char * 指针元素赋值给一个vector中的string。

#include 
#include 
#include 

using namespace std;

int main()
{
	list<char *> l1 = {"aaa","bbb","ccc"};
	vector<string> v1;

	v1.assign(l1.begin(),l1.end());

	for(auto s : v1)	cout << s << " ";
	cout << endl;

	return 0;
}

练习9.15

编写程序，判定两个vector是否相等。

#include 
#include 

using namespace std;

int main()
{
	vector<int> v1 = {1,2,3};
	vector<int> v2 = {1,3};

	cout << boolalpha << (v1 == v2) << endl;

	return 0;
}

练习9.16

重写上一题的程序，比较一个list中的元素和一个vector中的元素。

#include 
#include 
#include 

using namespace std;

int main()
{
	vector<int> v1 = {1,2,3};
	list<int> l1 = {1,2,3};

	cout << boolalpha << (vector<int>(l1.begin(),l1.end()) == v1) << endl;

	return 0;
}

练习9.17

假定c1 和 c2 是两个容器，下面的比较操作有何限制？

	if (c1 < c2)

c1和c2不能是无序容器，且容器类型要相同，最后，元素类型要支持运算符。

练习9.18

编写程序，从标准输入读取string序列，存入一个deque中。编写一个循环，用迭代器打印deque中的元素。

#include 
#include 
#include 

using namespace std;

int main()
{
	string s;
	deque<string> deque1;

	while(cin >> s)
		deque1.push_back(s);

	for(auto iter = deque1.cbegin(); iter != deque1.cend(); ++iter)
		cout << *iter << " ";
	cout << endl;

	return 0;
}

练习9.19

重写上一题的程序，用list替代deque。列出程序要做出哪些改变。

只需讲deque替换为list。

#include 
#include 
#include 

using namespace std;

int main()
{
	string s;
	list<string> list1;

	while(cin >> s)
		list1.push_back(s);

	for(auto iter = list1.cbegin(); iter != list1.cend(); ++iter)
		cout << *iter << " ";
	cout << endl;
	
	return 0;
}

练习9.20

编写程序，从一个list拷贝元素到两个deque中。值为偶数的所有元素都拷贝到一个deque中，而奇数值元素都拷贝到另一个deque中。

#include 
#include 
#include 
#include 

using namespace std;

int main()
{
	list<int> list1 = {1,2,3,4,5,6};
	deque<int> deque_odd, deque_even;

	for(const auto i : list1)
		(i % 2) ? deque_odd.push_back(i) : deque_even.push_back(i);
		//(i & 0x1 ? deque_odd : deque_even).push_back(i);

	for(const auto i : deque_odd)
		cout << i << " ";
	cout << endl;

	for(const auto i : deque_even)
		cout << i << " ";
	cout << endl;
	
	return 0;
}

练习9.21

如果我们将第308页中使用 insert 返回值将元素添加到list中的循环程序改写为将元素插入到vector中，分析循环将如何工作。

还是一样的操作，实现的是在vector的一个特定位置反复插入元素。具体请查看本节使用insert返回值的内容。

练习9.22

假定iv是一个int的vector，下面的程序存在什么错误？你将如何修改？

vector<int>::iterator iter = iv.begin(),
					  mid = iv.begin() + iv.size() / 2;
while (iter != mid)
	if (*iter == some_val)
		iv.insert(iter, 2 * some_val);

问题：
1.循环不会停止；
2.迭代器在插入操作后会变化。

// cause the reallocation will lead the iterators and references
// after the insertion point to invalid. Thus, we need to call reserver at first.

#include 
#include 

void double_and_insert(std::vector<int>& v, int some_val)
{
    auto mid = [&]{ return v.begin() + v.size() / 2; };
    for (auto curr = v.begin(); curr != mid(); ++curr)
        if (*curr == some_val)
            ++(curr = v.insert(curr, 2 * some_val));
}

int main()
{
    std::vector<int> v{ 1, 9, 1, 9, 9, 9, 1, 1 };
    double_and_insert(v, 1);

    for (auto i : v) 
        std::cout << i << std::endl;
}

练习9.23

在本节第一个程序中，若 c.size() 为1，则val、val2、val3和val4的值会是什么？

同一个元素的拷贝。

练习9.24

编写程序，分别使用 at、下标运算符、front 和 begin 提取一个vector中的第一个元素。在一个空vector上测试你的程序。

#include 
#include 

using namespace std;

int main()
{
	// vector v1 = {1};
	vector<int> v1;

	cout << v1.at(0) << endl;		//terminate called after throwing an instance of 'std::out_of_range'   what():  vector::_M_range_check
	cout << v1[0] << endl;			//Segmentation fault (core dumped)
	cout << v1.front() << endl;		//Segmentation fault (core dumped)
	cout << *v1.begin() << endl;	//Segmentation fault (core dumped)

	return 0;
}

练习9.25

对于第312页中删除一个范围内的元素的程序，如果 elem1 与 elem2 相等会发生什么？如果 elem2 是尾后迭代器，或者 elem1 和 elem2 皆为尾后迭代器，又会发生什么？

如果elem1与elem2相等，则一个元素都不会删除；
如果elem2是尾后迭代器，则会从elem1元素删除到最后一个元素；
如果elem1与elem2都是尾后迭代器，则一个元素都不会删除。

练习9.26

使用下面代码定义的ia，将ia 拷贝到一个vector和一个list中。是用单迭代器版本的erase从list中删除奇数元素，从vector中删除偶数元素。

int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };

#include 
#include 
#include 

using namespace std;

int main()
{
	int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };

	vector<int> v1(ia, end(ia));
	list<int> l1(ia, end(ia));

	for(auto iter = l1.begin(); iter != l1.end(); )
	{		
		if(*iter % 2) iter = l1.erase(iter);
		else ++iter;
	}

	for(auto iter = v1.begin(); iter != v1.end(); )
	{	
			if(*iter % 2 == 0) iter = v1.erase(iter);
			else ++iter;
	}
	
	for(const auto i : l1)
		cout << i << " ";
	cout << endl;

	for(const auto i : v1)
		cout << i << " ";
	cout << endl;

	return 0;
}

练习9.27

编写程序，查找并删除forward_list中的奇数元素。

#include 
#include 

using namespace std;

int main()
{
	forward_list<int> flst = {0,1,2,3,4,5,6,7,8,9};
	auto prev = flst.before_begin();
	auto curr = flst.begin();

	while(curr != flst.end())
	{
		if(*curr % 2)
			curr = flst.erase_after(prev);
		else
		{
			prev = curr;
			++ curr;
		}
	}

	for(const auto i : flst)
		cout << i << " ";
	cout << endl;

	return 0;
}

练习9.28

编写函数，接受一个forward_list和两个string共三个参数。函数应在链表中查找第一个string，并将第二个string插入到紧接着第一个string之后的位置。若第一个string未在链表中，则将第二个string插入到链表末尾。

#include 
#include 

using namespace std;

void insert_string(forward_list<string> &flst, const string &find_str, const string &insert_str)
{
	auto prev = flst.before_begin();
	auto curr = flst.begin();

	while(curr != flst.end())
	{
		if(*curr == find_str)
		{
			flst.insert_after(curr, insert_str);
			return;
		}
		else
		{
			prev = curr;
			++curr;
		}
	}
	flst.insert_after(prev, insert_str);
}

int main()
{
	forward_list<string> flst = {"aa", "bb", "cc", "dd"};

	insert_string(flst, "aaa", "bilibili");

	for(const auto s : flst)
		cout << s << " ";
	cout << endl;

	return 0;
}

练习9.29

假定vec包含25个元素，那么vec.resize(100)会做什么？如果接下来调用vec.resize(10)会做什么？

会添加75个新元素，并对新元素进行初始化；
后面90个元素会被丢弃。

练习9.30

接受单个参数的resize版本对元素类型有什么限制（如果有的话）？

如果元素类型的类类型，则元素类型必须提供一个默认构造函数。

练习9.31

第316页中删除偶数值元素并复制奇数值元素的程序不能用于list或forward_list。为什么？修改程序，使之也能用于这些类型。

list:

#include 
#include 

using namespace std;

int main()
{
	list<int> l1 = {0,1,2,3,4,5,6,7,8,9};
	auto iter = l1.begin();

	while(iter != l1.end())
	{
		if(*iter % 2)
		{
			iter = l1.insert(iter, *iter);
			++iter;
			++iter;
		}else
		{
			iter = l1.erase(iter);
		}
	}

	for(const auto i : l1)
		cout << i << " ";
	cout << endl;

	return 0;
}

forward_list:

#include 
#include 

using namespace std;

int main()
{
	forward_list<int> flst = {0,1,2,3,4,5,6,7,8,9};
	auto iter = flst.begin();
	auto prev = flst.before_begin();

	while(iter != flst.end())
	{
		if(*iter % 2)
		{
			iter = flst.insert_after(iter, *iter);
			prev = iter;
			++iter;
		}else
		{
			iter = flst.erase_after(prev);
		}
	}

	for(const auto i : flst)
		cout << i << " ";
	cout << endl;

	return 0;
}

练习9.32

在第316页的程序中，向下面语句这样调用insert是否合法？如果不合法，为什么？

iter = vi.insert(iter, *iter++);

不合法，insert中的参数运行顺序是未定义的，我们不知道iter运行的是iter+1的状态还是未+1的状态。

练习9.33

在本节最后一个例子中，如果不将insert的结果赋予begin，将会发生什么？编写程序，去掉此赋值语句，验证你的答案。

#include 
#include 

using namespace std;

int main()
{
	vector<int> v1 = {0,1,2,3,4,5,6,7,8,9};
	auto iter = v1.begin();

	while(iter != v1.end())
	{
		++iter;
		// iter = v1.insert(iter, 42);
		v1.insert(iter, 42);
		++iter;
	}

	for(const auto i : v1)
		cout << i << " ";
	cout << endl;

	return 0;
}

插入操作：如果存储空间被重新分配，则迭代器全部失效；如果没有重新分配，插入位置之后的迭代器全部失效。
运行结果为：

$ ./ex33 *** Error in `./ex33': munmap_chunk(): invalid pointer: 0x0000000002118040 ***
Aborted (core dumped)

练习9.34

假定vi是一个保存int的容器，其中有偶数值也有奇数值，分析下面循环的行为，然后编写程序验证你的分析是否正确。

iter = vi.begin();
while (iter != vi.end())
	if (*iter % 2)
		iter = vi.insert(iter, *iter);
	++iter;

会无限循环，当碰到第一个奇数时，iter从inert()中得到插入元素的迭代器，++iter后，迭代器指向的还是之前碰到的那个奇数，下次循环中还是检查这个奇数，程序陷入无限循环。
在测试代码中，如果取消打印行的注释，会一直打印1。

练习9.35

解释一个vector的capacity和size有何区别。

容器的size是指它已经保存的元素的数目；而capacity则是在不分配新的内存空间的前提下最多可以保存多少元素。

练习9.36

一个容器的capacity可能小于它的size吗？

不可能。

练习9.37

为什么list或array没有capacity成员函数？

list所占的空间不是连续的；array是固定size的。

练习9.38

编写程序，探究在你的标准实现中，vector是如何增长的。

#include 
#include 
#include 

using namespace std;

int main()
{
	vector<string> v;
	
	for (string buffer; cin >> buffer; v.push_back(buffer))
		cout << v.size() << " " << v.capacity() << endl;

	return 0;
}

练习9.39

解释下面程序片段做了什么：

vector<string> svec;
svec.reserve(1024);
string word;
while (cin >> word)
	svec.push_back(word);
svec.resize(svec.size() + svec.size() / 2);

为svec预留1024的空间，将输入添加到svec中，将svec的size增加当前size的一半。

练习9.40

如果上一题的程序读入了256个词，在resize之后容器的capacity可能是多少？如果读入了512个、1000个、或1048个呢？

读入了256词、512词时，size增加到384、768，capacity不变；
读入1000词或1048词后，size增加到1500、1572，capacity至少增大到可以容纳当前size。

练习9.41

编写程序，从一个vector初始化一个string。

#include 
#include 
#include 

using namespace std;

int main()
{
	vector<char> vc = {'a','b','c'};
	string s(vc.begin(), vc.end());

	for(const auto c : vc)
		cout << c << " ";
	cout << endl;

	return 0;
}

练习9.42

假定你希望每次读取一个字符存入一个string中，而且知道最少需要读取100个字符，应该如何提高程序的性能？

string s;
s.reserve(100);

练习9.43

编写一个函数，接受三个string参数是s、oldVal 和newVal。使用迭代器及insert和erase函数将s中所有oldVal替换为newVal。测试你的程序，用它替换通用的简写形式，如，将"tho"替换为"though",将"thru"替换为"through"。

在gcc上编译失败（当时的测试环境为ubuntu 14.04+gcc version 4.8.4），在Ubuntu16.06+gcc5.4可以通过编译并成功运行。

#include 
#include 

using namespace std;

void replace_with_str(string &s, const string &oldVal, const string &newVal)
{
	auto iter = s.begin();

	while(iter != s.end())
	{
		if((s.end()-iter) < (oldVal.end()- oldVal.begin()))
		{
			return;
		}
		if(oldVal == string(iter, iter+oldVal.size()))
		{
			iter = s.erase(iter, iter+oldVal.size());
			iter = s.insert(iter, newVal.begin(), newVal.end());
			iter += newVal.size();
		}else
			++iter;
	}
}

int main()
{
	string s("tho thru");

	replace_with_str(s, "tho", "though");
	cout << s << endl;

	replace_with_str(s, "thru", "through");
	cout << s << endl;

	return 0;
}

练习9.44

重写上一题的函数，这次使用一个下标和replace。

#include 
#include 

using namespace std;

void replace_with_str(string &s, const string &oldVal, const string &newVal)
{
	// auto iter = s.begin();
	string::size_type index = 0;

	while(index != s.size())
	{
		if(oldVal == string(s, index, oldVal.size()))
		{
			s.replace(index, oldVal.size(), newVal);
		}
		++index;
	}
}

int main()
{
	string s("tho thru tho");

	replace_with_str(s, "tho", "though");
	cout << s << endl;

	replace_with_str(s, "thru", "through");
	cout << s << endl;

	return 0;
}

练习9.45

编写一个函数，接受一个表示名字的string参数和两个分别表示前缀（如"Mr.“或"Mrs.”）和后缀（如"Jr.“或"III”）的字符串。使用迭代器及insert和append函数将前缀和后缀添加到给定的名字中，将生成的新string返回。

#include 
#include 

using namespace std;

string add_pre_post(const string &name, const string &pre, const string &post)
{
	string s = name;
	s.insert(s.begin(), pre.cbegin(), pre.cend());
	return s.append(post);
}

int main()
{
	string name("tx");

	cout << add_pre_post(name, "Mr.", "Jr.") << endl;

	cout << add_pre_post("TX", "Mr.", "Jr.") << endl;

	return 0;
}

练习9.46

重写上一题的函数，这次使用位置和长度来管理string，并只使用insert。

#include 
#include 

using namespace std;

string add_pre_post(const string &name, const string &pre, const string &post)
{
	string s = name;
	s.insert(0, pre);
	return s.insert(s.size(), post);
}

int main()
{
	string name("tx");

	cout << add_pre_post(name, "Mr.", "Jr.") << endl;

	cout << add_pre_post("TX", "Mr.", "Jr.") << endl;

	return 0;
}

练习9.47

编写程序，首先查找string"ab2c3d7R4E6"中每个数字字符，然后查找其中每个字母字符。编写两个版本的程序，第一个要使用find_first_of，第二个要使用find_first_not_of。

#include 
#include 

using namespace std;

int main()
{
	string numbers{"123456789"};
	string alphabet{"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"};
	string str{"ab2c3d7R4E6"};

	for(string::size_type pos = 0; (pos = str.find_first_of(numbers, pos)) != string::npos; ++pos)
	{
		cout << "found number at index: " << pos
		<< " element is " << str[pos] << endl;
	}
	for(string::size_type pos = 0; (pos = str.find_first_of(alphabet, pos)) != string::npos; ++pos)
	{
		cout << "found alphabet at index: " << pos
		<< " element is " << str[pos] << endl;
	}

	for(string::size_type pos = 0; (pos = str.find_first_not_of(alphabet, pos)) != string::npos; ++pos)
	{
		cout << "found number at index: " << pos
		<< " element is " << str[pos] << endl;
	}
	for(string::size_type pos = 0; (pos = str.find_first_not_of(numbers, pos)) != string::npos; ++pos)
	{
		cout << "found alphabet at index: " << pos
		<< " element is " << str[pos] << endl;
	}

	return 0;
}

练习9.48

假定name和numbers的定义如325页所示，numbers.find(name)返回什么？

string::npos

练习9.49

如果一个字母延伸到中线之上，如d 或 f，则称其有上出头部分（ascender）。如果一个字母延伸到中线之下，如p或g，则称其有下出头部分（descender）。编写程序，读入一个单词文件，输出最长的既不包含上出头部分，也不包含下出头部分的单词。

//
//  ex9_49.cpp
//  Exercise 9.49
//
//  Created by pezy on 12/5/14.
//
//  @Brief  A letter has an ascender if, as with d or f, part of the letter extends
//          above the middle of the line.
//          A letter has a descender if, as with p or g, part of the letter extends below the line.
//          Write a program that reads a file containing words and reports the longest word
//          that contains neither ascenders nor descenders.
//  
//  @Refactor  @Yue Wang Jun 2015
//

#include 
#include 
#include 

using std::string; using std::cout; using std::endl; using std::ifstream;

int main()
{
    ifstream ifs("letter.txt");
    if (!ifs) return -1;

    string longest;
    auto update_with = [&longest](string const& curr)
    {
        if (string::npos == curr.find_first_not_of("aceimnorsuvwxz"))
            longest = longest.size() < curr.size() ? curr : longest;
    };
    for (string curr; ifs >> curr; update_with(curr));
    cout << longest << endl;

    return 0;
}

练习9.50

编写程序处理一个vector，其元素都表示整型值。计算vector中所有元素之和。修改程序，使之计算表示浮点值的string之和。

#include 
#include 
#include 

using namespace std;

int main()
{
	vector<string> v1(10, "5");
	int sum_int = 0;
	for(const auto s : v1)
		sum_int += stoi(s);
	cout << sum_int << endl;

	vector<string> v2(10, "3.14");
	double sum_double = 0;
	for(const auto s : v2)
		sum_double += stod(s);
	cout << sum_double << endl;

	return 0;
}

练习9.51

设计一个类，它有三个unsigned成员，分别表示年、月和日。为其编写构造函数，接受一个表示日期的string参数。你的构造函数应该能处理不同的数据格式，如January 1,1900、1/1/1990、Jan 1 1900 等。

#include 
#include 

using namespace std;

class my_date
{
public:
	my_date(const string&);
private:
	unsigned int year;
	unsigned int month;
	unsigned int day;
};

my_date::my_date(const string &s)
{
	string date_str = s;
	string::size_type index1 = 0;
	string::size_type index2 = 0;

	if(s.find(',') != string::npos)//January 1, 1900
	{
		index1 = s.find(' ');
		index2 = s.find(',', index1+1);
		cout << "year: " << s.substr(index2+1, s.size()) << "; month: " << s.substr(0, index1) << "; day: " << s.substr(index1+1, index2-index1-1) << endl;
		// month = stoi(s.substr(0, index1));
		if( s.find("Jan") < s.size() )  month = 1;
		if( s.find("Feb") < s.size() )  month = 2;
		if( s.find("Mar") < s.size() )  month = 3;
		if( s.find("Apr") < s.size() )  month = 4;
		if( s.find("May") < s.size() )  month = 5;
		if( s.find("Jun") < s.size() )  month = 6;
		if( s.find("Jul") < s.size() )  month = 7;
		if( s.find("Aug") < s.size() )  month = 8;
		if( s.find("Sep") < s.size() )  month = 9;
		if( s.find("Oct") < s.size() )  month =10;
		if( s.find("Nov") < s.size() )  month =11;
		if( s.find("Dec") < s.size() )  month =12;
		day = stoi(s.substr(index1+1, index2-index1-1));
		year = stoi(s.substr(index2+1, s.size()));
	}else if(s.find('/') != string::npos)//1/1/1900
	{
		index1 = s.find('/');
		index2 = s.find('/', index1+1);
		cout << "year: " << s.substr(index2+1, s.size()) << "; month: " << s.substr(0, index1) << "; day: " << s.substr(index1+1, index2-index1-1) << endl;
		month = stoi(s.substr(0, index1));
		day = stoi(s.substr(index1+1, index2-index1-1));
		year = stoi(s.substr(index2+1, s.size()));
	}else//Jan 1 1900
	{
		index1 = s.find(' ');
		index2 = s.find(' ', index1+1);
		cout << "year: " << s.substr(index2+1, s.size()) << "; month: " << s.substr(0, index1) << "; day: " << s.substr(index1+1, index2-index1-1) << endl;
		// month = stoi(s.substr(0, index1));
		if( s.find("Jan") < s.size() )  month = 1;
		if( s.find("Feb") < s.size() )  month = 2;
		if( s.find("Mar") < s.size() )  month = 3;
		if( s.find("Apr") < s.size() )  month = 4;
		if( s.find("May") < s.size() )  month = 5;
		if( s.find("Jun") < s.size() )  month = 6;
		if( s.find("Jul") < s.size() )  month = 7;
		if( s.find("Aug") < s.size() )  month = 8;
		if( s.find("Sep") < s.size() )  month = 9;
		if( s.find("Oct") < s.size() )  month =10;
		if( s.find("Nov") < s.size() )  month =11;
		if( s.find("Dec") < s.size() )  month =12;
		day = stoi(s.substr(index1+1, index2-index1-1));
		year = stoi(s.substr(index2+1, s.size()));
	}
	cout << "year: " << year << "; month: " << month << "; day: " << day << endl;
}

int main()
{
	my_date my_date1("January 1, 1900");
	my_date my_date2("1/1/1900");
	my_date my_date3("Jan 1 1900");

	return 0;
}

练习9.52

使用stack处理括号化的表达式。当你看到一个左括号，将其记录下来。当你在一个左括号之后看到一个右括号，从stack中pop对象，直至遇到左括号，将左括号也一起弹出栈。然后将一个值（括号内的运算结果）push到栈中，表示一个括号化的（子）表达式已经处理完毕，被其运算结果所替代。

看了半天没看懂，还以为要写个计算器，贴上大神代码：

//
//  ex9_52.cpp
//  Exercise 9.52 
//
//  Created by pezy on 12/5/14.
//
//  @Brief  Use a stack to process parenthesized expressions. 
//          When you see an open parenthesis, note that it was seen. 
//          When you see a close parenthesis after an open parenthesis, 
//          pop elements down to and including the open parenthesis off the stack. 
//          push a value onto the stack to indicate that a parenthesized expression was replaced. 

#include 
#include 
#include 

using std::string; using std::cout; using std::endl; using std::stack;

int main()
{
    string expression{ "This is (pezy)." };
    bool bSeen = false;
    stack<char> stk;
    for (const auto &s : expression)
    {
        if (s == '(') { bSeen = true; continue; }
        else if (s == ')') bSeen = false;
        
        if (bSeen) stk.push(s);
    }
    
    string repstr;
    while (!stk.empty())
    {
        repstr += stk.top();
        stk.pop();
    }
    
    expression.replace(expression.find("(")+1, repstr.size(), repstr);
    
    cout << expression << endl;
    
    return 0;
}