C++ primer plus(第六版)编程练习答案第16章 string类和标准模板库

- 日理万妓 2024-03-24 08:38 22阅读 0赞

## 一、程序清单 ##

## str1.cpp ##

// str1.cpp -- introducing the string class
    #include <iostream>
    #include <string>
    // using string constructors
    
    int main()
    {
    	using namespace std;
    	string one("Lottery Winner!");     // ctor #1
    	cout << one << endl;               // overloaded <<
    	string two(20, '$');               // ctor #2
    	cout << two << endl;
    	string three(one);                 // ctor #3
    	cout << three << endl;
    	one += " Oops!";                   // overloaded +=
    	cout << one << endl;
    	two = "Sorry! That was ";
    	three[0] = 'P';
    	string four;                       // ctor #4
    	four = two + three;                // overloaded +, =
    	cout << four << endl;
    	char alls[] = "All's well that ends well";
    	string five(alls, 20);              // ctor #5
    	cout << five << "!\n";
    	string six(alls + 6, alls + 10);     // ctor #6
    	cout << six << ", ";
    	string seven(&five[6], &five[10]); // ctor #6 again
    	cout << seven << "...\n";
    	string eight(four, 7, 16);         // ctor #7
        //将four的第八个字符(位置7)开始，将16个字符复制到eight中
    	cout << eight << " in motion!" << endl;
    	// std::cin.get();
    	return 0;
    }

执行结果：

Lottery Winner!
    $$$$$$$$$$$$$$$$$$$$
    Lottery Winner!
    Lottery Winner! Oops!
    Sorry! That was Pottery Winner!
    All's well that ends!
    well, well...
    That was Pottery in motion!

## strfile.cpp ##

// strfile.cpp -- read strings from a file
    #include <iostream>
    #include <fstream>
    #include <string>
    #include <cstdlib>
    int main()
    {
    	using namespace std;
    	ifstream fin;
    	fin.open("tobuy.txt");
    	if (fin.is_open() == false)
    	{
    		cerr << "Can't open file. Bye.\n";
    		exit(EXIT_FAILURE);
    	}
    	string item;
    	int count = 0;
    
    	getline(fin, item, ':');
    	while (fin)  // while input is good
    	{
    		++count;
    		cout << count << ": " << item << endl;
    		getline(fin, item, ':');
    	}
    	cout << "Done\n";
    	fin.close();
    	// std::cin.get();
    	// std::cin.get();
    	return 0;
    }

## tobuy.txt ##

sardines:chocolate ice cream:pop corn:leeks:
    cottage cheese;olive oil:butter:tofu:

![watermark,type\_d3F5LXplbmhlaQ,shadow\_50,text\_Q1NETiBA6ZW\_5rKZ5pyJ6IKl6bG8,size\_20,color\_FFFFFF,t\_70,g\_se,x\_16][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16]

## hangman.cpp ##

// hangman.cpp -- some string methods
    #include <iostream>
    #include <string>
    #include <cstdlib>
    #include <ctime>
    #include <cctype>
    using std::string;
    const int NUM = 26;
    const string wordlist[NUM] = { "apiary", "beetle", "cereal",
    	"danger", "ensign", "florid", "garage", "health", "insult",
    	"jackal", "keeper", "loaner", "manage", "nonce", "onset",
    	"plaid", "quilt", "remote", "stolid", "train", "useful",
    	"valid", "whence", "xenon", "yearn", "zippy" };
    
    int main()
    {
    	using std::cout;
    	using std::cin;
    	using std::tolower;
    	using std::endl;
    
    	std::srand(std::time(0));
    	char play;
    	cout << "Will you play a word game? <y/n> ";
    	cin >> play;
    	play = tolower(play);
    	while (play == 'y')
    	{
    		string target = wordlist[std::rand() % NUM];
    		int length = target.length();
    		string attempt(length, '-');
    		string badchars;
    		int guesses = 6;
    		cout << "Guess my secret word. It has " << length
    			<< " letters, and you guess\n"
    			<< "one letter at a time. You get " << guesses
    			<< " wrong guesses.\n";
    		cout << "Your word: " << attempt << endl;
    		while (guesses > 0 && attempt != target)
    		{
    			char letter;
    			cout << "Guess a letter: ";
    			cin >> letter;
    			if (badchars.find(letter) != string::npos
    				|| attempt.find(letter) != string::npos)
    			{
    				cout << "You already guessed that. Try again.\n";
    				continue;
    			}
    			int loc = target.find(letter);
    			if (loc == string::npos)
    			{
    				cout << "Oh, bad guess!\n";
    				--guesses;
    				badchars += letter; // add to string
    			}
    			else
    			{
    				cout << "Good guess!\n";
    				attempt[loc] = letter;
    				// check if letter appears again
    				loc = target.find(letter, loc + 1);
    				while (loc != string::npos)
    				{
    					attempt[loc] = letter;
    					loc = target.find(letter, loc + 1);
    				}
    			}
    			cout << "Your word: " << attempt << endl;
    			if (attempt != target)
    			{
    				if (badchars.length() > 0)
    					cout << "Bad choices: " << badchars << endl;
    				cout << guesses << " bad guesses left\n";
    			}
    		}
    		if (guesses > 0)
    			cout << "That's right!\n";
    		else
    			cout << "Sorry, the word is " << target << ".\n";
    
    		cout << "Will you play another? <y/n> ";
    		cin >> play;
    		play = tolower(play);
    	}
    
    	cout << "Bye\n";
    
    	return 0;
    }

执行结果：

1: sardines
    2: chocolate ice cream
    3: pop corn
    4: leeks
    5:
    cottage cheese;olive oil
    6: butter
    7: tofu
    Done

## hangman.cpp ##

执行结果：

Will you play a word game? <y/n> y
    Guess my secret word. It has 6 letters, and you guess
    one letter at a time. You get 6 wrong guesses.
    Your word: ------
    Guess a letter: e
    Good guess!
    Your word: -ee-e-
    6 bad guesses left
    Guess a letter: l
    Oh, bad guess!
    Your word: -ee-e-
    Bad choices: l
    5 bad guesses left
    Guess a letter: g
    Oh, bad guess!
    Your word: -ee-e-
    Bad choices: lg
    4 bad guesses left
    Guess a letter: a
    Oh, bad guess!
    Your word: -ee-e-
    Bad choices: lga
    3 bad guesses left
    Guess a letter: v
    Oh, bad guess!
    Your word: -ee-e-
    Bad choices: lgav
    2 bad guesses left
    Guess a letter: l
    You already guessed that. Try again.
    Guess a letter: p
    Good guess!
    Your word: -eepe-
    Bad choices: lgav
    2 bad guesses left
    Guess a letter: p
    You already guessed that. Try again.
    Guess a letter: k
    Good guess!
    Your word: keepe-
    Bad choices: lgav
    2 bad guesses left
    Guess a letter: c
    Oh, bad guess!
    Your word: keepe-
    Bad choices: lgavc
    1 bad guesses left
    Guess a letter: r
    Good guess!
    Your word: keeper
    That's right!
    Will you play another? <y/n> n
    Bye

Guess a letter: o
    Oh, bad guess!
    Your word: ------
    Bad choices: gno
    3 bad guesses left
    Guess a letter: e
    Oh, bad guess!
    Your word: ------
    Bad choices: gnoe
    2 bad guesses left
    Guess a letter: p
    Good guess!
    Your word: -p----
    Bad choices: gnoe
    2 bad guesses left
    Guess a letter: a
    Good guess!
    Your word: ap-a--
    Bad choices: gnoe
    2 bad guesses left
    Guess a letter: i
    Good guess!
    Your word: apia--
    Bad choices: gnoe
    2 bad guesses left
    Guess a letter: r
    Good guess!
    Your word: apiar-
    Bad choices: gnoe
    2 bad guesses left
    Guess a letter: y
    Good guess!
    Your word: apiary
    That's right!
    Will you play another? <y/n> n
    Bye

## str2.cpp ##

// str2.cpp -- capacity() and reserve()
    #include <iostream>
    #include <string>
    int main()
    {
    	using namespace std;
    	string empty;
    	string small = "bit";
    	string larger = "Elephants are a girl's best friend";
    	cout << "Sizes:\n";
    	cout << "\tempty: " << empty.size() << endl;
    	cout << "\tsmall: " << small.size() << endl;
    	cout << "\tlarger: " << larger.size() << endl;
    	cout << "Capacities:\n";
    	cout << "\tempty: " << empty.capacity() << endl;
    	cout << "\tsmall: " << small.capacity() << endl;
    	cout << "\tlarger: " << larger.capacity() << endl;
    	empty.reserve(50);
    	cout << "Capacity after empty.reserve(50): "
    		<< empty.capacity() << endl;
    	// cin.get();
    	return 0;
    }

执行结果：

Sizes:
            empty: 0
            small: 3
            larger: 34
    Capacities:
            empty: 15
            small: 15
            larger: 47
    Capacity after empty.reserve(50): 63

## smrtptrs.cpp ##

// smrtptrs.cpp -- using three kinds of smart pointers
    #include <iostream>
    #include <string>
    #include <memory>
    
    class Report
    {
    private:
    	std::string str;
    public:
    	Report(const std::string s) : str(s) { std::cout << "Object created!\n"; }
    	~Report() { std::cout << "Object deleted!\n"; }
    	void comment() const { std::cout << str << "\n"; }
    };
    
    int main()
    {
    	{
    		std::auto_ptr<Report> ps(new Report("using auto_ptr"));
    		ps->comment();   // use -> to invoke a member function
    	}
    	{
    		std::shared_ptr<Report> ps(new Report("using shared_ptr"));
    		ps->comment();
    	}
    	{
    		std::unique_ptr<Report> ps(new Report("using unique_ptr"));
    		ps->comment();
    	}
    	// std::cin.get();  
    	return 0;
    }

执行结果：

Object created!
    using auto_ptr
    Object deleted!
    Object created!
    using shared_ptr
    Object deleted!
    Object created!
    using unique_ptr
    Object deleted!

## **fowl.cpp**  ##

// fowl.cpp  -- auto_ptr a poor choice
    #include <iostream>
    #include <string>
    #include <memory>
    
    int main()
    {
    	using namespace std;
    	auto_ptr<string> films[5] =
    	{
    		auto_ptr<string>(new string("Fowl Balls")),
    		auto_ptr<string>(new string("Duck Walks")),
    		auto_ptr<string>(new string("Chicken Runs")),
    		auto_ptr<string>(new string("Turkey Errors")),
    		auto_ptr<string>(new string("Goose Eggs"))
    	};
    	auto_ptr<string> pwin;
    	pwin = films[2];   // films[2] loses ownership
    
    	cout << "The nominees for best avian baseball film are\n";
    	for (int i = 0; i < 5; i++)
    		cout << *films[i] << endl;
    	cout << "The winner is " << *pwin << "!\n";
    	// cin.get();
    	return 0;
    }

执行结果：

The nominees for best avian baseball film are
    Fowl Balls
    Duck Walks

## fow2.cpp ##

将auto\_ptr修改为shared\_ptr得到的结果如下所示：

// fow2.cpp  -- auto_ptr a poor choice
    #include <iostream>
    #include <string>
    #include <memory>
    
    int main()
    {
    	using namespace std;
    	shared_ptr<string> films[5] =
    	{
    		auto_ptr<string>(new string("Fowl Balls")),
    		auto_ptr<string>(new string("Duck Walks")),
    		auto_ptr<string>(new string("Chicken Runs")),
    		auto_ptr<string>(new string("Turkey Errors")),
    		auto_ptr<string>(new string("Goose Eggs"))
    	};
    	shared_ptr<string> pwin;
    	pwin = films[2];   // films[2] loses ownership
    
    	cout << "The nominees for best avian baseball film are\n";
    	for (int i = 0; i < 5; i++)
    		cout << *films[i] << endl;
    	cout << "The winner is " << *pwin << "!\n";
    	// cin.get();
    	return 0;
    }

执行结果：

The nominees for best avian baseball film are
    Fowl Balls
    Duck Walks
    Chicken Runs
    Turkey Errors
    Goose Eggs
    The winner is Chicken Runs!

## vect1.cpp ##

// vect1.cpp -- introducing the vector template
    #include <iostream>
    #include <string>
    #include <vector>
    
    const int NUM = 5;
    int main()
    {
    	using std::vector;
    	using std::string;
    	using std::cin;
    	using std::cout;
    	using std::endl;
    
    	vector<int> ratings(NUM);
    	vector<string> titles(NUM);
    	cout << "You will do exactly as told. You will enter\n"
    		<< NUM << " book titles and your ratings (0-10).\n";
    	int i;
    	for (i = 0; i < NUM; i++)
    	{
    		cout << "Enter title #" << i + 1 << ": ";
    		getline(cin, titles[i]);
    		cout << "Enter your rating (0-10): ";
    		cin >> ratings[i];
    		cin.get();
    	}
    	cout << "Thank you. You entered the following:\n"
    		<< "Rating\tBook\n";
    	for (i = 0; i < NUM; i++)
    	{
    		cout << ratings[i] << "\t" << titles[i] << endl;
    	}
    	// cin.get();
    
    	return 0;
    }

执行结果：

You will do exactly as told. You will enter
    5 book titles and your ratings (0-10).
    Enter title #1: The Cat Who Knew C++
    Enter your rating (0-10): 6
    Enter title #2:  Felonious Felines
    Enter your rating (0-10): 4
    Enter title #3: Warlords of Wonk
    Enter your rating (0-10): 3
    Enter title #4:  Don't Touch That Metaphor
    Enter your rating (0-10): 5
    Enter title #5: Panic Oriented Programming
    Enter your rating (0-10): 8
    Thank you. You entered the following:
    Rating  Book
    6       The Cat Who Knew C++
    4        Felonious Felines
    3       Warlords of Wonk
    5        Don't Touch That Metaphor
    8       Panic Oriented Programming

## vect2.cpp ##

// vect2.cpp -- methods and iterators
    #include <iostream>
    #include <string>
    #include <vector>
    
    struct Review {
    	std::string title;
    	int rating;
    };
    bool FillReview(Review & rr);
    void ShowReview(const Review & rr);
    
    int main()
    {
    	using std::cout;
    	using std::vector;
    	vector<Review> books;
    	Review temp;
    	while (FillReview(temp))
    		books.push_back(temp);
    	int num = books.size();
    	if (num > 0)
    	{
    		cout << "Thank you. You entered the following:\n"
    			<< "Rating\tBook\n";
    		for (int i = 0; i < num; i++)
    			ShowReview(books[i]);
    		cout << "Reprising:\n"
    			<< "Rating\tBook\n";
    		vector<Review>::iterator pr;
    		for (pr = books.begin(); pr != books.end(); pr++)
    			ShowReview(*pr);
    		vector <Review> oldlist(books);     // copy constructor used
    		if (num > 3)
    		{
    			// remove 2 items
    			books.erase(books.begin() + 1, books.begin() + 3);//移除第二项和第四项
    			cout << "After erasure:\n";
    			for (pr = books.begin(); pr != books.end(); pr++)
    				ShowReview(*pr);
    			// insert 1 item
    			books.insert(books.begin(), oldlist.begin() + 1,
    				oldlist.begin() + 2);//[1,2)在开始的位置处插入第二项内容
    			cout << "After insertion:\n";
    			for (pr = books.begin(); pr != books.end(); pr++)
    				ShowReview(*pr);
    		}
    		books.swap(oldlist);
    		cout << "Swapping oldlist with books:\n";
    		for (pr = books.begin(); pr != books.end(); pr++)
    			ShowReview(*pr);
    	}
    	else
    		cout << "Nothing entered, nothing gained.\n";
    	// std::cin.get();
    	return 0;
    }
    
    bool FillReview(Review & rr)
    {
    	std::cout << "Enter book title (quit to quit): ";
    	std::getline(std::cin, rr.title);
    	if (rr.title == "quit")
    		return false;
    	std::cout << "Enter book rating: ";
    	std::cin >> rr.rating;
    	if (!std::cin)
    		return false;
    	// get rid of rest of input line
    	while (std::cin.get() != '\n')
    		continue;
    	return true;
    }
    
    void ShowReview(const Review & rr)
    {
    	std::cout << rr.rating << "\t" << rr.title << std::endl;
    }

执行结果：

Enter book title (quit to quit): The Cat Who Knew C++
    Enter book rating: 5
    Enter book title (quit to quit): Candid Canines
    Enter book rating: 7
    Enter book title (quit to quit): Warriors of Wonk
    Enter book rating: 4
    Enter book title (quit to quit): Quantum Manners
    Enter book rating: 8
    Enter book title (quit to quit): quit
    Thank you. You entered the following:
    Rating  Book
    5       The Cat Who Knew C++
    7       Candid Canines
    4       Warriors of Wonk
    8       Quantum Manners
    Reprising:
    Rating  Book
    5       The Cat Who Knew C++
    7       Candid Canines
    4       Warriors of Wonk
    8       Quantum Manners
    After erasure:
    5       The Cat Who Knew C++
    8       Quantum Manners
    After insertion:
    7       Candid Canines
    5       The Cat Who Knew C++
    8       Quantum Manners
    Swapping oldlist with books:
    5       The Cat Who Knew C++
    7       Candid Canines
    4       Warriors of Wonk
    8       Quantum Manners

## vect3.cpp ##

// vect3.cpp -- using STL functions
    #include <iostream>
    #include <string>
    #include <vector>
    #include <algorithm>
    
    struct Review {
    	std::string title;
    	int rating;
    };
    
    bool operator<(const Review & r1, const Review & r2);
    bool worseThan(const Review & r1, const Review & r2);
    bool FillReview(Review & rr);
    void ShowReview(const Review & rr);
    int main()
    {
    	using namespace std;
    
    	vector<Review> books;
    	Review temp;
    	while (FillReview(temp))
    		books.push_back(temp);
    	if (books.size() > 0)
    	{
    		cout << "Thank you. You entered the following "
    			<< books.size() << " ratings:\n"
    			<< "Rating\tBook\n";
    		for_each(books.begin(), books.end(), ShowReview);
    
    		sort(books.begin(), books.end());
    		cout << "Sorted by title:\nRating\tBook\n";
    		for_each(books.begin(), books.end(), ShowReview);
    
    		sort(books.begin(), books.end(), worseThan);
    		cout << "Sorted by rating:\nRating\tBook\n";
    		for_each(books.begin(), books.end(), ShowReview);
    
    		random_shuffle(books.begin(), books.end());
    		cout << "After shuffling:\nRating\tBook\n";
    		for_each(books.begin(), books.end(), ShowReview);
    	}
    	else
    		cout << "No entries. ";
    	cout << "Bye.\n";
    	// cin.get();
    	return 0;
    }
    
    bool operator<(const Review & r1, const Review & r2)
    {
    	if (r1.title < r2.title)
    		return true;
    	else if (r1.title == r2.title && r1.rating < r2.rating)
    		return true;
    	else
    		return false;
    }
    
    bool worseThan(const Review & r1, const Review & r2)
    {
    	if (r1.rating < r2.rating)
    		return true;
    	else
    		return false;
    }
    
    bool FillReview(Review & rr)
    {
    	std::cout << "Enter book title (quit to quit): ";
    	std::getline(std::cin, rr.title);
    	if (rr.title == "quit")
    		return false;
    	std::cout << "Enter book rating: ";
    	std::cin >> rr.rating;
    	if (!std::cin)
    		return false;
    	// get rid of rest of input line
    	while (std::cin.get() != '\n')
    		continue;
    	return true;
    }
    
    void ShowReview(const Review & rr)
    {
    	std::cout << rr.rating << "\t" << rr.title << std::endl;
    }

执行结果：

Enter book title (quit to quit): The Cat Who Can Teach You Weight Loss
    Enter book rating: 8
    Enter book title (quit to quit): The Dogs of Dharma
    Enter book rating: 6
    Enter book title (quit to quit): The Wimps of Wonk
    Enter book rating: 3
    Enter book title (quit to quit): Farewell and Delete
    Enter book rating: 7
    Enter book title (quit to quit): quit
    Thank you. You entered the following 4 ratings:
    Rating  Book
    8       The Cat Who Can Teach You Weight Loss
    6       The Dogs of Dharma
    3       The Wimps of Wonk
    7       Farewell and Delete
    Sorted by title:
    Rating  Book
    7       Farewell and Delete
    8       The Cat Who Can Teach You Weight Loss
    6       The Dogs of Dharma
    3       The Wimps of Wonk
    Sorted by rating:
    Rating  Book
    3       The Wimps of Wonk
    6       The Dogs of Dharma
    7       Farewell and Delete
    8       The Cat Who Can Teach You Weight Loss
    After shuffling:
    Rating  Book
    3       The Wimps of Wonk
    6       The Dogs of Dharma
    8       The Cat Who Can Teach You Weight Loss
    7       Farewell and Delete
    Bye.

## copyit.cpp ##

// copyit.cpp -- copy() and iterators
    #include <iostream>
    #include <iterator>
    #include <vector>
    
    int main()
    {
    	using namespace std;
    
    	int casts[10] = { 6, 7, 2, 9 ,4 , 11, 8, 7, 10, 5 };
    	vector<int> dice(10);
    	// copy from array to vector
    	copy(casts, casts + 10, dice.begin());
    	cout << "Let the dice be cast!\n";
    	// create an ostream iterator
    	ostream_iterator<int, char> out_iter(cout, " ");
    	// copy from vector to output
    	copy(dice.begin(), dice.end(), out_iter);
    	cout << endl;
    	cout << "Implicit use of reverse iterator.\n";
    	copy(dice.rbegin(), dice.rend(), out_iter);
    	cout << endl;
    	cout << "Explicit use of reverse iterator.\n";
    	// vector<int>::reverse_iterator ri;  // use if auto doesn't work
    	for (auto ri = dice.rbegin(); ri != dice.rend(); ++ri)
    		cout << *ri << ' ';
    	cout << endl;
    	// cin.get();
    	return 0;
    }

执行结果:

6 7 2 9 4 11 8 7 10 5
    Implicit use of reverse iterator.
    5 10 7 8 11 4 9 2 7 6
    Explicit use of reverse iterator.
    5 10 7 8 11 4 9 2 7 6

## inserts.cpp ##

// inserts.cpp -- copy() and insert iterators
    #include <iostream>
    #include <string>
    #include <iterator>
    #include <vector>
    #include <algorithm>
    
    void output(const std::string & s) { std::cout << s << " "; }
    
    int main()
    {
    	using namespace std;
    	string s1[4] = { "fine", "fish", "fashion", "fate" };
    	string s2[2] = { "busy", "bats" };
    	string s3[2] = { "silly", "singers" };
    	vector<string> words(4);
    	copy(s1, s1 + 4, words.begin());
    	for_each(words.begin(), words.end(), output);
    	cout << endl;
    
    	// construct anonymous back_insert_iterator object
    	copy(s2, s2 + 2, back_insert_iterator<vector<string> >(words));
    	//back_insert_iterator只能用于允许在尾部快速插入的容器
    	//front_insert_iterator只能用于允许在起始位置做时间固定插入的容器类型
    	for_each(words.begin(), words.end(), output);
    	cout << endl;
    
    	// construct anonymous insert_iterator object
    	copy(s3, s3 + 2, insert_iterator<vector<string> >(words, words.begin()));
    	//在其实位置插入s3的内容
    	for_each(words.begin(), words.end(), output);
    	cout << endl;
    	// cin.get();
    	return 0;
    }

执行结果：

fine fish fashion fate
    fine fish fashion fate busy bats
    silly singers fine fish fashion fate busy bats

## list.cpp ##

// list.cpp -- using a list
    #include <iostream>
    #include <list>
    #include <iterator>
    #include <algorithm>
    
    void outint(int n) { std::cout << n << " "; }
    
    int main()
    {
    	using namespace std;
    	list<int> one(5, 2); // list of 5 2s
    	int stuff[5] = { 1,2,4,8, 6 };
    	list<int> two;
    	two.insert(two.begin(), stuff, stuff + 5);
    	int more[6] = { 6, 4, 2, 4, 6, 5 };
    	list<int> three(two);
    	three.insert(three.end(), more, more + 6);
    
    	cout << "List one: ";
    	for_each(one.begin(), one.end(), outint);
    	cout << endl << "List two: ";
    	for_each(two.begin(), two.end(), outint);
    	cout << endl << "List three: ";
    	for_each(three.begin(), three.end(), outint);
    	three.remove(2);
    	cout << endl << "List three minus 2s: ";
    	for_each(three.begin(), three.end(), outint);
    	three.splice(three.begin(), one);
    	cout << endl << "List three after splice: ";
    	for_each(three.begin(), three.end(), outint);
    	cout << endl << "List one: ";
    	for_each(one.begin(), one.end(), outint);
    	three.unique();
    	cout << endl << "List three after unique: ";
    	for_each(three.begin(), three.end(), outint);
    	three.sort();
    	three.unique();
    	cout << endl << "List three after sort & unique: ";
    	for_each(three.begin(), three.end(), outint);
    	two.sort();
    	three.merge(two);
    	cout << endl << "Sorted two merged into three: ";
    	for_each(three.begin(), three.end(), outint);
    	cout << endl;
    	// cin.get();
    
    	return 0;
    }

执行结果：

List one: 2 2 2 2 2
    List two: 1 2 4 8 6
    List three: 1 2 4 8 6 6 4 2 4 6 5
    List three minus 2s: 1 4 8 6 6 4 4 6 5
    List three after splice: 2 2 2 2 2 1 4 8 6 6 4 4 6 5
    List one:
    List three after unique: 2 1 4 8 6 4 6 5
    List three after sort & unique: 1 2 4 5 6 8
    Sorted two merged into three: 1 1 2 2 4 4 5 6 6 8 8

## setops.cpp ##

// setops.cpp -- some set operations
    #include <iostream>
    #include <string>
    #include <set>
    #include <algorithm>
    #include <iterator>
    
    int main()
    {
    	using namespace std;
    	const int N = 6;
    	string s1[N] = { "buffoon", "thinkers", "for", "heavy", "can", "for" };
    	string s2[N] = { "metal", "any", "food", "elegant", "deliver","for" };
    
    	set<string> A(s1, s1 + N);
    	set<string> B(s2, s2 + N);
    
    	ostream_iterator<string, char> out(cout, " ");
    	cout << "Set A: ";
    	copy(A.begin(), A.end(), out);
    	cout << endl;
    	cout << "Set B: ";
    	copy(B.begin(), B.end(), out);
    	cout << endl;
    
    	cout << "Union of A and B:\n";
    	set_union(A.begin(), A.end(), B.begin(), B.end(), out);
    	cout << endl;
    
    	cout << "Intersection of A and B:\n";
    	set_intersection(A.begin(), A.end(), B.begin(), B.end(), out);
    	//set_intersection查找两个集合的交集
    	cout << endl;
    
    	cout << "Difference of A and B:\n";
    	set_difference(A.begin(), A.end(), B.begin(), B.end(), out);
    	//set_difference查找两个集合的差
    	cout << endl;
    
    	set<string> C;
    	cout << "Set C:\n";
    	set_union(A.begin(), A.end(), B.begin(), B.end(),
    		insert_iterator<set<string> >(C, C.begin()));
    	copy(C.begin(), C.end(), out);
    	cout << endl;
    
    	string s3("grungy");
    	C.insert(s3);
    	cout << "Set C after insertion:\n";
    	copy(C.begin(), C.end(), out);
    	cout << endl;
    
    	cout << "Showing a range:\n";
    	copy(C.lower_bound("ghost"), C.upper_bound("spook"), out);
    	//lower_bound将键作为参数并返回一个迭代器，该迭代器指向集合中第一个不小于键参数的成员
    	//upper_bound将键作为参数并返回一个迭代器，该迭代器指向集合中第一个大于键参数的成员
    	cout << endl;
    	// cin.get();
    	return 0;
    }

执行效果：

Set A: buffoon can for heavy thinkers
    Set B: any deliver elegant food for metal
    Union of A and B:
    any buffoon can deliver elegant food for heavy metal thinkers
    Intersection of A and B:
    for
    Difference of A and B:
    buffoon can heavy thinkers
    Set C:
    any buffoon can deliver elegant food for heavy metal thinkers
    Set C after insertion:
    any buffoon can deliver elegant food for grungy heavy metal thinkers
    Showing a range:
    grungy heavy metal

ERROR:

> “std::pair<std::\_Tree\_iterator<std::\_Tree\_val<std::\_Tree\_simple\_types<\_Ty>>>,std::\_Tree\_iterator<std::\_Tree\_val<std::\_Tree\_simple\_types<\_Ty>>>>”后面接“auto”是非法的(是否忘记了“;”?)

去掉auto：![watermark,type\_d3F5LXplbmhlaQ,shadow\_50,text\_Q1NETiBA6ZW\_5rKZ5pyJ6IKl6bG8,size\_20,color\_FFFFFF,t\_70,g\_se,x\_16][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16 3]

## multmap.cpp ##

// multmap.cpp -- use a multimap
    #include <iostream>
    #include <string>
    #include <map>
    #include <algorithm>
    
    typedef int KeyType;
    typedef std::pair<const KeyType, std::string> Pair;
    typedef std::multimap<KeyType, std::string> MapCode;
    
    int main()
    {
    	using namespace std;
    	MapCode codes;
    
    	codes.insert(Pair(415, "San Francisco"));
    	codes.insert(Pair(510, "Oakland"));
    	codes.insert(Pair(718, "Brooklyn"));
    	codes.insert(Pair(718, "Staten Island"));
    	codes.insert(Pair(415, "San Rafael"));
    	codes.insert(Pair(510, "Berkeley"));
    
    	cout << "Number of cities with area code 415: "
    		<< codes.count(415) << endl;
    	cout << "Number of cities with area code 718: "
    		<< codes.count(718) << endl;
    	cout << "Number of cities with area code 510: "
    		<< codes.count(510) << endl;
    	cout << "Area Code   City\n";
    	MapCode::iterator it;
    	for (it = codes.begin(); it != codes.end(); ++it)
    		cout << "    " << (*it).first << "     "
    		<< (*it).second << endl;
    
    	pair<MapCode::iterator, MapCode::iterator> range
    		= codes.equal_range(718);
    	cout << "Cities with area code 718:\n";
    	for (it = range.first; it != range.second; ++it)
    		cout << (*it).second << endl;
    	// cin.get();
    	return 0;
    }

执行结果：

Number of cities with area code 415: 2
    Number of cities with area code 718: 2
    Number of cities with area code 510: 2
    Area Code   City
        415     San Francisco
        415     San Rafael
        510     Oakland
        510     Berkeley
        718     Brooklyn
        718     Staten Island
    Cities with area code 718:
    Brooklyn
    Staten Island

## functor.cpp ##

// functor.cpp -- using a functor
    #include <iostream>
    #include <list>
    #include <iterator>
    #include <algorithm>
    
    template<class T>  // functor class defines operator()()
    class TooBig
    {
    private:
    	T cutoff;
    public:
    	TooBig(const T & t) : cutoff(t) {}
    	bool operator()(const T & v) { return v > cutoff; }
    };
    
    void outint(int n) { std::cout << n << " "; }
    
    int main()
    {
    	using std::list;
    	using std::cout;
    	using std::endl;
    	using std::for_each;
    	using std::remove_if;
    
    	TooBig<int> f100(100); // limit = 100
    	int vals[10] = { 50, 100, 90, 180, 60, 210, 415, 88, 188, 201 };
    	list<int> yadayada(vals, vals + 10); // range constructor
    	list<int> etcetera(vals, vals + 10);
    
    	// C++0x can use the following instead
       //  list<int> yadayada = {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};
       //  list<int> etcetera {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};
    
    	cout << "Original lists:\n";
    	for_each(yadayada.begin(), yadayada.end(), outint);
    	cout << endl;
    	for_each(etcetera.begin(), etcetera.end(), outint);
    	cout << endl;
    	yadayada.remove_if(f100);               // use a named function object
    	etcetera.remove_if(TooBig<int>(200));   // construct a function object
    	cout << "Trimmed lists:\n";
    	for_each(yadayada.begin(), yadayada.end(), outint);
    	cout << endl;
    	for_each(etcetera.begin(), etcetera.end(), outint);
    	cout << endl;
    	// std::cin.get();
    	return 0;
    }

执行结果：

Original lists:
    50 100 90 180 60 210 415 88 188 201
    50 100 90 180 60 210 415 88 188 201
    Trimmed lists:
    50 100 90 60 88
    50 100 90 180 60 88 188

## funadap.cpp ##

// funadap.cpp -- using function adapters
    #include <iostream>
    #include <vector>
    #include <iterator>
    #include <algorithm>
    #include <functional>
    
    void Show(double);
    const int LIM = 6;
    int main()
    {
    	using namespace std;
    	double arr1[LIM] = { 28, 29, 30, 35, 38, 59 };
    	double arr2[LIM] = { 63, 65, 69, 75, 80, 99 };
    	vector<double> gr8(arr1, arr1 + LIM);
    	vector<double> m8(arr2, arr2 + LIM);
    	cout.setf(ios_base::fixed);
    	cout.precision(1);
    	cout << "gr8:\t";
    	for_each(gr8.begin(), gr8.end(), Show);
    	cout << endl;
    	cout << "m8: \t";
    	for_each(m8.begin(), m8.end(), Show);
    	cout << endl;
    
    	vector<double> sum(LIM);
    	transform(gr8.begin(), gr8.end(), m8.begin(), sum.begin(),
    		plus<double>());
    	cout << "sum:\t";
    	for_each(sum.begin(), sum.end(), Show);
    	cout << endl;
    
    	vector<double> prod(LIM);
    	transform(gr8.begin(), gr8.end(), prod.begin(),
    		bind1st(multiplies<double>(), 2.5));
    	cout << "prod:\t";
    	for_each(prod.begin(), prod.end(), Show);
    	cout << endl;
    	// cin.get();
    	return 0;
    }
    
    void Show(double v)
    {
    	std::cout.width(6);
    	std::cout << v << ' ';
    }

执行效果：

gr8:      28.0   29.0   30.0   35.0   38.0   59.0
    m8:       63.0   65.0   69.0   75.0   80.0   99.0
    sum:      91.0   94.0   99.0  110.0  118.0  158.0
    prod:     70.0   72.5   75.0   87.5   95.0  147.5

## strgstl.cpp ##

// strgstl.cpp -- applying the STL to a string
    #include <iostream>
    #include <string>
    #include <algorithm>
    
    int main()
    {
    	using namespace std;
    	string letters;
    
    	cout << "Enter the letter grouping (quit to quit): ";
    	while (cin >> letters && letters != "quit")
    	{
    		cout << "Permutations of " << letters << endl;
    		sort(letters.begin(), letters.end());
    		cout << letters << endl;
    		while (next_permutation(letters.begin(), letters.end()))
    			cout << letters << endl;
    		cout << "Enter next sequence (quit to quit): ";
    	}
    	cout << "Done.\n";
    	// cin.get();
    	// cin.get();
    	return 0;
    }

执行效果：

Enter the letter grouping (quit to quit): aw1
    Permutations of aw1
    1aw
    1wa
    a1w
    aw1
    w1a
    wa1
    Enter next sequence (quit to quit): all
    Permutations of all
    all
    lal
    lla
    Enter next sequence (quit to quit): quit
    Done.

## listrmv.cpp ##

// listrmv.cpp -- applying the STL to a string
    #include <iostream>
    #include <list>
    #include <algorithm>
    
    void Show(int);
    const int LIM = 10;
    int main()
    {
    	using namespace std;
    	int ar[LIM] = { 4, 5, 4, 2, 2, 3, 4, 8, 1, 4 };
    	list<int> la(ar, ar + LIM);
    	list<int> lb(la);
    
    	cout << "Original list contents:\n\t";
    	for_each(la.begin(), la.end(), Show);
    	cout << endl;
    	la.remove(4);
    	cout << "After using the remove() method:\n";
    	cout << "la:\t";
    	for_each(la.begin(), la.end(), Show);
    	cout << endl;
    	list<int>::iterator last;
    	last = remove(lb.begin(), lb.end(), 4);
    	cout << "After using the remove() function:\n";
    	cout << "lb:\t";
    	for_each(lb.begin(), lb.end(), Show);
    	cout << endl;
    	lb.erase(last, lb.end());
    	cout << "After using the erase() method:\n";
    	cout << "lb:\t";
    	for_each(lb.begin(), lb.end(), Show);
    	cout << endl;
    	// cin.get();    
    	return 0;
    }
    
    void Show(int v)
    {
    	std::cout << v << ' ';
    }

执行结果：

Original list contents:
            4 5 4 2 2 3 4 8 1 4
    After using the remove() method:
    la:     5 2 2 3 8 1
    After using the remove() function:
    lb:     5 2 2 3 8 1 4 8 1 4
    After using the erase() method:
    lb:     5 2 2 3 8 1

## usealgo.cpp ##

//usealgo.cpp -- using several STL elements
    #include <iostream>
    #include <string>
    #include <vector>
    #include <set>
    #include <map>
    #include <iterator>
    #include <algorithm>
    #include <cctype>
    using namespace std;
    
    char toLower(char ch) { return tolower(ch); }
    string & ToLower(string & st);
    void display(const string & s);
    
    int main()
    {
    	vector<string> words;
    	cout << "Enter words (enter quit to quit):\n";
    	string input;
    	while (cin >> input && input != "quit")
    		words.push_back(input);
    
    	cout << "You entered the following words:\n";
    	for_each(words.begin(), words.end(), display);
    	cout << endl;
    
    	// place words in set, converting to lowercase
    	set<string> wordset;
    	transform(words.begin(), words.end(),
    		insert_iterator<set<string> >(wordset, wordset.begin()),
    		ToLower);
    	cout << "\nAlphabetic list of words:\n";
    	for_each(wordset.begin(), wordset.end(), display);
    	cout << endl;
    
    	// place word and frequency in map
    	map<string, int> wordmap;
    	set<string>::iterator si;
    	for (si = wordset.begin(); si != wordset.end(); si++)
    		wordmap[*si] = count(words.begin(), words.end(), *si);
    
    	// display map contents
    	cout << "\nWord frequency:\n";
    	for (si = wordset.begin(); si != wordset.end(); si++)
    		cout << *si << ": " << wordmap[*si] << endl;
    	// cin.get();
    	// cin.get();
    	return 0;
    }
    
    string & ToLower(string & st)
    {
    	transform(st.begin(), st.end(), st.begin(), toLower);
    	return st;
    }
    
    void display(const string & s)
    {
    	cout << s << " ";
    }

执行结果：

Enter words (enter quit to quit):
    The dog saw the cat and thought the cat fat
    The cat thought the cat perfect
    quit
    You entered the following words:
    The dog saw the cat and thought the cat fat The cat thought the cat perfect
    
    Alphabetic list of words:
    and cat dog fat perfect saw the thought
    
    Word frequency:
    and: 1
    cat: 4
    dog: 1
    fat: 1
    perfect: 1
    saw: 1
    the: 5
    thought: 2

## valvect.cpp ##

// valvect.cpp -- comparing vector and valarray
    #include <iostream>
    #include <valarray>
    #include <vector>
    #include <algorithm>
    int main()
    {
    	using namespace std;
    	vector<double> data;
    	double temp;
    
    	cout << "Enter numbers (<=0 to quit):\n";
    	while (cin >> temp && temp > 0)
    		data.push_back(temp);
    	sort(data.begin(), data.end());
    	int size = data.size();
    	valarray<double> numbers(size);
    	int i;
    	for (i = 0; i < size; i++)
    		numbers[i] = data[i];
    	valarray<double> sq_rts(size);
    	sq_rts = sqrt(numbers);
    	valarray<double> results(size);
    	results = numbers + 2.0 * sq_rts;
    	cout.setf(ios_base::fixed);
    	cout.precision(4);
    	for (i = 0; i < size; i++)
    	{
    		cout.width(8);
    		cout << numbers[i] << ": ";
    		cout.width(8);
    		cout << results[i] << endl;
    	}
    	cout << "done\n";
    	// cin.get();
    	// cin.get();
    
    	return 0;
    }

执行结果：

Enter numbers (<=0 to quit):
    3.3 1.8 5.2 10 14.4 21.6 26.9 0
      1.8000:   4.4833
      3.3000:   6.9332
      5.2000:   9.7607
     10.0000:  16.3246
     14.4000:  21.9895
     21.6000:  30.8952
     26.9000:  37.2730
    done

## vslice.cpp ##

// vslice.cpp -- using valarray slices
    #include <iostream>
    #include <valarray>
    #include <cstdlib>
    
    const int SIZE = 12;
    typedef std::valarray<int> vint;     // simplify declarations
    void show(const vint & v, int cols);
    int main()
    {
    	using std::slice;                // from <valarray>
    	using std::cout;
    	vint valint(SIZE);               // think of as 4 rows of 3
    
    	int i;
    	for (i = 0; i < SIZE; ++i)
    		valint[i] = std::rand() % 10;
    	cout << "Original array:\n";
    	show(valint, 3);                 // show in 3 columns
    	vint vcol(valint[slice(1, 4, 3)]); // extract 2nd column
    	cout << "Second column:\n";
    	show(vcol, 1);                   // show in 1 column
    	vint vrow(valint[slice(3, 3, 1)]); // extract 2nd row
    	cout << "Second row:\n";
    	show(vrow, 3);
    	valint[slice(2, 4, 3)] = 10;      // assign to 2nd column
    	cout << "Set last column to 10:\n";
    	show(valint, 3);
    	cout << "Set first column to sum of next two:\n";
    	// + not defined for slices, so convert to valarray<int>
    	valint[slice(0, 4, 3)] = vint(valint[slice(1, 4, 3)])
    		+ vint(valint[slice(2, 4, 3)]);
    	show(valint, 3);
    	// std::cin.get();
    	return 0;
    }
    
    void show(const vint & v, int cols)
    {
    	using std::cout;
    	using std::endl;
    
    	int lim = v.size();
    	for (int i = 0; i < lim; ++i)
    	{
    		cout.width(3);
    		cout << v[i];
    		if (i % cols == cols - 1)
    			cout << endl;
    		else
    			cout << ' ';
    	}
    	if (lim % cols != 0)
    		cout << endl;
    }

执行结果：

Original array:
      1   7   4
      0   9   4
      8   8   2
      4   5   5
    Second column:
      7
      9
      8
      5
    Second row:
      0   9   4
    Set last column to 10:
      1   7  10
      0   9  10
      8   8  10
      4   5  10
    Set first column to sum of next two:
     17   7  10
     19   9  10
     18   8  10
     15   5  10

## ilist.cpp ##

// ilist.cpp  -- use initializer_list
    #include <iostream>
    #include <initializer_list>
    
    double sum(std::initializer_list<double> il);
    double average(const std::initializer_list<double> & ril);
    
    int main()
    {
    	using std::cout;
    
    	cout << "List 1: sum = " << sum({ 2,3,4 })
    		<< ", ave = " << average({ 2,3,4 }) << '\n';
    	std::initializer_list<double> dl = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    	cout << "List 2: sum = " << sum(dl)
    		<< ", ave = " << average(dl) << '\n';
    	dl = { 16.0, 25.0, 36.0, 40.0, 64.0 };
    	cout << "List 3: sum = " << sum(dl)
    		<< ", ave = " << average(dl) << '\n';
    	// std::cin.get();
    	return 0;
    }
    
    double sum(std::initializer_list<double> il)
    {
    	double tot = 0;
    	for (auto p = il.begin(); p != il.end(); p++)
    		tot += *p;
    	return tot;
    }
    
    double average(const std::initializer_list<double> & ril)
    {
    	double tot = 0;
    	int n = ril.size();
    	double ave = 0.0;
    
    	if (n > 0)
    	{
    		for (auto p = ril.begin(); p != ril.end(); p++)
    			tot += *p;
    		ave = tot / n;
    	}
    	return ave;
    }

执行结果：

List 1: sum = 9, ave = 3
    List 2: sum = 16.5, ave = 3.3
    List 3: sum = 181, ave = 36.2

## 二、复习题 ##

**1. 考虑下面的类声明：**

>     class RQ1
>     {
>       private:
>         char * st; // points to C-style string
>       public:
>         RQ1() { st = new char [1]; strcpy(st,""); }
>         RQ1(const char * s)
>         {st = new char [strlen(s) + 1]; strcpy(st, s); }
>         RQ1(const RQ1 & rq)
>         {st = new char [strlen(rq.st) + 1]; strcpy(st, rq.st); }
>         ~RQ1() {delete [] st};
>         RQ & operator=(const RQ & rq);
>         // more stuff
>     };

**将它转换为使用`string`对象的声明。哪些方法不再需要显式定义？**

class RQ1
    {
      private:
        string st; 
      public:
        RQ1():st("") {}
        RQ1(const char * s):st(s){}
        ~RQ1() {};
        // more stuff
    };

因为`string`对象提供了自己的内存管理功能，所以不需要再显式定义复制构造函数、析构程序和赋值运算符。

**2. 在易于使用方面，指出`string`对象至少两个优于C-风格字符串的地方。**

`string`对象有自己的内存管理功能那个，不需要担心字符串超出存储容量的问题，而且可以将一个`string`对象赋值给另外一个`string`对象。

**3. 编写一个函数，用`string`对象作为参数，将`string`对象转换为全部大写。**

#include<string>
    #include<cctype>
    void ToUpper(std::string& s)
    {
        for(int i = 0; i < s.size(); ++i)
            str[i] = toupper(str[i];)
    }

**4. 从概念上或语法上说，下面哪个不是正确使用`auto_ptr`的方法（假设已经包含了所需的头文件）？**

>     auto_ptr<int> pia(new int[20]);
>     auto_ptr<string> (new string);
>     int rigue = 7;
>     auto_ptr<int>pr(&rigue);
>     auto_ptr dbl (new double);

auto_ptr<int> pia(new int[20]);  //错误，应该使用new，而不是new[]
    auto_ptr<string> (new string);   //错误，没有给指针命名
    int rigue = 7;                   
    auto_ptr<int>pr(&rigue);         //错误，不能指向自动变量，因为rigue不是new出来的
    auto_ptr dbl (new double);       //错误，缺少<double>，应为auto_ptr<double> dbl (new double);

**5. 如果可以生成一个存储高尔夫球棍（而不是数字）的栈，为何它（从概念上说）是一个坏的高尔夫袋子？**

栈的后入先出（LIFO）的特性意味着在取出目标球棍，需要删除在目标球棍入袋（入栈）之后入袋的所有球棍。

**6. 为什么说对于逐洞记录高尔夫成绩来说，set容器是糟糕的选择？**

set集合只存储每个值的一个拷贝，即具备去重机制，因此多个相同得分会被存储为一个得分。

**7. 既然指针是一个迭代器，为什么STL设计人员没有简单地使用指针来代替迭代器呢？**

迭代器的访问方式就是把不同集合的访问逻辑抽象出来，使得不用暴露集合内部的结构而达到循环遍历集合的效果。使用迭代器使得能够使用接口类似于指针的对象遍历不以数组方式组织的数据，例如双向链表中的数据。

**8. 为什么STL设计人员仅定义了迭代器基类，而使用继承来派生其他迭代器类型的类，并根据这些迭代器类来表示算法？**

STL方法使得可以将STL函数用于指向常规数组的常规指针以及指向STL容器类的迭代器，因此提高了通用性。

**9. 给出`vector`对象比常规数组方便的3个例子。**

一个`vector`对象可以赋值给另外一个`vector`对象；`vector`可以自己管理自己的内存，自动调整长度；`vector`可以使用`at()`方法，可以自动检查边界。

**10. 如果程序清单16.9是使用`list`（而不是`vector`）实现的，则该程序的哪些部分将是非法的？非法部分能够轻松修复吗？如果可以，如何修复呢？**

`list`不支持随机访问，因此公用`sort`方法无法使用，需要使用`list`自己的`sort`方法。`list`不支持随机打乱，可以将其放到`vector`，然后使用`vector`打乱，然后再转回`list`。

**11. 假设有程序清单16.15所示的函数符`TooBig`，下面的代码有何功能？赋给`bo`的是什么值？**

>     bool bo = TooBig<int>(10)(15);

`TooBig`的定义如下：

template <class T>
    class TooBig {
    private:
        T cutoff;
    
    public:
        TooBig(const T& t):cutoff(t){}
        bool operator()(const T& v){return v > cutoff; }
    };

对于`TooBig<int>(10)(15)`，`T`为`int`，10是用来初始化cutoff，15对应的是`operator()(const T& v)`中的`v`，则`bo = TooBig<int>(10)(15) = 15 > 10 = true`。

## 三、编程练习 ##

**1. 回文指的是顺读和逆读都一样的字符串。例如，“tot”和“otto”都是简短的回文。编写一个程序，让用户输入字符串，并将字符串引用传递给一个`bool`函数。如果字符串是回文，该函数将返回`true`，否则返回`false`。此时，不要担心诸如大小写、空格和标点符号这些复杂的问题。即这个简单的版本将拒绝“Otto”和“Madam，I'm Adam”。请查看附录F中的字符串方法列表，以简化这项任务。**

根据回文的定义我们很容易想到：将一个字符串翻转然后对比翻转后的字符串是否与原字符串相同，来判断该字符串是否为回文字符串。具体实现如下：

#include <iostream>
    #include <string>
    
    bool palindrome(const std::string& s);
    
    int main() {
        std::string input;
        std::cout << "Enter a word(q to quit): ";
    
        while (std::getline(std::cin, input) && input != "q") {
            if (palindrome(input))
                std::cout << input << " is palindrome!" << std::endl;
            else
                std::cout << input << "is not palindrome" << std::endl;
            std::cout << "Enter anthor word(q to quit): ";
        }
    
        std::cout << "Bye!~" << std::endl;
    
        return 0;
    }
    
    bool palindrome(const std::string& s) {
        std::string rev(s.rbegin(), s.rend());
        return (rev == s);
    }

**2. 与编程练习1中给出的问题相同，但要考虑诸如大小写、空格和标点符号这样的复杂问题。即“Madam，I'm Adam”将作为回文来测试。例如，测试函数可能会将字符串缩略为“madamimadam”，然后测试倒过来是否一样。不要忘了有用的cctype库，您可能从中找到几个有用的STL函数，尽管不一定非要使用它们。**

main.cpp：

#include <iostream>
    #include <string>
    #include <cctype>
    
    bool palindromePlus(const std::string& s);
    
    int main() {
      std::string input;
      std::cout << "Enter a word(q to quit): ";
    
      while (std::getline(std::cin, input) && input != "q") {
        if (palindromePlus(input))
          std::cout << input << " is palindrome!" << std::endl;
        else
          std::cout << input << "is not palindrome" << std::endl;
        std::cout << "Enter anthor word(q to quit): ";
      }
    
      std::cout << "Bye!~" << std::endl;
    
      return 0;
    }
    
    bool palindromePlus(const std::string& s) {
      // data preprocessing
      std::string target_s;
      for (auto& c : s) {
        if (isalpha(c)) {
          if (isupper(c))
            target_s.push_back(tolower(c));
          else
            target_s.push_back(c);
        }
      }
      std::string rev(target_s.rbegin(), target_s.rend());
      return (rev == target_s);
    }

**3. 修改程序清单16.3，使之从文件中读取单词。一种方案是，使用`vector<string>`对象而不是`string`数组。这样便可以使用`push_back( )`将数据文件中的单词复制到`vector<string>`对象中，并使用`size( )`来确定单词列表的长度。由于程序应该每次从文件中读取一个单词，因此应使用运算符`>>`而不是`getline( )`。文件中包含的单词应该用空格、制表符或换行符分隔。**

hangman.cpp：

// hangman.cpp -- some string methods
    #include <cctype>
    #include <cstdlib>
    #include <ctime>
    #include <fstream>
    #include <iostream>
    #include <string>
    #include <vector>
    
    using std::string;
    using std::vector;
    
    vector<string> readWordlist(const std::string &file_name);
    
    int main() {
        using std::cin;
        using std::cout;
        using std::endl;
        using std::tolower;
        std::srand(std::time(0));
        auto wordlist = readWordlist("chapter16-3/wordlist.txt");
        char play;
        cout << "Will you play a word game? <y/n> ";
        cin >> play;
        play = tolower(play);
        while (play == 'y') {
            string target = wordlist[std::rand() % wordlist.size()];
            int length = target.length();
            string attempt(length, '-');
            string badchars;
            int guesses = 6;
            cout << "Guess my secret word. It has " << length
                << " letters, and you guess\n"
                << "one letter at a time. You get " << guesses << " wrong guesses.\n";
            cout << "Your word: " << attempt << endl;
    
            while (guesses > 0 && attempt != target) {
                char letter;
                cout << "Guess a letter: ";
                cin >> letter;
                if (badchars.find(letter) != string::npos ||
                    attempt.find(letter) != string::npos) {
                    cout << "You already guessed that. Try again.\n";
                    continue;
                }
                int loc = target.find(letter);
                if (loc == string::npos) {
                    cout << "Oh, bad guess!\n";
                    --guesses;
                    badchars += letter;  // add to string
                } else {
                    cout << "Good guess!\n";
                    attempt[loc] = letter;
                    // check if letter appears again
                    loc = target.find(letter, loc + 1);
                    while (loc != string::npos) {
                        attempt[loc] = letter;
                        loc = target.find(letter, loc + 1);
                    }
                }
                cout << "Your word: " << attempt << endl;
                if (attempt != target) {
                    if (badchars.length() > 0) cout << "Bad choices: " << badchars << endl;
                    cout << guesses << " bad guesses left\n";
                }
            }
            if (guesses > 0)
                cout << "That's right!\n";
            else
                cout << "Sorry, the word is " << target << ".\n";
            cout << "Will you play another? <y/n> ";
            cin >> play;
            play = tolower(play);
        }
        cout << "Bye\n";
        return 0;
    }
    
    vector<string> readWordlist(const std::string &file_name) {
        std::ifstream fin;
        fin.open(file_name);
        if (!fin.is_open()) {
            std::cout << file_name << " open fail!" << std::endl;
            std::exit(EXIT_FAILURE);
        }
        vector<string> wordlist;
        string word;
        while (fin >> word) wordlist.emplace_back(word);
        return wordlist;
    }

**4. 编写一个具有老式风格接口的函数，其原型如下：**

>     int reduce(long ar[], int n);

**实参应是数组名和数组中的元素个数。该函数对数组进行排序，删除重复的值，返回缩减后数组中的元素数目。请使用STL函数编写该函数（如果决定使用通用的unique( )函数，请注意它将返回结果区间的结尾）。使用一个小程序测试该函数。**

main.cpp：

#include <algorithm>
    #include <iostream>
    #include <iterator>
    
    int reduce(long ar[], int n);
    
    int main() {
        long arr[10] = {15, 8, 5, 6, 11, 11, 6, 6, 198, 50};
        int newsize = reduce(arr, 10);
        std::ostream_iterator<long, char> out(std::cout, " ");
        std::copy(arr, arr + newsize, out);
        std::cout << std::endl;
        std::cout << "There are " << newsize << " numbers.";
    
        return 0;
    }
    
    int reduce(long ar[], int n) {
        std::sort(ar, ar + n);
        auto past_end = std::unique(ar, ar + n);
    
        return past_end - ar;
    }

**5. 问题与编程练习4相同，但要编写一个模板函数：**

>     template <class T>
>     int reduce(T ar[], int n);

**在一个使用long实例和string实例的小程序中测试该函数。**

main.cpp：

#include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <string>
    
    
    template <class T>
        int reduce(T ar[], int n);
    
    template <class T>
        void show(T ar[], int n);
    
    int main() {
        long arr[10] = {15, 8, 5, 6, 11, 11, 6, 6, 198, 50};
        int newsize = reduce(arr, 10);
        show(arr, newsize);
    
        std::string arr_str[] = {"hello", "world", "hello", "hi"};
        newsize = reduce(arr_str, sizeof(arr_str) / sizeof(arr_str[0]));
        show(arr_str, newsize);
    
        return 0;
    }
    
    template <class T>
        int reduce(T ar[], int n) {
        std::sort(ar, ar + n);
        auto past_end = std::unique(ar, ar + n);
    
        return past_end - ar;
    }
    
    template <class T>
        void show(T ar[], int n) {
        std::ostream_iterator<T, char> out(std::cout, " ");
        std::copy(ar, ar + n, out);
        std::cout << std::endl;
        std::cout << "There are " << n << " numbers.";
    }

**6. 使用STL queue模板类而不是第12章的Queue类，重新编写程序清单12.12所示的示例。**

customer.h:

#ifndef CUSTOMER_H_
    #define CUSTOMER_H_
    
    class Customer {
        private:
        long arrive;      // arrival time for customer
        int processtime;  // processing time for customer
        public:
        Customer() { arrive = processtime = 0; }
        void set(long when);
        long when() const { return arrive; }
        int ptime() const { return processtime; }
    };
    
    #endif  // CUSTOMER_H_

customer.cpp:

#include "customer.h"
    
    #include <cstdlib>
    
    void Customer::set(long when) {
        processtime = std::rand() % 3 + 1;
        arrive = when;
    }

bank.cpp:

// bank.cpp -- using the Queue interface
    // compile with queue.cpp
    #include <cstdlib>  // for rand() and srand()
    #include <ctime>    // for time()
    #include <iostream>
    #include <queue>
    
    #include "customer.h"
    
    const int MIN_PER_HR = 60;
    bool newcustomer(double x);  // is there a new customer?
    int main() {
        using std::cin;
        using std::cout;
        using std::endl;
        using std::ios_base;
        // setting things up
        std::srand(std::time(0));  // random initializing of rand()
        cout << "Case Study: Bank of Heather Automatic Teller\n";
        cout << "Enter maximum size of queue: ";
        int qs;
        cin >> qs;
        std::queue<Customer> line;  // line queue holds up to qs people
        cout << "Enter the number of simulation hours: ";
        int hours;  // hours of simulation
        cin >> hours;
        // simulation will run 1 cycle per minute
        long cyclelimit = MIN_PER_HR * hours;  // # of cycles
        cout << "Enter the average number of customers per hour: ";
        double perhour;  // average # of arrival per hour
        cin >> perhour;
        double min_per_cust;  // average time between arrivals
        min_per_cust = MIN_PER_HR / perhour;
        Customer temp;       // new customer data
        long turnaways = 0;  // turned away by full queue
        long customers = 0;  // joined the queue
        long served = 0;     // served during the simulation
        long sum_line = 0;   // cumulative line length
        int wait_time = 0;   // time until autoteller is free
        long line_wait = 0;  // cumulative time in line
        // running the simulation
        for (int cycle = 0; cycle < cyclelimit; cycle++) {
            if (newcustomer(min_per_cust))  // have newcomer
            {
                if (line.size() >= qs)
                    turnaways++;
                else {
                    customers++;
                    temp.set(cycle);     // cycle = time of arrival
                    line.emplace(temp);  // add newcomer to line
                }
            }
            if (wait_time <= 0 && !line.empty()) {
                line.pop();                // attend next customer
                wait_time = temp.ptime();  // for wait_time minutes
                line_wait += cycle - temp.when();
                served++;
            }
            if (wait_time > 0) wait_time--;
            sum_line += line.size();
        }
        // reporting results
        if (customers > 0) {
            cout << "customers accepted: " << customers << endl;
            cout << " customers served: " << served << endl;
            cout << " turnaways: " << turnaways << endl;
            cout << "average queue size: ";
            cout.precision(2);
            cout.setf(ios_base::fixed, ios_base::floatfield);
            cout << (double)sum_line / cyclelimit << endl;
            cout << " average wait time: " << (double)line_wait / served
                << " minutes\n";
        } else
            cout << "No customers!\n";
        cout << "Done!\n";
        return 0;
    }
    // x = average time, in minutes, between customers
    // return value is true if customer shows up this minute
    bool newcustomer(double x) { return (std::rand() * x / RAND_MAX < 1); }

**7. 彩票卡是一个常见的游戏。卡片上是带编号的圆点，其中一些圆点被随机选中。编写一个lotto( )函数，它接受两个参数。第一个参数是彩票卡上圆点的个数，第二个参数是随机选择的圆点个数。该函数返回一个`vector<int>`对象，其中包含（按排列后的顺序）随机选择的号码。例如，可以这样使用该函数：**

>     vector<int> winners;
>     winners = Lotto(51,6);

**这样将把一个矢量赋给winner，该矢量包含1～51中随机选定的6个数字。注意，仅仅使用`rand( )`无法完成这项任务，因它会生成重复的值。提示：让函数创建一个包含所有可能值的矢量，使用`random_shuffle( )`，然后通过打乱后的矢量的第一个值来获取值。编写一个小程序来测试这个函数。**

main.cpp：

#include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <vector>
    
    std::vector<int> lotto(int tot_num, int select_num);
    
    int main() {
        const int TOTAL = 51, SELECT_NUMS = 6;
        std::cout << "Play lotto? <y/n>: ";
        std::string choice;
        std::vector<int> winners;
    
        while (std::cin >> choice && choice != "n") {
            winners = lotto(TOTAL, SELECT_NUMS);
            for (auto it = winners.begin(); it != winners.end(); ++it)
                std::cout << *it << " ";
            std::cout << std::endl;
    
            std::cout << "Play lotto? <y/n>: ";
        }
    
        std::cout << "Bye~" << std::endl;
        return 0;
    }
    
    std::vector<int> lotto(int total, int select) {
        using std::vector;
        vector<int> all;
        for (int i = 1; i <= total; ++i) all.push_back(i);
        random_shuffle(all.begin(), all.end());
    
        vector<int> select_vec(all.begin(), all.begin() + select);
        std::sort(select_vec.begin(), select_vec.end());
    
        return select_vec;
    }

**8. Mat和Pat希望邀请他们的朋友来参加派对。他们要编写一个程序完成下面的任务。**

*  **让Mat输入他朋友的姓名列表。姓名存储在一个容器中，然后按排列后的顺序显示出来。**
 *  **让Pat输入她朋友的姓名列表。姓名存储在另一个容器中，然后按排列后的顺序显示出来。**
 *  **创建第三个容器，将两个列表合并，删除重复的部分，并显示这个容器的内容。**

main.cpp:

#include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <sstream>
    #include <string>
    #include <vector>
    
    void getNames(std::vector<std::string>& name_vec);
    inline void show(std::string& s) { std::cout << s << " "; }
    
    int main() {
        using std::cin;
        using std::cout;
        using std::endl;
        using std::string;
        using std::vector;
    
        vector<string> mat_friends, pat_friends;
        string name;
    
        cout << "Mat! Enter your friends(press enter to end): ";
        getNames(mat_friends);
    
        cout << "Pat! Enter your friends(press enter to end): ";
        getNames(pat_friends);
    
        std::sort(mat_friends.begin(), mat_friends.end());
        std::sort(pat_friends.begin(), pat_friends.end());
    
        cout << "Mat's friends: " << endl;
        for_each(mat_friends.begin(), mat_friends.end(), show);
        cout << endl;
        cout << "Pat's friends: " << endl;
        for_each(pat_friends.begin(), pat_friends.end(), show);
        cout << endl;
    
        // merge to vectors
        vector<string> all_friends;
        all_friends.reserve(mat_friends.size() + pat_friends.size());
        all_friends.insert(all_friends.end(), mat_friends.begin(), mat_friends.end());
        all_friends.insert(all_friends.end(), pat_friends.begin(), pat_friends.end());
    
        std::sort(all_friends.begin(), all_friends.end());
        auto new_end = std::unique(all_friends.begin(), all_friends.end());
        cout << "All friends: " << endl;
        for_each(all_friends.begin(), new_end, show);
        cout << endl;
    
        return 0;
    }
    
    void getNames(std::vector<std::string>& name_vec) {
        std::string names;
        std::getline(std::cin, names);
    
        std::istringstream ins(names);
        std::copy(std::istream_iterator<std::string>(ins),
                  std::istream_iterator<std::string>(), std::back_inserter(name_vec));
    }

**9. 相对于数组，在链表中添加和删除元素更容易，但排序速度更慢。这就引出了一种可能性：相对于使用链表算法进行排序，将链表复制到数组中，对数组进行排序，再将排序后的结果复制到链表中的速度可能更快；但这也可能占用更多的内存。请使用如下方法检验上述假设。**

**a．创建大型`vector<int>`对象`vi0`，并使用`rand( )`给它提供初始值。**

**b．创建`vector<int>`对象`vi`和`list<int>`对象`li`，它们的长度都和初始值与`vi0`相同。**

**c．计算使用STL算法`sort( )`对`vi`进行排序所需的时间，再计算使用list的方法`sort( )`对`li`进行排序所需的时间。**

**d．将`li`重置为排序的`vi0`的内容，并计算执行如下操作所需的时间：将`li`的内容复制到`vi`中，对`vi`进行排序，并将结果复制到`li`中。**

**要计算这些操作所需的时间，可使用ctime库中的`clock( )`。正如程序清单5.14演示的，可使用下面的语句来获取开始时间：**

>     clock_t start = clock();

**再在操作结束后使用下面的语句获取经过了多长时间：**

>     clock_t end = clock();
>     cout << (double)(end - start)/CLOCKS_PER_SEC;

**这种测试并非绝对可靠，因为结果取决于很多因素，如可用内存量、是否支持多处理以及数组（列表）的长度（随着要排序的元素数增加，数组相对于列表的效率将更明显）。另外，如果编译器提供了默认生成方式和发布生成方式，请使用发布生成方式。鉴于当今计算机的速度非常快，要获得有意义的结果，可能需要使用尽可能大的数组。例如，可尝试包含100000、1000000和10000000个元素。**

main.cpp:

#include <algorithm>
    #include <ctime>
    #include <iostream>
    #include <list>
    #include <random>
    #include <vector>
    
    const int SIZE = 1000000;
    
    int main() {
        using std::cin;
        using std::cout;
        using std::endl;
        using std::list;
        using std::vector;
    
        vector<int> vi0(SIZE, 0);
        std::srand(std::time(0));
        for (int i = 0; i < SIZE; ++i) vi0.at(i) = rand();
    
        vector<int> vi(vi0);
        list<int> li(SIZE, 0);
        std::copy(vi0.begin(), vi0.end(), li.begin());
    
        clock_t start = std::clock();
        std::sort(vi.begin(), vi.end());
        clock_t end = clock();
        cout << "sort vector time: " << (double)(end - start) / CLOCKS_PER_SEC
            << endl;
    
        start = std::clock();
        li.sort();
        end = clock();
        cout << "sort list time: " << (double)(end - start) / CLOCKS_PER_SEC << endl;
    
        std::copy(vi0.begin(), vi0.end(), li.begin());
        start = std::clock();
        std::copy(li.begin(), li.end(), vi.begin());
        std::sort(vi.begin(), vi.end());
        std::copy(vi.begin(), vi.end(), li.begin());
        end = clock();
        cout << "copy2vec-sort_vec-copy2list time: "
            << (double)(end - start) / CLOCKS_PER_SEC << endl;
    
        return 0;
    }

**10．请按如下方式修改程序清单16.9（vect3.cpp）。**

**a．在结构`Review`中添加成员`price`。**

**b．不使用`vector<Review>`来存储输入，而使用`vector<shared_ptr<Review>>`。别忘了，必须使用`new`返回的指针来初始化`shared_ptr`。**

**c．在输入阶段结束后，使用一个循环让用户选择如下方式之一显示书籍：按原始顺序显示、按字母表顺序显示、按评级升序显示、按评级降序显示、按价格升序显示、按价格降序显示、退出。**

**下面是一种可能的解决方案：获取输入后，再创建一个`shared_ptr`矢量，并用原始数组初始化它。定义一个对指向结构的指针进行比较的`operator < ( )`函数，并使用它对第二个矢量进行排序，让其中的`shared_ptr`按其指向的对象中的书名排序。重复上述过程，创建按`rating`和`price`排序的`shared_ptr`矢量。请注意，通过使用`rbegin()`和`rend()`，可避免创建按相反的顺序排列的`shared_ptr`矢量。**

vect3.cpp:

// vect3.cpp -- using STL functions
    #include <algorithm>
    #include <iostream>
    #include <memory>
    #include <string>
    #include <vector>
    
    struct Review {
        std::string title;
        int rating;
        double price;
    };
    
    bool operator<(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2);
    bool RatingAsc(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2);
    bool PriceAsc(const std::shared_ptr<Review>& p1,
                  const std::shared_ptr<Review>& p2);
    bool PriceDesc(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2);
    bool FillReview(std::shared_ptr<Review>& rptr);
    void ShowReview(const std::shared_ptr<Review>& rptr);
    void ShowMenu();
    
    int main() {
        using namespace std;
    
        vector<shared_ptr<Review> > books;
    
        // initialize books
        shared_ptr<Review> temp_ptr;
        while (FillReview(temp_ptr)) books.push_back(temp_ptr);
    
        if (books.size() > 0) {
            ShowMenu();
            char choice;
            while (cin >> choice && choice != '6') {
                vector<shared_ptr<Review> > books_cpy(books);
                switch (choice) {
                    case '1':
                        cout << "Original order:" << endl;
                        cout << "Rating\tBook\tPrice\n";
                        for_each(books_cpy.begin(), books_cpy.end(), ShowReview);
                        break;
                    case '2':
                        cout << "Alphabet order:" << endl;
                        cout << "Rating\tBook\tPrice\n";
                        sort(books_cpy.begin(), books_cpy.end());
                        for_each(books_cpy.begin(), books_cpy.end(), ShowReview);
                        break;
                    case '3':
                        cout << "Rating ascending:" << endl;
                        cout << "Rating\tBook\tPrice\n";
                        sort(books_cpy.begin(), books_cpy.end(), RatingAsc);
                        for_each(books_cpy.begin(), books_cpy.end(), ShowReview);
                        break;
                    case '4':
                        cout << "Price ascending:" << endl;
                        cout << "Rating\tBook\tPrice\n";
                        sort(books_cpy.begin(), books_cpy.end(), PriceAsc);
                        for_each(books_cpy.begin(), books_cpy.end(), ShowReview);
                        break;
                    case '5':
                        cout << "Price descending:" << endl;
                        cout << "Rating\tBook\tPrice\n";
                        sort(books_cpy.begin(), books_cpy.end(), PriceDesc);
                        for_each(books_cpy.begin(), books_cpy.end(), ShowReview);
                        break;
                    default:
                        break;
                }
                ShowMenu();
            }
        } else
            cout << "No entries. ";
        cout << "Bye.\n";
        return 0;
    }
    
    bool operator<(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2) {
        return p1->title < p2->title;
    }
    
    bool RatingAsc(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2) {
        return p1->rating < p2->rating;
    }
    
    bool PriceAsc(const std::shared_ptr<Review>& p1,
                  const std::shared_ptr<Review>& p2) {
        return p1->price < p2->price;
    }
    
    bool PriceDesc(const std::shared_ptr<Review>& p1,
                   const std::shared_ptr<Review>& p2) {
        return p1->price > p2->price;
    }
    
    bool FillReview(std::shared_ptr<Review>& rptr) {
        rptr = std::shared_ptr<Review>(new Review);
    
        std::cout << "Enter book title (quit to quit): ";
        std::getline(std::cin, rptr->title);
        if (rptr->title == "quit") return false;
    
        std::cout << "Enter book rating: ";
        std::cin >> rptr->rating;
        if (!std::cin) return false;
    
        std::cout << "Enter book price: ";
        std::cin >> rptr->price;
        if (!std::cin) return false;
    
        // get rid of rest of input line
        while (std::cin.get() != '\n') continue;
    
        return true;
    }
    
    void ShowReview(const std::shared_ptr<Review>& rptr) {
        std::cout << rptr->rating << "\t" << rptr->title << "\t" << rptr->price
            << std::endl;
    }
    
    void ShowMenu() {
        using std::cin;
        using std::cout;
        using std::endl;
    
        cout << "---------------------------------------------------------" << endl;
        cout << "1.original order   2.alphabet order    3.rating ascending" << endl;
        cout << "4.price ascending  3.price descending  6.quit" << endl;
        cout << "---------------------------------------------------------" << endl;
        cout << "Your choice: ";
    }

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/fcec55883637494c9ebeada9fa7b727e.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/796556b9019f499f9e2dd7f832e4859c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/032d155540d146e4a7dc30ce6339de4b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/cf0e0e8338d44b22acc92c69a77819de.png