Essential C++ 第一章，猜数代码分析ch1.cpp

 d

2. /**************************************************
3.  * Essential C++ -- Stanley Lippman
4.  * Addison-Wesley 
5.  * ISBN 0-201-48518-4
6.  * homepage: www.objectwrite.com
7.  * email: slippman@objectwrite.com
8.  *************************************************/
10. #include "ch1.h"
12. pvec Fibonacci_gen_elems( int pos ) 
13. { 
14.     static vector<unsigned int> _elems;
16.     if ( ! check_integrity( pos ))
17.          return 0;
19.     if ( _elems.empty() )
20.        { _elems.push_back( 1 ); _elems.push_back( 1 ); }
22.     if ( _elems.size() < pos )
23.     {
24.             int ix = _elems.size();
25.             int n_2 = _elems[ ix-2 ], 
26.                 n_1 = _elems[ ix-1 ];
28.             int elem;
29.             for ( ; ix < pos; ++ix ){
30.                     elem = n_2 + n_1; 
31.                     _elems.push_back( elem );
32.                     n_2 = n_1; n_1 = elem;
33.             }
34.      }
36.      return &_elems;
37. }  
39.    
40. pvec Pell_gen_elems( int pos )    
41. { 
42.     static vector< unsigned int> _elems;
44.     if ( ! check_integrity( pos ))
45.          return 0;
47.     if ( _elems.empty() )
48.        {  _elems.push_back( 1 ); _elems.push_back( 2 ); }
50.     if ( _elems.size() < pos )
51.     {
52.             int ix = _elems.size();
53.             int n_2 = _elems[ ix-2 ], 
54.                 n_1 = _elems[ ix-1 ];
56.             int elem;
57.             for ( ; ix < pos; ++ix ){
58.                     elem = n_2 + 2 * n_1; 
59.                     _elems.push_back( elem );
60.                     n_2 = n_1; n_1 = elem;
61.             }
62.      }
64.      return &_elems;
65. }
66.    
67. pvec Lucas_gen_elems( int pos ) 
68. {    
69.     static vector<unsigned int> _elems;
71.     if ( ! check_integrity( pos ))
72.          return 0;
74.     if ( _elems.empty() )
75.        {  _elems.push_back( 1 ); _elems.push_back( 3 ); }
77.     if ( _elems.size() < pos )
78.     {
79.             int ix = _elems.size();
80.             int n_2 = _elems[ ix-2 ], 
81.                 n_1 = _elems[ ix-1 ];
83.             int elem;
84.             for ( ; ix < pos; ++ix ){
85.                     elem = n_2 +  n_1; 
86.                     _elems.push_back( elem );
87.                     n_2 = n_1; n_1 = elem;
88.             }
89.      }
91.      return &_elems;
92. }    
93.    
94. pvec Triangular_gen_elems( int pos ) 
95. {
96.     static vector<unsigned int> _elems;
98.     if ( ! check_integrity( pos ))
99.          return 0;
101.     if ( _elems.size() < pos )
102.     {
103.         int ix = _elems.size() ? _elems.size()+1 : 1;
104.         for ( ; ix <= pos; ++ix )
105.               _elems.push_back( ix*(ix+1)/2 );
106.     }
108.     return &_elems;
109. }
111. pvec Square_gen_elems( int pos ) 
112. {
113.     static vector<unsigned int> _elems;
115.     if ( ! check_integrity( pos ))
116.          return 0;
118.     if ( _elems.size() < pos )
119.     {
120.         int ix = _elems.size() ? _elems.size()+1 : 1;
121.         for ( ; ix <= pos; ++ix )
122.               _elems.push_back( ix*ix );
123.     }
125.     return &_elems;
126. }   
127.     
128. pvec Pentagonal_gen_elems( int pos ) 
129. {
130.     static vector<unsigned int> _elems;
132.     if ( ! check_integrity( pos ))
133.          return 0;
135.     if ( _elems.size() < pos )
136.     {
137.         int ix = _elems.size() ? _elems.size()+1 : 1;
138.         for ( ; ix <= pos; ++ix )
139.               _elems.push_back( ix*(3*ix-1)/2 );
140.     }
142.     return &_elems;
143. }
145. pfunc gen_elems[] = 
146. { 0,
147.   Fibonacci_gen_elems,
148.   Pell_gen_elems,
149.   Lucas_gen_elems,
150.   Triangular_gen_elems,
151.   Square_gen_elems,
152.   Pentagonal_gen_elems
153. };
155. const char *name_seq[] = { "Invalid Sequence",
156.    "Fibonacci", "Pell", "Lucas",
157.    "Triangular", "Square", "Pentagonal"
158. };
160. int level_size[] = { 8, 8, 32, 128, 512 };
162. const char* wrong_msg[] = {
163.  "Oops! Nice guess but not quite it.",
164.  "Hmm. Sorry. Wrong again.",
165.  "Ah, this is harder than it looks, isn't it?",
166.  "It must be getting pretty frustrating by now!"
167. };
169. void display_statistics( user_profile *puser )
170. {
171.     cout << "Game Statistics for " << puser->name << "/n/t"
172.          << "# guesses: " << puser->guesses << "/n/t"
173.          << "# correct: " << puser->correct << "/n/t"
174.          << "% correct: " 
175.          << (static_cast<float>( puser->correct ) / static_cast<float>( puser->guesses )) * 100 << endl;
176. }
178. bool greet_user( user_profile *puser )
179. {
180.       cout << "Hi. What's your name? ";
182.       string nm;
183.       cin >> nm;
185.       if ( nm.empty() || nm[ 0 ] == ' ' ){
186.            cout << "ok. I guess you don't want to play. See ya!/n";
187.            return false;
188.       }
190.       cout << "Hi, " << nm
191.            << " Would you like to play Guess the Sequence? (y/n) ";
193.       char ch;
194.       cin >> ch;
196.       if ( ch != 'y' && ch != 'Y' ){
197.            cout << "ok. I'm sorry you don't want to play./n";
198.            return false;
199.       }
201.       cout << "/n/n" << "Hey, that's great, " << nm << "./n"
202.            << "We'll start in just a moment./nIt/'s simple, really!/n"
203.            << "I will print out two elements of a sequence/n"
204.            << "You just answer with the element value that comes next!/n/n";
206.       cout << "Oh, by the way, do you consider yourself a/n/t"
207.            << "beginner     -- enter 1/n/t"
208.            << "intermediate -- enter 2/n/t"
209.            << "advanced     -- enter 3/n/t"
210.            << "guru         -- enter 4/n/t" << endl;
212.       int level;
213.       cin >> level;
215.       if ( level < 1 || level > 4) level = 4;
217.       init_user( puser, nm, level );
218.       return true;
219. }
221. void print_seq( user_profile *puser )
222. {
223.     for ( int i = 0; i < puser->cur_seq_vec->size(); ++i )
224.           cout << (*puser->cur_seq_vec)[i] << ' ';
225.     cout << endl;
226. }
228. void display_seq( user_profile *puser )
229. {
230.     pvec p = seq_vec( puser ); 
231.     cout << "The first two elements of the series are: "
232.          << (*p)[ puser->pos-3 ] << ", " << (*p)[ puser->pos-2 ] 
233.          << "/nWhat is the next element? ";
234. }
236. void set_up_index( user_profile *puser )
237. {
238.     static string wherefrom( "set_up_index" );
240.     // randomly pick a position within the sequence
241.     puser->pos = rand() % ( level_size[ puser->level ] );
243.     // position represents 
244.     if ( puser->pos < 3 ) puser->pos += 3;
245.     
246.     set_seq_vec( puser, (*gen_elems[ puser->cur_seq ])( puser->pos ));
247.     trace( wherefrom, "new position: ", puser->pos );
248. }
250. void reset_seq( user_profile *puser )
251. {
252.     static string wherefrom( "reset_seq" );
254.     int new_seq = gen_seq_id( reinterpret_cast<unsigned int>( puser ));
255.     if ( new_seq == puser->cur_seq )
256.          new_seq = new_seq < ns_cnt ? new_seq+1 : 1;
258.     puser->cur_seq = static_cast<num_sequence>( new_seq );
260.     set_up_index( puser );
262.     print_seq( puser );
263.     trace( wherefrom, "new sequence: ", name_seq[ puser->cur_seq ]);
264. }
266. void init_user( user_profile *puser, const string& nm, int level )
267. {
268.     static string wherefrom( "init_user" );
270.     puser->name = nm;
271.     puser->guesses = 0;
272.     puser->correct = 0;
273.     puser->level = level;
275.     reset_seq( puser );
277.     trace( wherefrom, nm, puser->cur_seq, level );
278. }   
280. bool correct_guess( user_profile *puser, int guess )
281. {
282.     pvec p = seq_vec( puser ); 
283.     if ( guess == (*p)[ puser->pos-1 ] )
284.          return true;
285.     return false;
286. }
288. void play_game( user_profile *puser )
289. {
290.     bool next_seq  = true;      // show next sequence?
291.     bool go_for_it = true;      // user wants to guess?
292.     bool got_it    = false;     // user guessed correctly?
293.     int  num_tries;             // number of tries per sequence
295.     while ( next_seq == true )
296.     {
297.         num_tries = 0;
298.         display_seq( puser );
299.         while (( got_it == false ) &&
300.                ( go_for_it == true ))
301.         {
302.              unsigned int usr_guess;
303.              cin >> usr_guess;
305.               if ( correct_guess( puser, usr_guess ))
306.               {
307.                   bump_correct( puser );
308.                   got_it = true;
309.                   cout << "Hey, most excellent! /n/t"
310.                        << usr_guess << " is element # "
311.                        << puser->pos << " of the " 
312.                        << name_seq[ puser->cur_seq ] << " sequence./n";
313.               }
314.               else 
315.               {
316.                   bump_guess( puser );
317.                   cout << wrong_msg[ num_tries < ns_wrong_msg ? num_tries : ns_wrong_msg-1 ]
318.                        << " Would you like to try again? (y/n) ";
320.                   char usr_rsp;
321.                   cin >> usr_rsp;
322.  
323.                   if ( usr_rsp == 'N' || usr_rsp == 'n' )
324.                        go_for_it = false;
325.                   else { ++num_tries; cout << "Your next guess? "; }
326.               }
327.         } 
329.         cout << "Want to try another sequence? (y/n) ";
330.         char try_again;
331.         cin >> try_again;
333.         if ( try_again == 'N' || try_again == 'n' )
334.              next_seq = false;
335.         else { got_it = false; reset_seq( puser ); }
336.     }
337. }