使用<random>在C ++中的随机数顺序

Question

I have the following code, that I wrote to test a part of a larger program :

#include <fstream>
#include <random>
#include <iostream>
using namespace std ;

int main()
{
  mt19937_64 Generator(12187) ;
  mt19937_64 Generator2(12187) ;
  uniform_int_distribution<int> D1(1,6) ;

  cout << D1(Generator) << " " ;
  cout << D1(Generator) << " " << D1(Generator) << endl ;
  cout << D1(Generator2) << " " << D1(Generator2) << " " << D1(Generator2) << endl ;

  ofstream g1("g1.dat") ;
  g1 << Generator ;
  g1.close() ;
  ofstream g2("g2.dat") ;
  g2 << Generator2 ;
  g2.close() ;
}                                                            

The two generators are seeded with the same value, and therefore I expected the second row in the output to be identical to the first one. Instead, the output is

1 1 3
1 3 1

The state of the two generators as printed in the *.dat files is the same. I was wondering if there might be some hidden multi-threading in the random number generation causing the order mismatch.

I compiled with g++ version 5.3.0, on Linux, with the flag -std=c++11 .

Thanks in advance for your help.

Answer 1

x << y is syntactic sugar for a function call to operator<<(x, y) .

You will remember that the c++ standard places no restriction on the order of evaluation of the arguments of a function call.

So the compiler is free to emit code that computes x first or y first.

From the standard: §5 note 2:

Operators can be overloaded, that is, given meaning when applied to expressions of class type (Clause 9) or enumeration type (7.2). Uses of overloaded operators are transformed into function calls as described in 13.5 . Overloaded operators obey the rules for syntax specified in Clause 5, but the requirements of operand type, value category, and evaluation order are replaced by the rules for function call .

Answer 2

That's because the order of evaluation of this line

cout << D1(Generator2) << " " << D1(Generator2) << " " << D1(Generator2) << endl ;

is not what you think.

You can test it with this:

int f() {
  static int i = 0;
  return i++;
}

int main() {
  cout << f() << " " << f() << " " << f() << endl ;
  return 0;
}

Output: 2 1 0

---

The order is not specified by the C++ standard, so the order could be different on other compilers, please see Richard Hodges' answer.

Answer 3

A slight change to the program reveals what happens:

#include <fstream>
#include <random>
#include <iostream>
using namespace std ;

int main()
{
  mt19937_64 Generator(12187) ;
  mt19937_64 Generator2(12187) ;
  uniform_int_distribution<int> D1(1,100) ;

  cout << D1(Generator) << " " ;
  cout << D1(Generator) << " " ;
  cout << D1(Generator) << endl ;
  cout << D1(Generator2) << " " << D1(Generator2) << " " << D1(Generator2) << endl ;
}

Output:

4 48 12
12 48 4

So your Generators produce equal results - but the order the arguments of your cout-line are calculated in different order.

Try it online: http://ideone.com/rsoqDe

Answer 4

These lines

  cout << D1(Generator) << " " ;

  cout << D1(Generator) << " "
       << D1(Generator) << endl ;

  cout << D1(Generator2) << " "
       << D1(Generator2) << " "
       << D1(Generator2) << endl ;

because D1() returns an int, for which ostream::operator<<() has an overload, are effectively calling (excluding endl )

cout.operator<<(D1(Generator));

cout.operator<<(D1(Generator))
    .operator<<(D1(Generator));

cout.operator<<(D1(Generator2))
    .operator<<(D1(Generator2))
    .operator<<(D1(Generator2));

Now, the standard has this to say,

§ 5.2.2 [4]

When a function is called, each parameter shall be initialized with its corresponding argument.

[ Note: Such initializations are indeterminately sequenced with respect to each other — end note ]

If the function is a non-static member function, the this parameter of the function shall be initialized with a pointer to the object of the call

So let's break down the preceding expression

cout.operator<<(a())  // #1
    .operator<<(b())  // #2
    .operator<<(c()); // #3

To illustrate the construction of the this pointer, these are conceptually equivalent to (omitting ostream:: for brevity):

operator<<(           // #1
  &operator<<(        // #2
    &operator<<(      // #3
      &cout,
      a()
    ),                // end #3
    b()
  ),                  // end #2
  c()
);                    // end #1

Now let's look at the top-level call. Which do we evaluate first, #2 , or c() ? Since, as emphasized in the quote, the order is indeterminate, then we don't know—and this is true recursively: even if we evaluated #2 , we would still face the question of whether to evaluate its internal #3 or b() .

So that hopefully explains what's going on here more clearly.