练习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 <iostream>
#include <vector>

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 <iostream>
#include <vector>

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 <iostream>
#include <string>
#include <vector>
#include <list>

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<int> to vector<double>
    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<int> to vector<double>
    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 <iostream>
#include <list>
#include <vector>

using namespace std;

int main()
{
	char c1[5] = "aaaa";
	char c2[5] = "bbbb";
	char c3[5] = "cccc";
	list<char *> l1 = { c1,c2,c3 };
	vector<string> v1;

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

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

	return 0;
}

练习9.15

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

#include <vector>
#include <iostream>

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 <vector>
#include <iostream>
#include <list>

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 <string>
#include <deque>
#include <iostream>

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 <string>
#include <list>
#include <iostream>

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 <string>
#include <list>
#include <deque>
#include <iostream>

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 <iostream>
#include <vector>

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 <iostream>
#include <vector>

using namespace std;

int main()
{
	// vector<int> 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 <iostream>
#include <vector>
#include <list>

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 <iostream>
#include <forward_list>

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 <iostream>
#include <forward_list>

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或forward_list，list 和 forward_list 。与其他容器的一个不同是，迭代器不支持加减运算，究其原因，链表中元素并非在内存中连续存储，因此无法通过地址的加减在元素间远距离移动。因此，应多次调用++来实现与迭代器加法相同的效果。

list:（主要是 iter +=2 改成 ++iter;++iter;）

#include <list>
#include <iostream>

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 ，由于是单向链表结构，删除元素时，需将前驱指针调整为指向下一个节点，因此需维护“前驱”、“后驱”两个迭代器。
forward_list:（修改的比较多，具体看代码）

#include <forward_list>
#include <iostream>

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 <vector>
#include <iostream>

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 <iostream>
#include <vector>
#include <string>

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 <iostream>
#include <vector>
#include <string>

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 <string>
#include <iostream>

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 <string>
#include <iostream>

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 <string>
#include <iostream>

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 <string>
#include <iostream>

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 <string>
#include <iostream>

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 <string>
#include <fstream>
#include <iostream>

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 <string>
#include <iostream>
#include <vector>

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 <string>
#include <iostream>

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 <stack>
#include <string>
#include <iostream>

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;
}
Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生