Case Study: Random Number Generation(翻译教材)

悠悠 2021-12-13 23:17 178阅读 0赞

很荣幸，经过三天的努力。终于把自己翻译的教材做完了，现在把它贴出来，希望能指出其中的不足![大笑][laugh.gif]![大笑][laugh.gif]![大笑][laugh.gif]。

# [Case Study: Random Number Generation][Case Study_ Random Number Generation] #

# Fig. 6.7 C++ 标准库头文件 (Part 3 of 3.)  #

##  6.7 Case的学习: 随机数的生成 ##

我们现在需要一个简短的，并希望娱乐的分流成为一种流行的编程应用，即模仿和玩游戏，在这一节和下一节当中，我们将要开发一个包含多选功能的游戏。

这些元素的产生可以使用C++的标准库来获得，仔细研读下面的语句

i = rand();

这个rand函数产生一个在0和RAND\_MAX（在<cstdlib>头文件中定义的常量）之间的无符号的整型随机数，你可以通过在屏幕上显示来改变这个系统的RAND\_MAX常量。如果rand正确的产生了随机整数，则在0和RAND\_MAX之间的每一个数字在使用rand函数的时候都有机会被挑选出来。

由rand函数直接产生的这些数值的范围与那些特定的函数要求的不同。比如，一个模拟掷硬币的项目可能就只要求用0来代表正面，用1来代表反面。一个模拟掷骰子的项目只需要在1和6之间的随机整数，一个随机的预言下一艘穿过地平线的飞船类型（只有4种可能性）的游戏（只有4种可能性）只需要在1和4之间的整数

### 掷骰子游戏 ###

为了证明rand函数，在6.8章模拟了掷出20个骰子和每个显示的数值的情况。rand函数的函数原型是在<cstdlib>。为了产生取值范围为0到5的整数，我们这样用取模运算符%和rand函数

rand() % 6

这就是所谓的缩放。数字6被称为缩放因子。然后我们转移范围，通过使之前产生的数字加1便可完成。图6.8确认，结果范围为1至6。

. **6.8 移动，缩放整数通过1 + rand() % 6. (Part 1 of 2.)**

Chapter 6 Functions and an Introduction to Recursion

1 // Fig. 6.8: fig06\_08.cpp

2 // Shifted and scaled random integers.

3 \#include <iostream>

4 \#include <iomanip>

5 \#include <cstdlib> // contains function prototype for rand

6 using namespace std;

8 int main()

9 \{

10 // loop 20 times

11 for ( int counter = 1; counter <= 20; ++counter )

12 \{

13 // pick random number from 1 to 6 and output it

14 cout << setw( 10 ) << ( 1 + rand() % 6 );

16 // if counter is divisible by 5, start a new line of output

17 if ( counter % 5 == 0 )

18 cout << endl;

19 // end for

20 // end main

运行结果如下

6 6 5 5 6

5 1 1 5 3

6 6 2 4 2

6 2 3 4 1

**Fig. 6.8移动，缩放整数通过1 + rand() % 6 . (Part 2 of 2.)**

**掷一个骰子6,000,000次(Part 1 of 2.)**

为了证明由rand函数产生的数字具有大致相等的可能性。Fig. 6.9模拟了一个骰子的6,000,000的投掷实验，则每个在1和6之间的整数应该出现大约1,000,000次。这个结论会由函数的输出来证实。

1 // Fig. 6.9: fig06\_09.cpp

2 // Rolling a six-sided die 6,000,000 times.

3 \#include <iostream>

4 \#include <iomanip>

5 \#include <cstdlib> // contains function prototype for rand

6 using namespace std;

8 int main()

9 \{

10 int frequency1 = 0 ; // count of 1s rolled

11 int frequency2 = 0 ; // count of 2s rolled

12 int frequency3 = 0 ; // count of 3s rolled

13 int frequency4 = 0 ; // count of 4s rolled

14 int frequency5 = 0 ; // count of 5s rolled

15 int frequency6 = 0 ; // count of 6s rolled

17 int face; // stores most recently rolled value

19 // summarize results of 6,000,000 rolls of a die

20 for ( int roll = 1; roll <= 6000000; ++roll )

21 \{ 22 face = 1 + rand() % 6; // random number from 1 to 6

24 // determine roll value 1-6 and increment appropriate counter

25 switch ( face )

26 \{

27 case 1:

28 ++frequency1; // increment the 1s counter

29 break;

30 case 2:

31 ++frequency2; // increment the 2s counter

32 break;

33 case 3:

34 ++frequency3; // increment the 3s counter

35 break;

36 case 4:

37 ++frequency4; // increment the 4s counter

38 break;

39 case 5:

40 ++frequency5; // increment the 5s counter

41 break;

42 case 6:

43 ++frequency6; // increment the 6s counter

44 break;

45 default: // invalid value

46 cout << "Program should never get here!";

47 // end switch

48 // end for

50 cout << "Face" << setw( 13 ) << "Frequency" << endl; // output headers

51 cout << " 1" << setw( 13 ) << frequency1

52 << "\\n 2" << setw( 13 ) << frequency2

53 << "\\n 3" << setw( 13 ) << frequency3

54 << "\\n 4" << setw( 13 ) << frequency4

55 << "\\n 5" << setw( 13 ) << frequency5

56 << "\\n 6" << setw( 13 ) << frequency6 << endl;

57 // end main

Face Frequency

1 999702

2 1000823

3 999378

4 998898

5 1000777

6 1000422

**Fig. 6.9 |掷一个骰子6,000,000次(Part 2 of 2.)**

从程序的输出可以看出，我们可以模拟一个六面骰子的滚动通过缩放和缩放rand函数产生的值来得到。这个程序应该永远到不了（45-46行）在默认情况下的switch结构，因为switch机的控制表达始终具有值在1-6范围内的，但是，我们提供的默认的情况下，作为一项更好的做法。我们研究在第7章数组后，我们将展示如何用一行语句来代替switch结构。

再次执行fig6.8de 程序的结果。

6 6 5 5 6

5 1 1 5 3

6 6 2 4 2

6 2 3 4 1

这个程序输出了和Fig. 6.8.一样的结果。试问这些是随机数吗？当调试一个模拟程序的时候，这种可重复性是必不可少的证明，更正程序工作正常。

rand函数产生伪随机数.rand重复的被调用产生的数字序列的出现是随机的。然而，每次程序执行重复序列. 一旦程序被彻底的调试，每个执行时它可以条件不同而产生不同的随机数序列。这就是所谓的随机和由C ++标准库函数srand来完成的。功能函数srand需要一个无符号的整数参数和通过rand函数的不同，每个执行而产生不同的随机数序列的。新的C ++标准提供额外的随机数的能力，可以产生不确定性的随机数字的一组无法预测的随机数字。这种随机数发生器用于模拟和安全情况下，可预测性是不可取的

使用 srand 函数

Figure 6.10  演示srand函数.这个程序使用一个无符号的类型，它比无符号的整形短。整形在内存中占用两个字节（通常为4个字节32位系统和64位系统上多达8个字节），可以有正也可以是负的。一个unsigned的类型的变量也至少在内存中占用两个字节，一个两个字节长度unsigned的整数可以存储0-65535范围之间的正数。一个四字节长度的unsigned整数能存储的值的范围为0 - 4294967295。功能函数srand需要一个unsigned int值作为参数。srand函数的函数原型是在头<cstdlib>。

**Fig. 6.10 | 模拟掷骰子的程序**

1 // Fig. 6.10: fig06\_10.cpp

2 // Randomizing the die-rolling program.

3 \#include <iostream>

4 \#include <iomanip>

5 \#include <cstdlib> // contains prototypes for functions srand and rand

6 using namespace std;

8 int main()

9 \{

10 unsigned seed; // stores the seed entered by the user

12 cout << "Enter seed: ";

13 cin >> seed;

14 srand( seed ); // seed random number generator

16 // loop 10 times

17 for ( int counter = 1; counter <= 10; ++counter )

18 \{

19 // pick random number from 1 to 6 and output it

20 cout << setw( 10 ) << ( 1 + rand() % 6 );

22 // if counter is divisible by 5, start a new line of output

23 if ( counter % 5 == 0 )

24 cout << endl;

25 // end for

26 // end main

Enter seed: 67

6 1 4 6 2

1 6 1 6 4

Enter seed: 432

4 6 3 1 6

3 1 5 4 2

Enter seed: 67

6 1 4 6 2

1 6 1 6 4

我们运行几次这个程序并且观察它的运行结果，我们会注意到这个程序每次运行的时候都会产生不同的随机数序列。在每次执行时，用户输入一个不同的seed。我们在第一个和第三个使用了相同的seed，则在输出的时候在屏幕上显示了相同的一组10个数字

为了在程序在每次运行的时候我们不用都输入seed，我们可以使用像下列的语句

srand( time( 0 ) );

这样使计算机读取它的时钟，以获得seed的值。时间函数（与前面的语句写在参数0）通常会返回当前时间为1970年1月以来的秒数，在格林威治标准时间的午夜（GMT）。这个值被转换为一个无符号整数，作为随机数发生器的seed。时间的函数原型是在<ctime>头文件中。

广义缩放和平移的随机数

以前，我们模拟了一个掷出六面骰子用这个语句

face = 1 + rand() % 6;

它总是分配一个在1和6之间的整数（随机）给变量face，这个范围的宽度（即连续整数的范围）是6并且1使这个范围里面的起始数字。参看前面的语句，我们看到的宽度范围是由取模运算符(i.e., 6)，和范围的起始号码是相等的数量(i.e., 1)，将被添加到的表达式rand％6。我们可以概括为这样的结果为

number = shiftingValue + rand() % scalingFactor ;

移值是等于所需的范围内连续的整数中的第一个数和scalingFactor等于所需的范围的宽度的连续的整数

**6.8 Case 的学习:概率游戏; 介绍枚举**

在最受欢迎的概率游戏当中有一个被称作“craps,”这是在全球范围内的赌场和小巷里盛行的游戏。它的游戏规则如下

一个玩家投掷两个骰子，每个骰子有六个面。每个骰子上的六个面上印有1,2,3,4,5,6这些数字。在骰子经过摇晃停下后，朝上的两个面的数字被加在一起求和。如果结果是7 or 11的话，这个玩家就赢了。如果结果是2，3 or 12的话，这个玩家就输了，庄家就赢了。如果结果是4, 5, 6, 8, 9 or 10的话，玩家就到了“point.”如果想赢的话，玩家必须making the point.但是一旦玩家投出的结果是7的话，他就输了。

图6.11中的程序模拟了游戏。注意规则，玩家在游戏过程中必须一次投掷两个骰子。我们定义函数rollDice(lines 63–75)，用来掷骰子并计算和打印它们的总和。该函数定义一次，但在21和45行之间被调用，该函数没有参数，它返回两个骰子的总和，所以将其定义为int型

1 // Fig. 6.11: fig06\_11.cpp

2 // Craps simulation.

3 \#include <iostream>

4 \#include <cstdlib> // contains prototypes for functions srand and rand

5 \#include <ctime> // contains prototype for function time

6 using namespace std;

8 int rollDice(); // rolls dice, calculates and displays sum

10 int main()

11 \{

12 // enumeration with constants that represent the game status

13 enum Status \{ CONTINUE , WON, LOST \}; // all caps in constants

15 int myPoint; // point if no win or loss on first roll

16 Status gameStatus; // can contain CONTINUE, WON or LOST

18 // randomize random number generator using current time

19 srand( time( 0 ) );

21 int sumOfDice = rollDice(); // first roll of the dice

**Fig. 6.1 1 | 模拟Craps . (Part 1 of 3.)**

23 // determine game status and point (if needed) based on first roll

24 switch ( sumOfDice )

25 \{

26 case 7: // win with 7 on first roll

27 case 11: // win with 11 on first roll

28 gameStatus = WON ;

29 break;

30 case 2: // lose with 2 on first roll

31 case 3: // lose with 3 on first roll

32 case 12: // lose with 12 on first roll

33 gameStatus = LOST;

34 break;

35 default: // did not win or lose, so remember point

36 gameStatus = CONTINUE; // game is not over

37 myPoint = sumOfDice; // remember the point

38 cout << "Point is " << myPoint << endl;

39 break; // optional at end of switch

40 // end switch

42 // while game is not complete

43 while ( gameStatus == CONTINUE ) // not WON or LOST

44 \{

45 sumOfDice = rollDice(); // roll dice again

47 // determine game status

48 if ( sumOfDice == myPoint ) // win by making point

49 gameStatus = WON ;

50 else

51 if ( sumOfDice == 7 ) // lose by rolling 7 before point

52 gameStatus = LOST;

53 // end while

55 // display won or lost message

56 if ( gameStatus == WON )

57 cout << "Player wins" << endl;

58 else

59 cout << "Player loses" << endl;

60 // end main

62 // roll dice, calculate sum and display results

63 int rollDice()

64 \{

65 // pick random die values

66 int die1 = 1 + rand() % 6; // first die roll

67 int die2 = 1 + rand() % 6; // second die roll

69 int sum = die1 + die2; // compute sum of die values

71 // display results of this roll

72 cout << "Player rolled " << die1 << " + " << die2

73 << " = " << sum << endl;

74 return sum; // end function rollDice

75 // end function rollDice

**F g. 6.1 1 | 模拟Craps (Part 2 of 3.)**

Player rolled 2 + 5 = 7

Player wins

Player rolled 6 + 6 = 12

Player loses

Player rolled 1 + 3 = 4

Point is 4

Player rolled 4 + 6 = 10

Player rolled 2 + 4 = 6

Player rolled 6 + 4 = 10

Player rolled 2 + 3 = 5

Player rolled 2 + 4 = 6

Player rolled 1 + 1 = 2

Player rolled 4 + 4 = 8

Player rolled 4 + 3 = 7

Player loses

Player rolled 3 + 3 = 6

Point is 6

Player rolled 5 + 3 = 8

Player rolled 4 + 5 = 9

Player rolled 2 + 1 = 3

Player rolled 1 + 5 = 6

Player wins

**Fig. 6.1 1 | 模拟Craps . (Part 3 of 3.)**

这个游戏是十分公平的，玩家可能在第一次就输掉，也可能在之后的模拟中才输。这个程序中使用变量gameStatus来记录具体的情况。gameStatus（13行）这个变量是一个新，用户定义的类型称为enume。枚举，介绍关键字枚举类型名称（在这种情况下，状态），是一家集标识符所代表的整数常量。通常这些enume的常数的值从0开始，除非另有规定，每次增加1。在前面的枚举，继续比赛值0，胜出得了值1，失败得了值2。枚举中的标识符必须是唯一的，但单独的枚举常量可以有相同的整数值

Good Programming Practice 6.1

作为一个用户定义的类型名称标识符的首字母大写

Good Programming Practice 6.2

使用枚举常量时使用大写字母。这使得这些常数在程序易于被观察到，并提醒您枚举常量不是变量。用户定义的类型状态的变量可以分配三个值中，可以只有一个

在枚举声明。当玩家赢得比赛的时候，程序把gameStatus赋值为赢得状态(lines 28 and 49).，当输了的时候，程序把gameStatus设置成输的状态

转载于:https://www.cnblogs.com/james1207/p/3362225.html

[laugh.gif]: /images/20211213/d7ae863f777645fa888b43aa9b96ef7f.png
[Case Study_ Random Number Generation]: http://pan.baidu.com/s/1opP9T