VS2010下编译配置Boost_1.53

   b2 --build-dir=build-directory toolset=toolset-name --build-type=complete stage

我的编译命令为： b2 --build-dir=c:\boost_1_53\build_manual toolset=msvc --build-type=complete stage

 1 #include <iostream>
 2 #include <fstream>
 3 #include <ctime>            // std::time
 4 
 5 #include <boost/random/linear_congruential.hpp>
 6 #include <boost/random/uniform_int.hpp>
 7 #include <boost/random/uniform_real.hpp>
 8 #include <boost/random/variate_generator.hpp>
 9 #include <boost/generator_iterator.hpp>
10 
11 // This is a typedef for a random number generator.
12 // Try boost::mt19937 or boost::ecuyer1988 instead of boost::minstd_rand
13 typedef boost::minstd_rand base_generator_type;
14 
15 // This is a reproducible simulation experiment.  See main().
16 void experiment(base_generator_type & generator)
17 {
18   // Define a uniform random number distribution of integer values between
19   // 1 and 6 inclusive.
20   typedef boost::uniform_int<> distribution_type;
21   typedef boost::variate_generator<base_generator_type&, distribution_type> gen_type;
22   gen_type die_gen(generator, distribution_type(1, 6));
23 
24   // If you want to use an STL iterator interface, use iterator_adaptors.hpp.
25   boost::generator_iterator<gen_type> die(&die_gen);
26   for(int i = 0; i < 10; i++)
27     std::cout << *die++ << " ";
28   std::cout << '\n';
29 }
30 
31 int main()
32 {
33   // Define a random number generator and initialize it with a reproducible
34   // seed.
35   base_generator_type generator(42);
36 
37   std::cout << "10 samples of a uniform distribution in [0..1):\n";
38 
39   // Define a uniform random number distribution which produces "double"
40   // values between 0 and 1 (0 inclusive, 1 exclusive).
41   boost::uniform_real<> uni_dist(0,1);
42   boost::variate_generator<base_generator_type&, boost::uniform_real<> > uni(generator, uni_dist);
43 
44   std::cout.setf(std::ios::fixed);
45   // You can now retrieve random numbers from that distribution by means
46   // of a STL Generator interface, i.e. calling the generator as a zero-
47   // argument function.
48   for(int i = 0; i < 10; i++)
49     std::cout << uni() << '\n';
50 
51   /*
52    * Change seed to something else.
53    *
54    * Caveat: std::time(0) is not a very good truly-random seed.  When
55    * called in rapid succession, it could return the same values, and
56    * thus the same random number sequences could ensue.  If not the same
57    * values are returned, the values differ only slightly in the
58    * lowest bits.  A linear congruential generator with a small factor
59    * wrapped in a uniform_smallint (see experiment) will produce the same
60    * values for the first few iterations.   This is because uniform_smallint
61    * takes only the highest bits of the generator, and the generator itself
62    * needs a few iterations to spread the initial entropy from the lowest bits
63    * to the whole state.
64    */
65   generator.seed(static_cast<unsigned int>(std::time(0)));
66 
67   std::cout << "\nexperiment: roll a die 10 times:\n";
68 
69   // You can save a generator's state by copy construction.
70   base_generator_type saved_generator = generator;
71 
72   // When calling other functions which take a generator or distribution
73   // as a parameter, make sure to always call by reference (or pointer).
74   // Calling by value invokes the copy constructor, which means that the
75   // sequence of random numbers at the caller is disconnected from the
76   // sequence at the callee.
77   experiment(generator);
78 
79   std::cout << "redo the experiment to verify it:\n";
80   experiment(saved_generator);
81 
82   // After that, both generators are equivalent
83   assert(generator == saved_generator);
84 
85   // as a degenerate case, you can set min = max for uniform_int
86   boost::uniform_int<> degen_dist(4,4);
87   boost::variate_generator<base_generator_type&, boost::uniform_int<> > deg(generator, degen_dist);
88   std::cout << deg() << " " << deg() << " " << deg() << std::endl;
89   
90   {
91     // You can save the generator state for future use.  You can read the
92     // state back in at any later time using operator>>.
93     std::ofstream file("rng.saved", std::ofstream::trunc);
94     file << generator;
95   }
96 
97   getchar();
98   return 0;
99 }