在现代c++中，你可以使用c++11附带的<random>头文件。 要获得随机浮点数，可以使用std::uniform_real_distribution<>。

你可以使用一个函数来生成数字，如果你不希望数字总是相同的，那就将引擎和分布设置为静态。 例子:

float get_random()
{
    static std::default_random_engine e;
    static std::uniform_real_distribution<> dis(0, 1); // rage 0 - 1
    return dis(e);
}

理想的做法是将浮动对象放置在std::vector:这样的容器中:

int main()
{
    std::vector<float> nums;
    for (int i{}; i != 5; ++i) // Generate 5 random floats
        nums.emplace_back(get_random());

    for (const auto& i : nums) std::cout << i << " ";
}

示例输出:

0.0518757 0.969106 0.0985112 0.0895674 0.895542

在我看来，上面的答案确实给出了一些“随机”浮点数，但它们都不是真正的随机浮点数(即它们错过了浮点数表示的一部分)。在我进入我的实现之前，让我们先看看浮点数的ANSI/IEEE标准格式:

|符号(1位)| e(8位)| f(23位)|

这个词代表的数字是 (-1 *号)* 2^e * 1.f

注意“e”是一个有偏差的数字(偏差为127)，因此范围从-127到126。最简单的(实际上也是最随机的)函数是将随机int类型的数据写入浮点数，因此

int tmp = rand();
float f = (float)*((float*)&tmp);

注意，如果你做浮动f = (float)rand();它将整数转换为浮点数(因此10将变成10.0)。 现在如果你想限制最大值你可以这样做(不确定是否有效)

int tmp = rand();
float f = *((float*)&tmp);
tmp = (unsigned int)f       // note float to int conversion!
tmp %= max_number;
f -= tmp;

但是如果你观察浮点数的结构，你会发现浮点数的最大值大约是2^127，这比int数的最大值(2^32)要大得多，因此排除了很大一部分可以用浮点数表示的数字。 这是我的最终实现:

/**
 * Function generates a random float using the upper_bound float to determine 
 * the upper bound for the exponent and for the fractional part.
 * @param min_exp sets the minimum number (closest to 0) to 1 * e^min_exp (min -127)
 * @param max_exp sets the maximum number to 2 * e^max_exp (max 126)
 * @param sign_flag if sign_flag = 0 the random number is always positive, if 
 *              sign_flag = 1 then the sign bit is random as well
 * @return a random float
 */
float randf(int min_exp, int max_exp, char sign_flag) {
    assert(min_exp <= max_exp);

    int min_exp_mod = min_exp + 126;

    int sign_mod = sign_flag + 1;
    int frac_mod = (1 << 23);

    int s = rand() % sign_mod;  // note x % 1 = 0
    int e = (rand() % max_exp) + min_exp_mod;
    int f = rand() % frac_mod;

    int tmp = (s << 31) | (e << 23) | f;

    float r = (float)*((float*)(&tmp));

    /** uncomment if you want to see the structure of the float. */
//    printf("%x, %x, %x, %x, %f\n", (s << 31), (e << 23), f, tmp, r);

    return r;
}

使用这个函数randf(0,8,0)将返回一个介于0.0和255.0之间的随机数

在一些系统上(目前想到的是带有VC的Windows)， RAND_MAX小得可笑，也就是只有15位。当除以RAND_MAX时，你只生成了一个15位的尾数，而不是23位。这对您来说可能是问题，也可能不是问题，但在这种情况下，您会遗漏一些值。

哦，刚才注意到已经有关于这个问题的注释了。不管怎样，这里有一些代码可以帮你解决这个问题:

float r = (float)((rand() << 15 + rand()) & ((1 << 24) - 1)) / (1 << 24);

未经测试，但可能工作:-)

c++ 11提供了很多随机的新选项。关于这个主题的权威论文是N3551, c++ 11中的随机数生成

要了解为什么使用rand()会有问题，请参阅Stephan T. Lavavej在2013年GoingNative活动期间所做的rand()被认为是有害的演示材料。幻灯片在评论中，这里有一个直接链接。

我还介绍了boost以及使用rand，因为遗留代码可能仍然需要它的支持。

下面的例子是从cppreference站点提取出来的，它使用了std::mersenne_twister_engine引擎和std::uniform_real_distribution引擎，后者在[0,10]区间内生成数字，其他引擎和分布被注释掉了(见现场):

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>

int main()
{
    std::random_device rd;

    //
    // Engines 
    //
    std::mt19937 e2(rd());
    //std::knuth_b e2(rd());
    //std::default_random_engine e2(rd()) ;

    //
    // Distribtuions
    //
    std::uniform_real_distribution<> dist(0, 10);
    //std::normal_distribution<> dist(2, 2);
    //std::student_t_distribution<> dist(5);
    //std::poisson_distribution<> dist(2);
    //std::extreme_value_distribution<> dist(0,2);

    std::map<int, int> hist;
    for (int n = 0; n < 10000; ++n) {
        ++hist[std::floor(dist(e2))];
    }

    for (auto p : hist) {
        std::cout << std::fixed << std::setprecision(1) << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*') << '\n';
    }
}

输出将类似如下:

0 ****
1 ****
2 ****
3 ****
4 *****
5 ****
6 *****
7 ****
8 *****
9 ****

输出将根据你选择的分布而变化，所以如果我们决定使用std::normal_distribution，将mean和stddev的值都设为2，例如dist(2,2)，而不是输出将类似于此(参见现场):

-6 
-5 
-4 
-3 
-2 **
-1 ****
 0 *******
 1 *********
 2 *********
 3 *******
 4 ****
 5 **
 6 
 7 
 8 
 9 

以下是N3551中一些代码的修改版本(见现场):

#include <algorithm>
#include <array>
#include <iostream>
#include <random>

std::default_random_engine & global_urng( )
{
    static std::default_random_engine u{};
    return u ;
}

void randomize( )
{
    static std::random_device rd{};
    global_urng().seed( rd() );
}

int main( )
{
  // Manufacture a deck of cards:
  using card = int;
  std::array<card,52> deck{};
  std::iota(deck.begin(), deck.end(), 0);

  randomize( ) ;  

  std::shuffle(deck.begin(), deck.end(), global_urng());
  // Display each card in the shuffled deck:
  auto suit = []( card c ) { return "SHDC"[c / 13]; };
  auto rank = []( card c ) { return "AKQJT98765432"[c % 13]; };

  for( card c : deck )
      std::cout << ' ' << rank(c) << suit(c);

   std::cout << std::endl;
}

结果将类似于:

5h 5s as 9s 4d 6h th 6d kh 2s qs 9h 8h 3d kc td 7h 2d ks 3c tc 7d 4c qh qc qd jd ah jc ac kd 9d 5c 2h 4h 9c 8c jh 5d 4s 7c AD 3s 8s ts 2c 8d 3h 6c js 7s 6s

提高

当然是Boost。随机总是一个选项，这里我使用boost:: Random::uniform_real_distribution:

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>

int main()
{
    boost::random::mt19937 gen;
    boost::random::uniform_real_distribution<> dist(0, 10);

    std::map<int, int> hist;
    for (int n = 0; n < 10000; ++n) {
        ++hist[std::floor(dist(gen))];
    }

    for (auto p : hist) {
        std::cout << std::fixed << std::setprecision(1) << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*') << '\n';
    }
}

兰德（）

如果你必须使用rand()，那么我们可以去C常见问题解答关于如何生成浮点随机数的指南?，它基本上给出了一个类似于在区间[0,1)上生成一个的例子:

#include <stdlib.h>

double randZeroToOne()
{
    return rand() / (RAND_MAX + 1.);
}

并生成一个范围为[M,N)的随机数:

double randMToN(double M, double N)
{
    return M + (rand() / ( RAND_MAX / (N-M) ) ) ;  
}

drand48(3)是POSIX的标准方法。GLibC还提供了一个可重入版本drand48_r(3)。

该函数在SVID 3中被宣布过时，但没有提供足够的替代方案，因此IEEE Std 1003.1-2013仍然包含它，并且没有说明它将很快消失。

在Windows中，标准的方法是CryptGenRandom()。

对于c++，它可以在dist变量指定的范围内生成实浮点数

#include <random>  //If it doesnt work then use   #include <tr1/random>
#include <iostream>

using namespace std;

typedef std::tr1::ranlux64_base_01 Myeng; 
typedef std::tr1::normal_distribution<double> Mydist;

int main() { 
       Myeng eng; 
       eng.seed((unsigned int) time(NULL)); //initializing generator to January 1, 1970);
       Mydist dist(1,10); 

       dist.reset(); // discard any cached values 
       for (int i = 0; i < 10; i++)
       {
           std::cout << "a random value == " << (int)dist(eng) << std::endl; 
       }

       return (0);
}