How do I input random numbers in C++ array?

Question

#include <iostream>
#include <ctime>


using namespace std;
int randBetween()
{
    
    unsigned seed = time(0);
    srand(seed);
    
    const int MIN_VALUE = -100;
    const int MAX_VALUE = 100;
    
    return (rand() % (MAX_VALUE - MIN_VALUE + 1 )) + MIN_VALUE;
}




int main() {
   
    const int SIZE = 10;
    
    int myArray[SIZE];
    
    
    // ^^ how do I use function above to give myArray random values?
    
    return 0;
}

I wanna use that rand function to give my array random values from -100 to 100 but I dont know how to put that rand function in the array so that my array can generate random number inside it hopefully that makes sense how do I do that?

Answer 1

First we'll take a look at your code and critique it.

#include <iostream>
#include <ctime>
// MISSING <cstdlib> for C random functions

using namespace std;  // Bad Practice
int randBetween()
{
    
    unsigned seed = time(0);  // Wrong placement; should only instantiate ONCE
    srand(seed);
    
    const int MIN_VALUE = -100;
    const int MAX_VALUE = 100;
    
    return (rand() % (MAX_VALUE - MIN_VALUE + 1 )) + MIN_VALUE;
    // Modulo math tends to make the values in the lower end of the range more prevalent; i.e., 
    // it's not very uniform.
}




int main() {
   
    const int SIZE = 10;  // All caps names for constants is not desirable; they can be confused for macros
    
    int myArray[SIZE];  // Prefer std::array if the size is known, else std::vector for most cases
    
    
    // ^^ how do I use function above to give myArray random values?
    
    return 0;
}

The biggest issue is the use of C-style conventions when C++ provides better methods. In fact, you won't even need a function for this.

The secret sauce of getting the random numbers into your array is a loop. Make your loop visit every element and assign a new random number. Either directly, as in my first example, or by using a function as in my second example.

#include <array>
#include <iostream>
#include <random>

int main() {
  const int minValue = -100;
  const int maxValue = 100;
  const int size = 10;

  std::array<int, size> myArray;

  // std::mt19937 is the goto PRNG in <random>
  // This declaration also seeds the PRNG using std::random_device
  // A std::uniform_int_distribution is exactly what it sounds like
  // Every number in the range is equally likely to occur.
  std::mt19937 prng(std::random_device{}());
  std::uniform_int_distribution<int> dist(minValue, maxValue);

  for (auto& i : myArray) {
    i = dist(prng);
  }

  for (auto i : myArray) {
    std::cout << i << ' ';
  }
  std::cout << '\n';
}

Now, if you want or need the function, there's a little bit of extra work that needs to be done.

#include <array>
#include <iostream>
#include <random>

int randBetween() {
  const int minValue = -100;
  const int maxValue = 100;

  // The keyword static is required now so that the PRNG and distribution
  // are not re-instantiated every time the function is called. This is
  // important for them both to work as intended. Re-instantiating resets
  // their state, and they constantly start from scratch. They must be allowed
  // to persist their state for better results.
  static std::mt19937 prng(std::random_device{}());  // Note the static
  static std::uniform_int_distribution<int> dist(minValue, maxValue);

  return dist(prng);
}

int main() {
  const int size = 10;

  std::array<int, size> myArray;
  for (auto& i : myArray) {
    i = randBetween();
  }

  for (auto i : myArray) {
    std::cout << i << ' ';
  }
  std::cout << '\n';
}

Separating the PRNG from the distribution is good practice, especially when programs get larger. Then your single PRNG can feed multiple distributions if needed.

One output that I got:

-2 -37 81 85 -38 -62 31 -15 -12 -31

Answer 2

Rolling up the comments into an answer:

You could use a loop:

for (size_t i = 0; i < SIZE; ++i)
{
    myArray[i] = randBetween();
}

Or you could use the standard algorithm std::generate:

std::generate(std::begin(myArray), std::end(myArray), randBetween);

This will loop over the array, calling randBetween for each member and assigning it to the result.

You have a big issue, however. You should not call srand each time you want a random number. Call it once, in the beginning of main. As you have it now, you will likely fill the array with one number for a given run. There is a tiny chance the number will change part way through the array if the second of the current time changes during the program run.

Also the C++ Standard Library for random numbers is much preferable to rand. And I'd recommend using a standard container rather than a native array.

Answer 3

An alternate way would be to use PRNG(Pseudo Random Number Generator). This is from the include random, include functional header. Like this, run this in C++17 compiler:

#include <iostream>
#include <random>
#include <functional> // For std::bind()


auto createUniformPseudoRandomNumberGenerator(double max)
{
 std::random_device seeder; 
 std::default_random_engine generator{seeder()};
 std::uniform_real_distribution distribution{0.0, max};
 return std::bind(distribution, generator); 
}

int main() 
{

const int SIZE = 10;

int myArray[SIZE];


double limit{};
std::cout<<"Enter max number limit.\n";
std::cin>>limit;

static auto random_number=createUniformPseudoRandomNumberGenerator(limit);

for (size_t i{};i<SIZE;++i)
{
    myArray[i]=  random_number();
}


return 0;
}

Link : https://onlinegdb.com/686M8KB1p