Question

我正在开发一个程序，它将初始数组作为输入，然后从初始数组中随机生成10个随机数组。

我编写了一个从初始数组生成单个随机数组的函数。

但是，我无法开发一个在main函数中调用此函数的代码，并生成10个这样的随机数组。我还将使用这10个随机生成的数组在main函数中进一步计算。

由于我目前对C ++的了解有限，我不知道使用向量进行动态分配。如果有人可以指导在主函数中使用的代码，那将会有很大的帮助。

此处int initial[]是第一个使用int *newparents()函数生成10个其他随机数组的数组。当在main中调用newparents()函数时，它返回一个随机洗牌的数组。

我会请求你帮助在main函数中生成10个随机数组，方法是调用newparents()函数然后存储它们以供进一步使用。

代码：

int initial[] =
{ 10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200 };
int size = sizeof(initial) / sizeof(initial[0]);

int *newparents()
{
    int *pt = new int[size];
    random_shuffle(&initial[0], &initial[size]);
    for (unsigned i = 0; i<size; i++)
    {
        pt[i] = initial[i];
    }
    return pt;
}

int main()
{
    int *p;
    p = newparents();
    cout << "p1=" << " ";
    for (int i = 0; i<size; i++)
    {
        cout << *(p + i) << " ";
    }
    return 0;
}

感谢您的帮助。

Answer 1

使用std::vector执行此操作的简单方法：

#include <iostream>
#include <vector>
#include <algorithm>

std::vector< std::vector<int> >
GenerateRandomArrays( std::vector<int> const & inInitialArray, int inNumberOfArrays)
{
    std::vector<std::vector<int> > generatedArrays;
    std::vector<int> tempArray(inInitialArray);
    for (int i = 0; i < inNumberOfArrays; i++)
    {
        std::random_shuffle(tempArray.begin(), tempArray.end());
        generatedArrays.push_back(tempArray);
    }
    return generatedArrays;
}

int main() {
    // Creates the initial array.
    std::vector<int> initial{ 10,20,30,40,50 };
    auto blah = GenerateRandomArrays(initial, 10);
    return 0;
}

输出：

50  20  40  30  10
50  40  30  10  20
20  10  30  50  40
30  40  20  10  50
30  50  20  10  40
20  50  10  40  30
50  30  20  10  40
30  40  20  10  50
20  10  50  40  30
20  50  10  40  30

注意：我正在创建新的tempArray，因为我认为您不想更改intial向量。如果那不是你的情况那么，你可以将initial数组本身洗牌并将其添加到向量向量中。

Answer 2

要使用您的代码创建指向混洗数组的10个指针数组，您可以简单地：

int *arr[10];
for (int i = 0; i < 10; ++i)
    arr[i] = newparents();

int *arr[10];将创建指向int的10个指针的数组，这是您的newparents();函数返回的指针，指向第一个int混洗数组的指针。

由于您在堆上分配了这些数组，因此请确保在完成后释放该内存：

for (int i = 0; i < 10; ++i)
    delete[] arr[i];

Answer 3

我编写了一个从初始数组生成单个随机数组的函数。

不，您编写了一个函数来将初始数组混洗到位，然后复制它。坦率地说这有点奇怪，因为我不明白你为什么想要在全局内变异（在第一次调用你的函数之后，全局数组仍被称为“初始”但不再处于初始状态）。

由于我目前对C ++的了解有限，我不知道使用向量进行动态分配。

重点是std::vector为您处理所有分配，避免了当前代码中的内存泄漏和手动复制。

如果您花时间正确使用C ++，而不是尝试在C ++中编写C语言，那么代码就非常简单：

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

// let's avoid mutating our global state
const std::vector<int> Seeds =
{10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200};

// this shuffles a copy of the argument passed
std::vector<int> shuffle(std::vector<int> v) {
    std::random_shuffle(begin(v), end(v));
    return v;
}

// return n independently-shuffled copies of "initial"
std::vector<std::vector<int>> shuffle_n(size_t n,
                                        std::vector<int> const& initial) {
    std::vector<std::vector<int>> result(n);
    std::generate_n(begin(result), n,
                    [&initial]() {
                        return shuffle(initial);
                    });
    return result;
}

int main() {
    // one line to create 10 shuffled vectors
    auto allparents = shuffle_n(10, Seeds);

    // and one loop to print them all
    for (auto &v : allparents) {
        std::cout << '{';
        std::copy(begin(v), end(v),
                  std::ostream_iterator<int>(std::cout, " "));
        std::cout << "}\n";
    }
}

在c ++中生成和存储随机数组

3 个答案: