generating and storing random arrays in c++ - c++

Question

I am working on a program which takes the initial array as an input and then randomly generates 10 random arrays from the initial array.
I have written a function to generate a single random array from the initial array.
However,I am unable to develop a code which calls this function in the main function and generates 10 such random arrays.I will also be using these 10 randomly generated arrays for further calculation in the main function.
Since my knowledge of C++ is limited for now,I am not aware of using vectors for dynamic allocation.It would be of great help if anyone can guide be regarding the code to be used in the main function.
Here int initial[] is the first array used to generate 10 other random arrays using the int *newparents() function. When the newparents() function is called in main it returns one randomly shuffled array.
I would request your help in generating 10 random arrays in the main function by calling the newparents() function and then storing them for further use.
Code :
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;
}
Thank you for your help.

Answer 1

A simple way to do this using 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;
}
Output :
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
Note : I am creating a new tempArray only because I think you do not want to alter the intial vector. If that is not a case for you then, you can just shuffle the initial array itself and add it to the vector of vectors.

Answer 2

To create array of 10 pointers to the shuffled arrays using your code you can simply:
int *arr[10];
for (int i = 0; i < 10; ++i)
arr[i] = newparents();
int *arr[10]; will create array of 10 pointers to int, which is what what your newparents(); function returns, a pointer to the first int of shuffled array.
Since you allocated those arrays on the heap, make sure you free that memory once finished with them:
for (int i = 0; i < 10; ++i)
delete[] arr[i];

Answer 3

I have written a function to generate a single random array from the initial array.
No, you wrote a function to shuffle the initial array in place and then copy it. This is frankly a bit odd, because I don't see why you want to mutate the global in-place (after the first time you call your function, the global array is still called "initial" but is no longer in its initial state).
Since my knowledge of C++ is limited for now,I am not aware of using vectors for dynamic allocation.
The whole point is that std::vector handles all the allocation for you, avoiding the memory leaks and manual copying in your current code.
If you take the time to use C++ properly, instead of trying to write C in C++, the code is pretty trivial:
#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";
}
}