C 生成一个随机字节流

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

下面是函数：

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

是的，你在C中有函数

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

这个数字是由一个算法生成的，该算法每次调用时都返回一个显然不相关的数字序列。该算法使用种子生成序列，序列应该使用函数初始化为某个不同的值

编辑：

在您发表评论时，我为您编写了一段代码，可以帮助您演示如何使用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;
} 

---

对于每个字节，可以调用随机数生成器函数。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));

#包括
#包括
无符号字符*gen\u rdm\u字节流（大小\u t num\u字节）
{
无符号字符*流=malloc（num_字节）；
尺寸i；
对于（i=0；i

---

由于

stream

是无符号的，如果

rand

返回的值大于

UCHAR\u MAX

，则她将减小（模

UCHAR\u MAX

）。因此，您将得到介于0和255之间的伪随机数。

这里有一个用于在给定范围内生成随机整数值的通用函数：

#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 );
}

所以

for（i=0；i

以下是一个实际的流（std:：istream），使用C++11库

写这篇文章并不是为了快速，但它很有趣：

#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;
}

#包括
#包括
#包括

只是添加了一些类：

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(); }
};

类StreamHasherBuf:public std:：streambuf
{
私人：
大小\u t m\u散列；
std:：array m_buf；//结果哈希值是数组大小的函数！
静态constexpr size\u t bufsize=std:：tuple\u size\u v；
无效添加和重置放置区域（）
{
boost:：hash_combine（m_hash，boost:：hash_range（pbase（），pptr（））；
setp（&m_-buf[0]，&m_-buf[bufsize]）；
}
受保护的：
int_类型溢出（int_类型c）重写
{
如果（c！=EOF）
{
如果（pptr（）==epptr（））
添加和重置放置区域（）；
*pptr（）=c；
pbump（1）；
}
返回0；
}
公众：
StreamHasherBuf（）：m_hash（0）{setp（&m_buf[0]，&m_buf[bufsize]）；}
大小\u t散列（）
{
添加和重置放置区域（）；
返回m_散列；
}
};
类StreamHasher:public std:：ostream
{
私人：
StreamHasherBuf m_streambuf；
公众：
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';
}

intmain（）
{
RandomBuf random（100，'a'，'z'）；//创建一个streambuf，在间隔['a'，'z']内生成100个伪随机字符。
流哈希器；
hasher您可能想尝试使用一个标准库函数，在
malloc
之后返回随机数。内存在某种意义上已经是
random
。它不是真正随机的，而是充满了垃圾。我认为它应该足够用于测试，我认为您不需要加密强随机生成器。这是
int
，它是4字节的s@user138126
int
大小取决于C中的平台。在Linux系统中，可以使用sizeof（int）检查其大小operator@user138126系统上的是查看此代码输出：如果
srand（nr）中的
nr
是固定的，那么生成的字节总是相同的，无论平台是什么，对吗？@user138126:不一定，因为每个平台都不具有相同的随机数生成器。但是，例如，使用函数
time
可以解决问题。您可以放弃rand（）和srand（）而使用arc4random（）为了更好的结果。
#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;
}

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';
}