mt19937是什么鬼？

今天看一个C++的例子，突然看到这个mt19937，起先还以为是什么地方搞错了，怎么会有这个怪的名称呢？这个名称是mt1937? 代表1937年？心里一开始有这个疑问。代码如下：

std::random_device rd;std::mt19937 gen(rd());std::uniform_int_distribution<> dist(-10, 10);std::vector<int> v;generate_n(back_inserter(v), 20, bind(dist, gen));std::cout << "Before sort: ";copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));selection_sort(v.begin(), v.end());std::cout << "\nAfter sort: ";copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));std::cout << '\n';

后来通过查看MSDN以及网络相关的文章，才了解到这个是最新的计算随机数的算法。

Mersenne Twister算法译为马特赛特旋转演算法，是伪随机数发生器之一，其主要作用是生成伪随机数。此算法是Makoto Matsumoto （松本）和Takuji Nishimura （西村）于1997年开发的，基于有限二进制字段上的矩阵线性再生。可以快速产生高质量的伪随机数，修正了古老随机数产生算法的很多缺陷。Mersenne Twister这个名字来自周期长度通常取Mersenne质数这样一个事实。常见的有两个变种Mersenne Twister MT19937和Mersenne Twister MT19937-64。
Mersenne Twister算法的原理：Mersenne Twister算法是利用线性反馈移位寄存器(LFSR)产生随机数的，LFSR的反馈函数是寄存器中某些位的简单异或，这些位也称之为抽头序列。一个n位的LFSR能够在重复之前产生2^n-1位长的伪随机序列。只有具有一定抽头序列的LFSR才能通过所有2^n-1个内部状态，产生2^n - 1位长的伪随机序列，这个输出的序列就称之为m序列。为了使LFSR成为最大周期的LFSR，由抽头序列加上常数1形成的多项式必须是本原多项式。一个n阶本原多项式是不可约多项式，它能整除x^(2*n-1)+1而不能整除x^d+1，其中d能整除2^n-1。例如(32,7,5,3,2,1,0)是指本原多项式x^32+x^7+x^5+x^3+x^2+x+1，把它转化为最大周期LFSR就是在LFSR的第32，7，5，2，1位抽头。利用上述两种方法产生周期为m的伪随机序列后，只需要将产生的伪随机序列除以序列的周期，就可以得到(0，1)上均匀分布的伪随机序列了。
Mersenne Twister有以下优点：随机性好，在计算机上容易实现，占用内存较少(mt19937的C程式码执行仅需624个字的工作区域)，与其它已使用的伪随机数发生器相比，产生随机数的速度快、周期长，可达到2^19937-1，且具有623维均匀分布的性质，对于一般的应用来说，足够大了，序列关联比较小，能通过很多随机性测试。
马特赛特旋转演算法产生一个伪随机数，一般为MtRand()。

从这段话里可以看到它是2的19937次方，所以它的名称就来源这里。

在STL标准库定义如下：

typedef mersenne_twister_engine<uint_fast32_t,32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253>mt19937;

这个算法在C++里简单地实现如下：

#include <stdint.h>// Define MT19937 constants (32-bit RNG)
enum
{// Assumes W = 32 (omitting this)N = 624,M = 397,R = 31,A = 0x9908B0DF,F = 1812433253,U = 11,// Assumes D = 0xFFFFFFFF (omitting this)S = 7,B = 0x9D2C5680,T = 15,C = 0xEFC60000,L = 18,MASK_LOWER = (1ull << R) - 1,MASK_UPPER = (1ull << R)
};static uint32_t  mt[N];
static uint16_t  index;// Re-init with a given seed
void Initialize(const uint32_t  seed)
{uint32_t  i;mt[0] = seed;for ( i = 1; i < N; i++ ){mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i);}index = N;
}static void Twist()
{uint32_t  i, x, xA;for ( i = 0; i < N; i++ ){x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER);xA = x >> 1;if ( x & 0x1 )xA ^= A;mt[i] = mt[(i + M) % N] ^ xA;}index = 0;
}// Obtain a 32-bit random number
uint32_t ExtractU32()
{uint32_t  y;int       i = index;if ( index >= N ){Twist();i = index;}y = mt[i];index = i + 1;y ^= (mt[i] >> U);y ^= (y << S) & B;y ^= (y << T) & C;y ^= (y >> L);return y;
}

相关网站：

http://www.cppblog.com/Chipset/archive/2009/01/19/72330.html

boost库的实现：

/* boost random/mersenne_twister.hpp header file** Copyright Jens Maurer 2000-2001* Copyright Steven Watanabe 2010* Distributed under the Boost Software License, Version 1.0. (See* accompanying file LICENSE_1_0.txt or copy at* http://www.boost.org/LICENSE_1_0.txt)** See http://www.boost.org for most recent version including documentation.** $Id: mersenne_twister.hpp 74867 2011-10-09 23:13:31Z steven_watanabe $** Revision history*  2001-02-18  moved to individual header files*/#ifndef BOOST_RANDOM_MERSENNE_TWISTER_HPP
#define BOOST_RANDOM_MERSENNE_TWISTER_HPP#include <iosfwd>
#include <istream>
#include <stdexcept>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/integer/integer_mask.hpp>
#include <boost/random/detail/config.hpp>
#include <boost/random/detail/ptr_helper.hpp>
#include <boost/random/detail/seed.hpp>
#include <boost/random/detail/seed_impl.hpp>
#include <boost/random/detail/generator_seed_seq.hpp>namespace boost {
namespace random {/*** Instantiations of class template mersenne_twister_engine model a* \pseudo_random_number_generator. It uses the algorithm described in**  @blockquote*  "Mersenne Twister: A 623-dimensionally equidistributed uniform*  pseudo-random number generator", Makoto Matsumoto and Takuji Nishimura,*  ACM Transactions on Modeling and Computer Simulation: Special Issue on*  Uniform Random Number Generation, Vol. 8, No. 1, January 1998, pp. 3-30. *  @endblockquote** @xmlnote* The boost variant has been implemented from scratch and does not* derive from or use mt19937.c provided on the above WWW site. However, it* was verified that both produce identical output.* @endxmlnote** The seeding from an integer was changed in April 2005 to address a* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html">weakness</a>.* * The quality of the generator crucially depends on the choice of the* parameters.  User code should employ one of the sensibly parameterized* generators such as \mt19937 instead.** The generator requires considerable amounts of memory for the storage of* its state array. For example, \mt11213b requires about 1408 bytes and* \mt19937 requires about 2496 bytes.*/
template<class UIntType,std::size_t w, std::size_t n, std::size_t m, std::size_t r,UIntType a, std::size_t u, UIntType d, std::size_t s,UIntType b, std::size_t t,UIntType c, std::size_t l, UIntType f>
class mersenne_twister_engine
{
public:typedef UIntType result_type;BOOST_STATIC_CONSTANT(std::size_t, word_size = w);BOOST_STATIC_CONSTANT(std::size_t, state_size = n);BOOST_STATIC_CONSTANT(std::size_t, shift_size = m);BOOST_STATIC_CONSTANT(std::size_t, mask_bits = r);BOOST_STATIC_CONSTANT(UIntType, xor_mask = a);BOOST_STATIC_CONSTANT(std::size_t, tempering_u = u);BOOST_STATIC_CONSTANT(UIntType, tempering_d = d);BOOST_STATIC_CONSTANT(std::size_t, tempering_s = s);BOOST_STATIC_CONSTANT(UIntType, tempering_b = b);BOOST_STATIC_CONSTANT(std::size_t, tempering_t = t);BOOST_STATIC_CONSTANT(UIntType, tempering_c = c);BOOST_STATIC_CONSTANT(std::size_t, tempering_l = l);BOOST_STATIC_CONSTANT(UIntType, initialization_multiplier = f);BOOST_STATIC_CONSTANT(UIntType, default_seed = 5489u);// backwards compatibilityBOOST_STATIC_CONSTANT(UIntType, parameter_a = a);BOOST_STATIC_CONSTANT(std::size_t, output_u = u);BOOST_STATIC_CONSTANT(std::size_t, output_s = s);BOOST_STATIC_CONSTANT(UIntType, output_b = b);BOOST_STATIC_CONSTANT(std::size_t, output_t = t);BOOST_STATIC_CONSTANT(UIntType, output_c = c);BOOST_STATIC_CONSTANT(std::size_t, output_l = l);// old Boost.Random concept requirementsBOOST_STATIC_CONSTANT(bool, has_fixed_range = false);/*** Constructs a @c mersenne_twister_engine and calls @c seed().*/mersenne_twister_engine() { seed(); }/*** Constructs a @c mersenne_twister_engine and calls @c seed(value).*/BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister_engine,UIntType, value){ seed(value); }template<class It> mersenne_twister_engine(It& first, It last){ seed(first,last); }/*** Constructs a mersenne_twister_engine and calls @c seed(gen).** @xmlnote* The copy constructor will always be preferred over* the templated constructor.* @endxmlnote*/BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(mersenne_twister_engine,SeedSeq, seq){ seed(seq); }// compiler-generated copy ctor and assignment operator are fine/** Calls @c seed(default_seed). */void seed() { seed(default_seed); }/*** Sets the state x(0) to v mod 2w. Then, iteratively,* sets x(i) to* (i + f * (x(i-1) xor (x(i-1) rshift w-2))) mod 2<sup>w</sup>* for i = 1 .. n-1. x(n) is the first value to be returned by operator().*/BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister_engine, UIntType, value){// New seeding algorithm from // http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html// In the previous versions, MSBs of the seed affected only MSBs of the// state x[].const UIntType mask = (max)();x[0] = value & mask;for (i = 1; i < n; i++) {// See Knuth "The Art of Computer Programming"// Vol. 2, 3rd ed., page 106x[i] = (f * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;}}/*** Seeds a mersenne_twister_engine using values produced by seq.generate().*/BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(mersenne_twister_engine, SeeqSeq, seq){detail::seed_array_int<w>(seq, x);i = n;// fix up the state if it's all zeroes.if((x[0] & (~static_cast<UIntType>(0) << r)) == 0) {for(std::size_t j = 1; j < n; ++j) {if(x[j] != 0) return;}x[0] = static_cast<UIntType>(1) << (w-1);}}/** Sets the state of the generator using values from an iterator range. */template<class It>void seed(It& first, It last){detail::fill_array_int<w>(first, last, x);i = n;// fix up the state if it's all zeroes.if((x[0] & (~static_cast<UIntType>(0) << r)) == 0) {for(std::size_t j = 1; j < n; ++j) {if(x[j] != 0) return;}x[0] = static_cast<UIntType>(1) << (w-1);}}/** Returns the smallest value that the generator can produce. */static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0; }/** Returns the largest value that the generator can produce. */static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return boost::low_bits_mask_t<w>::sig_bits; }/** Produces the next value of the generator. */result_type operator()();/** Fills a range with random values */template<class Iter>void generate(Iter first, Iter last){ detail::generate_from_int(*this, first, last); }/*** Advances the state of the generator by @c z steps.  Equivalent to** @code* for(unsigned long long i = 0; i < z; ++i) {*     gen();* }* @endcode*/void discard(boost::uintmax_t z){for(boost::uintmax_t j = 0; j < z; ++j) {(*this)();}}#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS/** Writes a mersenne_twister_engine to a @c std::ostream */template<class CharT, class Traits>friend std::basic_ostream<CharT,Traits>&operator<<(std::basic_ostream<CharT,Traits>& os,const mersenne_twister_engine& mt){mt.print(os);return os;}/** Reads a mersenne_twister_engine from a @c std::istream */template<class CharT, class Traits>friend std::basic_istream<CharT,Traits>&operator>>(std::basic_istream<CharT,Traits>& is,mersenne_twister_engine& mt){for(std::size_t j = 0; j < mt.state_size; ++j)is >> mt.x[j] >> std::ws;// MSVC (up to 7.1) and Borland (up to 5.64) don't handle the template// value parameter "n" available from the class template scope, so use// the static constant with the same valuemt.i = mt.state_size;return is;}
#endif/*** Returns true if the two generators are in the same state,* and will thus produce identical sequences.*/friend bool operator==(const mersenne_twister_engine& x,const mersenne_twister_engine& y){if(x.i < y.i) return x.equal_imp(y);else return y.equal_imp(x);}/*** Returns true if the two generators are in different states.*/friend bool operator!=(const mersenne_twister_engine& x,const mersenne_twister_engine& y){ return !(x == y); }private:/// \cond show_privatevoid twist();/*** Does the work of operator==.  This is in a member function* for portability.  Some compilers, such as msvc 7.1 and* Sun CC 5.10 can't access template parameters or static* members of the class from inline friend functions.** requires i <= other.i*/bool equal_imp(const mersenne_twister_engine& other) const{UIntType back[n];std::size_t offset = other.i - i;for(std::size_t j = 0; j + offset < n; ++j)if(x[j] != other.x[j+offset])return false;rewind(&back[n-1], offset);for(std::size_t j = 0; j < offset; ++j)if(back[j + n - offset] != other.x[j])return false;return true;}/*** Does the work of operator<<.  This is in a member function* for portability.*/template<class CharT, class Traits>void print(std::basic_ostream<CharT, Traits>& os) const{UIntType data[n];for(std::size_t j = 0; j < i; ++j) {data[j + n - i] = x[j];}if(i != n) {rewind(&data[n - i - 1], n - i);}os << data[0];for(std::size_t j = 1; j < n; ++j) {os << ' ' << data[j];}}/*** Copies z elements of the state preceding x[0] into* the array whose last element is last.*/void rewind(UIntType* last, std::size_t z) const{const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;const UIntType lower_mask = ~upper_mask;UIntType y0 = x[m-1] ^ x[n-1];if(y0 & (static_cast<UIntType>(1) << (w-1))) {y0 = ((y0 ^ a) << 1) | 1;} else {y0 = y0 << 1;}for(std::size_t sz = 0; sz < z; ++sz) {UIntType y1 =rewind_find(last, sz, m-1) ^ rewind_find(last, sz, n-1);if(y1 & (static_cast<UIntType>(1) << (w-1))) {y1 = ((y1 ^ a) << 1) | 1;} else {y1 = y1 << 1;}*(last - sz) = (y0 & upper_mask) | (y1 & lower_mask);y0 = y1;}}/*** Given a pointer to the last element of the rewind array,* and the current size of the rewind array, finds an element* relative to the next available slot in the rewind array.*/UIntTyperewind_find(UIntType* last, std::size_t size, std::size_t j) const{std::size_t index = (j + n - size + n - 1) % n;if(index < n - size) {return x[index];} else {return *(last - (n - 1 - index));}}/// \endcond// state representation: next output is o(x(i))//   x[0]  ... x[k] x[k+1] ... x[n-1]   represents//  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1)UIntType x[n]; std::size_t i;
};/// \cond show_private#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
//  A definition is required even for integral static constants
#define BOOST_RANDOM_MT_DEFINE_CONSTANT(type, name)                         \
template<class UIntType, std::size_t w, std::size_t n, std::size_t m,       \std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s,    \UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>       \
const type mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::name
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, word_size);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, state_size);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, shift_size);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, mask_bits);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, xor_mask);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_u);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_d);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_s);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_b);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_t);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_c);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_l);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, initialization_multiplier);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, default_seed);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, parameter_a);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_u );
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_s);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_b);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_t);
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_c);
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_l);
BOOST_RANDOM_MT_DEFINE_CONSTANT(bool, has_fixed_range);
#undef BOOST_RANDOM_MT_DEFINE_CONSTANT
#endiftemplate<class UIntType,std::size_t w, std::size_t n, std::size_t m, std::size_t r,UIntType a, std::size_t u, UIntType d, std::size_t s,UIntType b, std::size_t t,UIntType c, std::size_t l, UIntType f>
void
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::twist()
{const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;const UIntType lower_mask = ~upper_mask;const std::size_t unroll_factor = 6;const std::size_t unroll_extra1 = (n-m) % unroll_factor;const std::size_t unroll_extra2 = (m-1) % unroll_factor;// split loop to avoid costly modulo operations{  // extra scope for MSVC brokenness w.r.t. for scopefor(std::size_t j = 0; j < n-m-unroll_extra1; j++) {UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);}}{for(std::size_t j = n-m-unroll_extra1; j < n-m; j++) {UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);}}{for(std::size_t j = n-m; j < n-1-unroll_extra2; j++) {UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);}}{for(std::size_t j = n-1-unroll_extra2; j < n-1; j++) {UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);}}// last iterationUIntType y = (x[n-1] & upper_mask) | (x[0] & lower_mask);x[n-1] = x[m-1] ^ (y >> 1) ^ ((x[0]&1) * a);i = 0;
}
/// \endcondtemplate<class UIntType,std::size_t w, std::size_t n, std::size_t m, std::size_t r,UIntType a, std::size_t u, UIntType d, std::size_t s,UIntType b, std::size_t t,UIntType c, std::size_t l, UIntType f>
inline typename
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::result_type
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::operator()()
{if(i == n)twist();// Step 4UIntType z = x[i];++i;z ^= ((z >> u) & d);z ^= ((z << s) & b);z ^= ((z << t) & c);z ^= (z >> l);return z;
}/*** The specializations \mt11213b and \mt19937 are from**  @blockquote*  "Mersenne Twister: A 623-dimensionally equidistributed*  uniform pseudo-random number generator", Makoto Matsumoto*  and Takuji Nishimura, ACM Transactions on Modeling and*  Computer Simulation: Special Issue on Uniform Random Number*  Generation, Vol. 8, No. 1, January 1998, pp. 3-30. *  @endblockquote*/
typedef mersenne_twister_engine<uint32_t,32,351,175,19,0xccab8ee7,11,0xffffffff,7,0x31b6ab00,15,0xffe50000,17,1812433253> mt11213b;/*** The specializations \mt11213b and \mt19937 are from**  @blockquote*  "Mersenne Twister: A 623-dimensionally equidistributed*  uniform pseudo-random number generator", Makoto Matsumoto*  and Takuji Nishimura, ACM Transactions on Modeling and*  Computer Simulation: Special Issue on Uniform Random Number*  Generation, Vol. 8, No. 1, January 1998, pp. 3-30. *  @endblockquote*/
typedef mersenne_twister_engine<uint32_t,32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253> mt19937;#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
typedef mersenne_twister_engine<uint64_t,64,312,156,31,UINT64_C(0xb5026f5aa96619e9),29,UINT64_C(0x5555555555555555),17,UINT64_C(0x71d67fffeda60000),37,UINT64_C(0xfff7eee000000000),43,UINT64_C(6364136223846793005)> mt19937_64;
#endif/// \cond show_deprecatedtemplate<class UIntType,int w, int n, int m, int r,UIntType a, int u, std::size_t s,UIntType b, int t,UIntType c, int l, UIntType v>
class mersenne_twister :public mersenne_twister_engine<UIntType,w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253>
{typedef mersenne_twister_engine<UIntType,w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253> base_type;
public:mersenne_twister() {}BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(mersenne_twister, Gen, gen){ seed(gen); }BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister, UIntType, val){ seed(val); }template<class It>mersenne_twister(It& first, It last) : base_type(first, last) {}void seed() { base_type::seed(); }BOOST_RANDOM_DETAIL_GENERATOR_SEED(mersenne_twister, Gen, gen){detail::generator_seed_seq<Gen> seq(gen);base_type::seed(seq);}BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister, UIntType, val){ base_type::seed(val); }template<class It>void seed(It& first, It last) { base_type::seed(first, last); }
};/// \endcond} // namespace randomusing random::mt11213b;
using random::mt19937;
using random::mt19937_64;} // namespace boostBOOST_RANDOM_PTR_HELPER_SPEC(boost::mt11213b)
BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937)
BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937_64)#endif // BOOST_RANDOM_MERSENNE_TWISTER_HPP

1. C++标准模板库从入门到精通

http://edu.csdn.net/course/detail/3324

2.跟老菜鸟学C++

http://edu.csdn.net/course/detail/2901

3. 跟老菜鸟学python

http://edu.csdn.net/course/detail/2592

4. 在VC2015里学会使用tinyxml库

http://edu.csdn.net/course/detail/2590

5. 在Windows下SVN的版本管理与实战

http://edu.csdn.net/course/detail/2579

6.Visual Studio 2015开发C++程序的基本使用

http://edu.csdn.net/course/detail/2570

7.在VC2015里使用protobuf协议

http://edu.csdn.net/course/detail/2582

8.在VC2015里学会使用MySQL数据库

http://edu.csdn.net/course/detail/2672