Question

对于我的一个应用程序，我需要生成大小为2 ^ 35的向量（我的RAM大小为96 GB，因此该向量可以很容易地放入RAM中）。

int main ()
{
  int i;

  /* initialize random seed: */
  srand (time(NULL));

  vector<int> vec;
  do {
     i = rand() % 10 + 1;
     vec.push_back(i);
  } while ((vec.size()*sizeof(int))<pow(2,35));

  return 0;
}

但是，我注意到我的do while循环无限执行。其中一个可能的原因是vec.size()的范围是长无符号整数，它远小于插入的元素数pow(2,35)，因此我认为它在无限循环中。我可能错了。如果我错了，请纠正我。但有人可以告诉我如何在vec中插入大于pow(2,35)的数字。

gcc版本：4.8.2

Answer 1

我会尝试在一个简单的解决方案中解决您的一些问题：

你遇到的第一个问题是空间。由于您只需要1-10的数字，因此int8_t会更好地为您服务。

第二是速度。 std::vector做了大量的分配和重新分配。由于你有一个固定的尺寸，在我看来，没有必要使用它。知道这一点，我们将使用一个简单的数组和线程来提高性能。

以下是代码：

#include <array>
#include <random>
#include <thread>
#include <cstdint>
#include <memory>
#include <chrono>

// Since you only need numbers from 1-10, a single byte will work nicely.
const uint64_t size = UINT64_C(0x800000000); // Exactly 2^35
typedef std::array<int8_t, size> vec_t;

// start is first element, end is one-past the last. This is a template so we can generate multiple functions.
template<unsigned s>
void fill(vec_t::iterator start, vec_t::iterator end) {
    static const int seed = std::chrono::system_clock::now().time_since_epoch().count()*(s+1);
    static std::default_random_engine generator(seed);
    static std::uniform_int_distribution<int8_t> distribution(1,10);
    for(auto it = start; it != end; ++it) {
        *it = distribution(generator);  // generates number in the range 1..10
    }
}

int main() {
    auto vec = std::unique_ptr<vec_t>(new vec_t());

    // Each will have its own generator and distribution.
    std::thread a(fill<0>, vec->begin(), vec->begin() + size/4);
    std::thread b(fill<1>, vec->begin() + size/4, vec->begin() + size/2);
    std::thread c(fill<2>, vec->begin() + size/2, vec->begin() + (size/4)*3);
    std::thread d(fill<3>, vec->begin() + (size/4)*3, vec->end());
    a.join();
    b.join();
    c.join();
    d.join();
    return 0;
}

Answer 2

为什么不能使用构造函数？

std::vector<int> vec ( number_of_elements );

这样你就可以保留内存，然后你可以使用generate或其他东西来随机化元素。

Answer 3

<强>更新

正如Baum mit Augen所强调的那样，这篇文章并没有真正回答这个问题，因为在他的平台条件下4并不成立（sizeof(std::size_t)实际上是8）。但是，我在此留言是为了突出显示移植代码时可能出现的问题。

原帖

我看到的一个问题如下。让我们假设（大多数平台都满足这些假设）

1）vec.size返回std::size_t（无法保证）;

2）sizeof返回std::size_t（保证）;

3）std::size_t是无符号整数类型（保证）;

4）sizeof(std::size_t) == 4（不保证）;

5）CHAR_BIT == 8（不保证）。

（回想一下，CHAR_BIT是char中的位数。）

因此，vec.size()*sizeof(int)的类型为std::size_t，其最大值为2^(sizeof(std::size_t)*CHAR_BIT) - 1 == 2^32 - 1 < 2^32 < 2^35。因此，vec.size()*sizeof(int)始终小于2^35。

在std :: vector c ++中存储许多元素

3 个答案: