c - 生成随机字节流

Question

我正在测试一个使用 UDP/TCP 将数据包发送到远程服务器的网络程序，为此，我想生成一些随机字节流。

这是功能：

unsigned char *gen_rdm_bytestream(int num_bytes)
{
    unsigned char *stream = malloc(num_bytes);
    /*
     * here how to generate?
     */
    return stream;
}

Answer 1

对于每个字节，您可以调用一个随机数生成器函数。C 标准提供了函数rand。在使用它之前，您应该通过调用来初始化随机序列srand。

gen_rdm_bytestream然后可能看起来像这样：

#include <stdlib.h>
#include <time.h>

unsigned char *gen_rdm_bytestream (size_t num_bytes)
{
  unsigned char *stream = malloc (num_bytes);
  size_t i;

  for (i = 0; i < num_bytes; i++)
  {
    stream[i] = rand ();
  }

  return stream;
}

srand ((unsigned int) time (NULL));

由于stream是无符号的，如果返回的值rand大于UCHAR_MAX，她将被减少（模UCHAR_MAX）。因此，您将获得 0 到 255 之间的伪随机数。

Answer 2

是的，你int rand (void);在 C 中有函数，

返回介于 0 和 RAND_MAX 之间的伪随机整数。RAND_MAX 是 <cstdlib> 中定义的常数。

这个数字是由一种算法生成的，每次调用它时都会返回一系列明显不相关的数字。该算法使用种子生成系列，应使用函数srand() 将其初始化为某个独特的值。

编辑：

正如您评论的那样，我为您编写了一个代码，可以帮助您演示如何使用 rand()，该程序及其输出是：

#include <stdio.h>     
#include <stdlib.h>  /* srand, rand */
#include <time.h>    
int main (){
 int i=0;
 srand (time(NULL));
 printf("Five rand numbers: \n");
 for(i = 1; i <= 5; i++){
   printf("\n %d", rand());
 }
 printf("Five rand numbersb between 2 to 5: \n");
 for(i = 1; i <= 5; i++){
   printf("\n %d", (2 + rand()%4));
 }    
 return 1;
} 

输出：

 Five rand numbers: 

 1482376850
 1746468296
 1429725746
 595545676
 1544987577

 Five rand numbers, between 2 to 5: 

 2
 5
 3
 4
 3

键盘链接

Answer 3

这是在给定范围内生成随机整数值的通用函数：

#include <stdlib>

/**
 * Assumes srand has already been called
 */
int randInRange( int min, int max )
{
  double scale = 1.0 / (RAND_MAX + 1);
  double range = max - min + 1;
  return min + (int) ( rand() * scale * range );
}

利用它来创建无符号char值：

u_char randomByte()
{
  return (u_char) randInRange( 0, 255 );
}

所以，

for ( i = 0; i < numBytes; i++ )
  stream[i] = randomByte();

Answer 4

以下是一个实际流 (std::istream) 并使用 C++11 <random> 库。

这并不是写得特别快，但它很有趣：

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

class RandomBuf : public std::streambuf
{
 private:
  size_t m_size;
  std::array<char, 64> m_buf;
  std::mt19937_64 m_twister;
  std::uniform_int_distribution<char> m_dist;

 protected:
  int_type underflow() override {
    if (m_size == 0)
      return EOF;

    size_t size = std::min(m_size, m_buf.size());
    setg(&m_buf[0], &m_buf[0], &m_buf[size]);
    for (size_t i = 0; i < size; ++i)
      m_buf[i] = m_dist(m_twister);
    m_size -= size;
    return 0;
  }

 public:
  RandomBuf(size_t size, char b, char e) : m_size(size), m_dist(b, e) { }
};

class Random : public std::istream
{
  private:
   RandomBuf m_streambuf;

  public:
   Random(size_t size, char b, char e) : m_streambuf(size, b, e)  {
     rdbuf(&m_streambuf);
   }
};

// Example usage:

int main()
{
  Random random(100, 'a', 'z'); // Create an istream that produces 100 pseudo-random characters in the interval ['a', 'z'].
  // Read random stream to a string:
  std::string str;
  random >> str;
  // Print result.
  std::cout << str << std::endl;
}

该程序的输出（确切地说，因为标准保证默认构造的 Mersenne twister 具有给定的种子）：

ugsyakganihodonwmktggixegfszuclgupylingbnscxadzqhjmhhyqtssbmctlpchqfflzfwhvjywmajtnkaxczrmtpnlvwmzxd

编辑：

对于额外的奖励积分，我添加了一个 StreamHasher 类： https ://wandbox.org/permlink/bIDCVTnJjkdafARo

只是添加的类：

class StreamHasherBuf : public std::streambuf
{
 private:
  size_t m_hash;
  std::array<char, 64> m_buf;   // The resulting hash value is a function of the size of the array!
  static constexpr size_t bufsize = std::tuple_size_v<decltype(m_buf)>;

  void add_and_reset_put_area()
  {
    boost::hash_combine(m_hash, boost::hash_range(pbase(), pptr()));
    setp(&m_buf[0], &m_buf[bufsize]);
  }

 protected:
  int_type overflow(int_type c) override
  {
    if (c != EOF)
    {
      if (pptr() == epptr())
        add_and_reset_put_area();
      *pptr() = c;
      pbump(1);
    }
    return 0;
  }

 public:
  StreamHasherBuf() : m_hash(0) { setp(&m_buf[0], &m_buf[bufsize]); }

  size_t hash()
  {
    add_and_reset_put_area();
    return m_hash;
  }
};

class StreamHasher : public std::ostream
{
 private:
  StreamHasherBuf m_streambuf;

 public:
  StreamHasher() { rdbuf(&m_streambuf); }
  size_t hash() { return m_streambuf.hash(); }
};

例如

int main()
{
  RandomBuf random(100, 'a', 'z'); // Create a streambuf that produces 100 pseudo-random characters in the interval ['a', 'z'].
  StreamHasher hasher;
  hasher << &random;
  std::cout << hasher.hash() << '\n';
}